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

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工作正常。如果我将进口改为相对进口)

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

为什么会出现此错误？情况与上面的情况大不相同吗？

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

Answer 1

首先让我们从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先翻译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，如果ImportError该属性不存在，则引发否则返回此属性。

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

很好的相对导入from . import b例如在OP问题中等价from pkg import b。

但是，这是怎么发生的呢？为了理解这一点，我们应该import.c特别关注python的模块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 in pkg/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.py已经导入了，这意味着('pkg.a' in sys.modules) == True导入将被跳过，仅getattr(pkg, 'a')将调用，但是会发生什么呢？python尚未完成导入pkg/a.py！因此，只会getattr(pkg, 'a')调用，这将AttributeError在import_from()函数中引发，并将其转换为ImportError(cannot import name a)。

免责声明 ：这是我自己的工作，以了解口译员内部发生的事情，我远不是专家。

EDIt： 改写了这个答案，因为当我再次尝试阅读它时，我指出了我的答案是不好的，希望现在它会更有用:)