循环模块依赖关系和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 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,如果它不存在则引发ImportError其他返回此属性.

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

相对导入就好from . import b,例如在OP问题中的情况from pkg import b.

但是这怎么发生？要理解这一点,我们应该import.c特别关注函数get_parent()的python模块.正如你所看到的那样,函数很安静很长,但是一般来说,当它看到相对导入时它会尝试.用父包替换dot 取决于__main__模块,这也是OP问题的一部分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在这种情况下会发生第二次导入,那就是有趣的部分,这是导入子句中模块的导入.所以再次在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:这个答案被改写了,因为当我再次尝试阅读时,我评论我的答案是如何制定的,希望现在它会更有用:)