39

假设我们有两个具有循环依赖的模块：

# a.py
import b
def f(): return b.y
x = 42


# b.py
import a
def g(): return a.x
y = 43

这两个模块都在pkg一个空的目录中__init__.py。导入pkg.a或pkg.b工作正常，如this answer中所述。如果我将进口更改为相对进口

from . import b

我ImportError在尝试导入其中一个模块时得到一个：

>>> import pkg.a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "pkg/a.py", line 1, in <module>
    from . import b
  File "pkg/b.py", line 1, in <module>
    from . import a
ImportError: cannot import name a

为什么我会收到此错误？情况不是和上面差不多吗？（这与这个问题有关吗？）

编辑：这个问题与软件设计无关。我知道避免循环依赖的方法，但无论如何我对错误的原因很感兴趣。

4

3 回答 3

36

首先让我们从from importpython 的工作原理开始：

那么首先让我们看一下字节码：

>>> def foo():
...     from foo import bar

>>> dis.dis(foo)
2           0 LOAD_CONST               1 (-1)
              3 LOAD_CONST               2 (('bar',))
              6 IMPORT_NAME              0 (foo)
              9 IMPORT_FROM              1 (bar)
             12 STORE_FAST               0 (bar)
             15 POP_TOP             
             16 LOAD_CONST               0 (None)
             19 RETURN_VALUE

嗯很有趣:)，所以from foo import bar被翻译为 first IMPORT_NAME foo，相当于import foo然后IMPORT_FROM bar。

现在怎么IMPORT_FROM办？

让我们看看python在他发现时做了什么IMPORT_FROM：

TARGET(IMPORT_FROM)
     w = GETITEM(names, oparg);
     v = TOP();
     READ_TIMESTAMP(intr0);
     x = import_from(v, w);
     READ_TIMESTAMP(intr1);
     PUSH(x);
     if (x != NULL) DISPATCH();
     break;

好吧，基本上他得到了要导入的名称，这在我们的foo()函数 will be 中bar，然后他从帧堆栈中弹出v最后一个执行的操作码的返回值 is IMPORT_NAME，然后import_from()使用这两个参数调用函数：

static PyObject *
import_from(PyObject *v, PyObject *name)
{
    PyObject *x;

    x = PyObject_GetAttr(v, name);

    if (x == NULL && PyErr_ExceptionMatches(PyExc_AttributeError)) {
        PyErr_Format(PyExc_ImportError, "cannot import name %S", name);
    }
    return x;
}

如您所见，该import_from()功能很简单，它首先尝试name从模块中获取属性v，如果它不存在，则引发ImportError否则返回此属性。

现在这与相对导入有什么关系？

from . import b例如，在 OP 问题中的相对导入等价于from pkg import b.

但这是怎么发生的？要理解这一点，我们应该看一下import.cpython 的模块，特别是函数get_parent()。如您所见，该函数在这里列出的时间很长，但一般来说，当它看到相对导入时，它会.根据__main__模块尝试用父包替换点，这再次来自 OP 问题是 package pkg。

现在让我们把所有这些放在一起，并试图弄清楚为什么我们最终会出现 OP 问题中的行为。

为此，如果我们能看到 python 在导入时做了什么，这将对我们有所帮助，这是我们幸运的一天，python 已经有了这个功能，可以通过在额外详细模式下运行它来启用它-vv。

所以使用命令行python -vv -c 'import pkg.b'：：

Python 2.6.5 (r265:79063, Apr 16 2010, 13:57:41) 
[GCC 4.4.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.

import pkg # directory pkg
# trying pkg/__init__.so
# trying pkg/__init__module.so
# trying pkg/__init__.py
# pkg/__init__.pyc matches pkg/__init__.py
import pkg # precompiled from pkg/__init__.pyc
# trying pkg/b.so
# trying pkg/bmodule.so
# trying pkg/b.py
# pkg/b.pyc matches pkg/b.py
import pkg.b # precompiled from pkg/b.pyc
# trying pkg/a.so
# trying pkg/amodule.so
# trying pkg/a.py
# pkg/a.pyc matches pkg/a.py
import pkg.a # precompiled from pkg/a.pyc
#   clear[2] __name__
#   clear[2] __file__
#   clear[2] __package__
#   clear[2] __name__
#   clear[2] __file__
#   clear[2] __package__
...
Traceback (most recent call last):
  File "<string>", line 1, in <module>
  File "pkg/b.py", line 1, in <module>
    from . import a
  File "pkg/a.py", line 2, in <module>
    from . import a
ImportError: cannot import name a
# clear __builtin__._

嗯之前发生了ImportError什么？

首先) from . import a inpkg/b.py被调用，如上面解释的那样被翻译成from pkg import a，在字节码中再次等价于import pkg; getattr(pkg, 'a'). 但是等一下a也是一个模块？！那么有趣的部分来了，如果我们from module|package import module在这种情况下会发生第二次导入，即在 import 子句中导入模块。所以再次在 OP 示例中，我们现在需要导入pkg/a.py，正如您所知，首先我们sys.modules为新模块设置密钥，pkg.a然后我们继续解释模块pkg/a.py，但在模块pkg/a.py完成导入之前调用from . import b.

现在是第二个）部分，pkg/b.py它将被导入，然后它会首先尝试import pkg，因为pkg已经导入，所以我们有一个键pkg，sys.modules它只会返回该键的值。然后它将import b设置pkg.b密钥sys.modules并开始解释。我们到达这条线from . import a！

但请记住pkg/a.pyis 已经导入，这意味着('pkg.a' in sys.modules) == True导入将被跳过，只会getattr(pkg, 'a')调用 ，但会发生什么？python没有完成导入pkg/a.py！？所以 onlygetattr(pkg, 'a')会被调用，这会AttributeError在import_from()函数中引发一个，它会被翻译成ImportError(cannot import name a).

免责声明：这是我自己努力了解口译员内部发生的事情，我离成为专家还很遥远。

编辑：这个答案被改写了，因为当我试图再次阅读它时，我注意到我的答案是如何表述错误的，希望现在它会更有用:)

于 2011-06-16T20:41:46.433 回答
4

（顺便说一句，相对导入无关紧要。使用from pkg import... 揭示了同样的例外。）

from foo import bar我认为这里发生的事情是和之间的区别在于import foo.bar，在第一个中，值bar可以是 pkg 中的 module ，也可以是 module 中foo的变量foo。在第二种情况下，bar除了模块/包之外的任何东西都是无效的。

这很重要，因为如果已知 bar 是一个模块，那么它的内容sys.modules就足以填充它。如果它可能是foo模块中的一个变量，那么解释器实际上必须查看 的内容foo，但是在导入foo时，那将是无效的；实际模块尚未填充。

在相对导入的情况下，我们理解from . import bar为从包含当前模块的包中导入 bar 模块，但这实际上只是语法糖，.名称被转换为完全限定名称并传递给__import__()，因此看起来对于所有的世界，就像模棱两可的from foo import bar

于 2011-06-15T03:38:11.567 回答
1

作为附加说明：

我有以下模块结构：

base
 +guiStuff
   -gui
 +databaseStuff
   -db
 -basescript

我希望能够通过 运行我的脚本import base.basescript，但是由于gui文件有一个import base.databaseStuff.db导致导入base. 因为base只注册了，因为__main__它导致了整个导入的第二次执行和上面的错误，除非我使用上面的外部脚本，base因此只导入base/basescript一次。为了防止这种情况，我在我的基本脚本中加入了以下内容：

if  __name__ == '__main__' or \
  not '__main__' in sys.modules or \
  sys.modules['__main__'].__file__ != __file__: 
    #imports here
于 2012-05-31T18:37:50.190 回答