Question

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

# 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

为什么会出现此错误？情况不是和上面差不多吗？（这与this question相关吗？）

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

Answer 1

首先让我们从from import在python中的工作方式开始：

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

>>> 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被翻译为第一个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()函数中将是bar，然后他从帧堆栈弹出值v，这是返回执行的最后一个操作码是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，如果它不存在则会引发{{1} }} else返回此属性。

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

像ImportError这样的相对导入是相同的，例如在OP from . import b的OP问题中。

但这是怎么发生的？为了理解这一点，我们应该特别关注函数import.c的get_parent()模块。正如您所看到的那样，函数很安静很长，但是一般来说，当它看到相对导入时它会尝试用父包替换点from pkg import b，具体取决于.模块，再来自OP问题的是包__main__。

现在让我们将所有这些放在一起，并试图找出为什么我们最终得到OP问题中的行为。

为此，如果我们可以看到python在进行导入时会做什么，它将对我们有所帮助。好吧，我们的幸运日python已经具备了这个功能，可以通过在额外的详细模式pkg中运行它来启用。

所以使用命令行：-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，如上所述将其翻译为pkg/b.py，再次使用字节码相当于{{1} }}。但等一下from pkg import a也是一个模块？！好吧，如果我们在这种情况下有类似import pkg; getattr(pkg, 'a')之类的东西，那么有趣的部分会发生第二次导入，这是导入子句中模块的导入。再次在OP示例中，我们现在需要导入a，首先我们在from module|package import module中为我们的新模块设置一个关键字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.py，但会发生什么？ python没有完成导入('pkg.a' in sys.modules) == True！因此，只会调用getattr(pkg, 'a')，这会在pkg/a.py函数中引发getattr(pkg, 'a')，该函数将转换为AttributeError。

免责声明：这是我自己努力了解翻译中发生的事情，我远没有成为专家。

EDIt：这个答案被改写了，因为当我再次尝试阅读时，我评论了我的答案是如何制定的，希望现在它会更有用:)

Answer 2

（在某种程度上，相对导入并不重要。使用from pkg import ...会显示相同的异常。）

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

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

在相对导入的情况下，我们理解from . import bar意味着从包含当前模块的包中导入bar模块，但这实际上只是语法糖，.名称被翻译到一个完全限定的名称并传递给__import__()，因此它寻找所有的世界，如暧昧的from foo import bar

Answer 3

作为补充说明：

我有以下模块结构：

base
 +guiStuff
   -gui
 +databaseStuff
   -db
 -basescript

我希望能够按import base.basescript运行我的脚本，但由于gui文件有import base.databaseStuff.db而导致导入base，因此失败并显示错误。由于base仅注册为__main__，因此导致第二次执行整个导入和上述错误，除非我使用base上方的外部脚本，因此导入base / {{ 1}}只有一次。为了防止这种情况，我将以下内容放在我的基本脚本中：

basescript

循环模块依赖关系和Python中的相对导入

3 个答案: