blocks|key|91673|text|这就是为什么在大多数情况下在python中使用from+__+import+*被认为是不好的形式。要么使用from+__+import+myFunc，要么使用import+__+as+myLib。然后，当你需要从myLib的东西，它不会超越其他的东西。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|91674|有关在当前命名空间中查找内容的帮助，请查看pprint库、dir积木、当地人建的、和全球的内在。|91675|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/library/pprint.html|1|http://docs.python.org/library/functions.html#dir|2|http://docs.python.org/library/functions.html#locals|3|http://docs.python.org/library/functions.html#globals^0|N|G|1H|L|27|I|2Y|5|0|L|7|0|T|5|1|Z|5|2|15|6|3|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|14|8|@]|D|@$9|15|A|16|1|17]|$9|18|A|19|1|1A]|$9|1B|A|1C|1|1D]|$9|1E|A|1F|1|1G]]|E|$]]|$1|H|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]|P|$5|K|L|M|E|$N|Q]]|R|$5|K|L|M|E|$N|S]]|T|$5|K|L|M|E|$N|U]]]]

This is why it is considered bad form to use <code>from __ import *</code> in python in most cases. Either use <code>from __ import myFunc</code> or else <code>import __ as myLib</code>. Then when you need something from <code>myLib</code> it doesn't over lap something else.

For help finding things in the current namespace, check out the <a href="http://docs.python.org/library/pprint.html" rel="nofollow">pprint library</a>, <a href="http://docs.python.org/library/functions.html#dir" rel="nofollow">the dir builtin</a>, <a href="http://docs.python.org/library/functions.html#locals" rel="nofollow">the locals builtin</a>, <a href="http://docs.python.org/library/functions.html#globals" rel="nofollow">and the globals builtin</a>.

blocks|key|206847|text|不，from+blah+import+*定义的名称不保留来自何处的任何信息。这些值可能有一个线索，例如，类有一个__module__属性，但它们可能是在一个模块中定义的，然后从另一个模块导入，所以您不能指望它们就是您所期望的值。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|206848|entityMap^0|2|I|1K|A|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

No, the names defined by <code>from blah import *</code> don't retain any information about where they came from. The values might have a clue, for example, classes have a <code>__module__</code> attribute, but they may have been defined in one module, then imported from another, so you can't count on them being the values you expect.

blocks|key|91687|text|如果在解释器中调用方法本身，它将告诉您它的父模块是什么。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|91688|例如：|91689|>>>+from+collections+import+*
>>>+deque
<type+'collections.deque'>|code-block|syntax|javascript|91690|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

If you call the method itself in the interpreter it will tell you what it's parent modules are.

For example:

<pre><code>&gt;&gt;&gt; from collections import *
&gt;&gt;&gt; deque
&lt;type 'collections.deque'&gt;
</code></pre>

blocks|key|206878|text|例如，某种类型：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|206879|>>>+from+zope.interface.common.idatetime+import+*
>>>+print+IDate.__module__
'zope.interface.common.idatetime'
>>>+print+Attribute.__module__
'zope.interface.interface'|code-block|syntax|javascript|206880|Attribute的模块可能看起来令人惊讶，因为它不是从哪里导入的，而是定义了Attribute类型的地方。看看zope/interface/common/idatetype.py，我们看到：|offset|length|style|CODE|206881|from+zope.interface+import+Interface,+Attribute|206882|这解释了__module__的价值。从其他模块导入的类型的实例也会遇到问题。假设您创建了一个名为Attribute的att实例|206883|>>>+att+=+Attribute('foo')
>>>+print+att.__module__
'zope.interface.interface'|206884|同样，您正在学习类型来自何处，而不是定义变量的位置。|206885|很可能不使用通配符导入的最大原因是您不知道您得到了什么，它们会污染您的命名空间，并可能会破坏其他类型/变量。|206886|>>>+class+Attribute(object):
...++++foo+=+9
...
>>>+print+Attribute.foo
9
>>>+from+zope.interface.common.idatetime+import+*
>>>+print+Attribute.foo
Traceback+(most+recent+call+last):
++File+"<stdin>",+line+1,+in+<module>
AttributeError:+type+object+'Attribute'+has+no+attribute+'foo'|206887|即使今天import+*在没有冲突的情况下工作，也不能保证它不会在将来导入包的更新时发生。|206888|entityMap^0|0|0|0|9|13|9|1K|Y|0|0|4|A|1C|9|1M|3|0|0|0|0|0|4|8|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|14|8|@$I|15|J|16|K|L]|$I|17|J|18|K|L]|$I|19|J|1A|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1C|8|@$I|1D|J|1E|K|L]|$I|1F|J|1G|K|L]|$I|1H|J|1I|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1J|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1K|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1L|8|@]|9|@]|A|$]]|$1|W|3|X|5|D|7|1M|8|@]|9|@]|A|$E|F]]|$1|Y|3|Z|5|6|7|1N|8|@$I|1O|J|1P|K|L]]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]]|11|$]]

Sort-of, for example:

<pre><code>&gt;&gt;&gt; from zope.interface.common.idatetime import *
&gt;&gt;&gt; print IDate.__module__
'zope.interface.common.idatetime'
&gt;&gt;&gt; print Attribute.__module__
'zope.interface.interface'
</code></pre>

The module of the <code>Attribute</code> may seem surprising since that is not where you imported it from, but it is where the <code>Attribute</code> type was defined. Looking at <code>zope/interface/common/idatetype.py</code>, we see:

<pre><code>from zope.interface import Interface, Attribute
</code></pre>

which explains the value of <code>__module__</code>. You'll also run into problems with instances of types imported from other modules. Suppose that you create an <code>Attribute</code> instance named <code>att</code>:

<pre><code>&gt;&gt;&gt; att = Attribute('foo')
&gt;&gt;&gt; print att.__module__
'zope.interface.interface'
</code></pre>

Again, you're learning where the type came from, but not where the variable was defined.

Quite possibly the biggest reason to not use wildcard imports is that you don't know what you're getting and they pollute your namespace and possibly clobber other types/variables.

<pre><code>&gt;&gt;&gt; class Attribute(object):
... foo = 9
...
&gt;&gt;&gt; print Attribute.foo
9
&gt;&gt;&gt; from zope.interface.common.idatetime import *
&gt;&gt;&gt; print Attribute.foo
Traceback (most recent call last):
 File "&lt;stdin&gt;", line 1, in &lt;module&gt;
AttributeError: type object 'Attribute' has no attribute 'foo'
</code></pre>

Even if today the <code>import *</code> works without collision, there is no guarantee that it won't happen with future updates to the package being imported.

As an example, say I have a variable defined where there may be multiple 

<pre><code>from __ import *
from ____ import *
</code></pre>

etc.

Is there a way to figure out where one of the variables in the namespace is defined?

edit

Thanks, but I already understand that import * is often considered poor form. That wasn't the question though, and in any case I didn't write it. It'd just be nice to have a way to find where the variable came from.

in python, is there a way to find the module that contains a variable or other object from the object itself?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

例如，我定义了一个变量，其中可能存在多个变量。from __ import *from ____ import *等。是否有一种方法可以确定名称空间中的一个变量是在哪里定义的？编辑谢谢，但我已经明白导入*通常被认为是糟糕的形式。但这不是问题，而且无论如何我也没有写。如果能找到变量的来源，那就太好了。

问在python中，是否有方法从对象本身找到包含变量或其他对象的模块？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在python中，是否有方法从对象本身找到包含变量或其他对象的模块？EN