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()函数非常简单，它首先尝试从模块v中获取属性name，如果它不存在，它将引发ImportError，否则返回此属性。

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

例如，在OP问题中的情况下，像from . import b这样的相对导入等价于from pkg import b。

但这是怎么发生的呢？为了理解这一点，我们应该看看python的import.c模块，特别是函数get_parent（）。正如你所看到的，该函数在这里列出的时间很长，但通常情况下，当它看到相对导入时，它会尝试用父包替换点.，这取决于__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之前发生了什么

First）pkg/b.py中的from . import a被调用，如上所述被翻译为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已经导入，所以在我们的sys.modules中有一个密钥pkg，它将只返回该密钥的值。然后它将import b设置sys.modules中的pkg.b键并开始解释。我们到达这条线路from . import a！

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

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

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理解为从包含当前模块的包中导入条形模块，但这实际上只是语法糖，.名称被翻译为完全限定的名称并传递给__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/basescript一次。为了防止这种情况，我在我的基本脚本中放入了以下内容：

if  __name__ == '__main__' or 
  not '__main__' in sys.modules or 
  sys.modules['__main__'].__file__ != __file__: 
    #imports here