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

Posted 2023-02-24

【中文标题】Python中的循环模块依赖和相对导入

【英文标题】：Cyclic module dependencies and relative imports in Python

【发布时间】：2011-09-15 03:50:13

【问题描述】：

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

# 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有关吗？）

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

【问题讨论】：

如果 a 依赖于 b 而 b 依赖于 a 为什么不你在同一个文件中加入两者？

@JBernardo：文件会变得非常大，而且功能实际上已经很好地分割了。 b 在某些数据管道中实现稍后的处理步骤，并对 a 中的类型进行操作。在a 中，我向类中添加了一些便捷方法，这些方法将调用转发到b 中的函数。除此之外，我想对上述行为进行解释。

或者将这些便捷方法放在依赖于 a 和 b 的第三个模块中。

@Sven 我无法回答您的代码为什么不起作用，但正如我们所说，循环依赖是已知的软件反模式，应该避免 .

@JBernardo：嗯，我知道这一点，并在介绍循环之前仔细考虑过。我认为在这种情况下，通过便利方法改进界面比打破一些抽象原则更重要。请注意，如果我加入文件，循环依赖不会消失——它只是单个文件中的循环依赖。

【参考方案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        

hmm 很有趣 :)，所以 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 的情况。

但是这是怎么发生的呢？为了理解这一点，我们应该看一下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 之前发生了什么？

首先） 调用pkg/b.py 中的from . import a，如前所述将其翻译为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。

现在是 Second) 部分，pkg/b.py 将被导入，然后它将首先尝试import pkg，因为pkg 已经导入，所以有一个密钥@987654369 @ 在我们的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')，这会在import_from()函数中引发AttributeError，它会被翻译成ImportError(cannot import name a)。

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

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

【讨论】：

感谢您提供详细的答案并实际查看来源。我仍然不是很满意。有两件事让我感到困惑：1. 在您的观点 (1) 中，from pkg import b 被执行。为什么即使b 显然不在pkg 的命名空间中，它仍然有效？这不是和下一步from pkg import a一样的情况吗？ 2. 模块的循环依赖通常是有效的，因为在模块体执行之前，将空的模块对象插入sys.modules。为什么在模块体执行之前没有将空模块对象a插入到pkg中？

@seven: 1. 因为pkg.b不是sys.modules所以我们需要先导入它在sys.modules中设置条目pkg.b然后在导入成功后添加b pkg 的命名空间。 2. a 模块被插入到包命名空间中的导入末尾，因为如果 a 的导入失败（你可以在你的模块中引发异常并查看）我们不希望它在pkg 的命名空间。基本上在导入成功后，将导入的模块添加到包的命名空间中。

感谢您为此答案付出的所有努力。现在它让事情变得非常清楚了。

@Sven：这是我的荣幸，也是一个很好的挑战 :)

【参考方案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一样查找整个世界

【讨论】：

感谢您的回答。不幸的是，我认为这不能解释它。如果在导入时查看foo 的内容是无效的，那么非循环导入也应该失败：如果foo.bar 执行from foo import quux，并且我导入foo.bar，解释器还必须查看foo 在导入时的内容，这工作正常。我说得有道理吗？

【参考方案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