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

39 投票

3 回答

6992 浏览

提问于 2025-04-16 19:35

假设我们有两个模块，它们之间有循环依赖：

# 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

为什么会出现这个错误呢？难道情况和之前的不一样吗？（这和这个问题有关系吗？）

补充说明：我知道有一些方法可以避免循环依赖，但我还是想了解这个错误的原因。

错误处理软件架构编程技巧依赖管理相对导入模块导入模块化设计循环依赖

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

回答于 2025-04-16 由 Python大师

分享举报

顺便说一下，相对导入并不重要。使用 from pkg import... 也会出现相同的错误。

我觉得这里的情况是，from foo import bar 和 import foo.bar 之间的区别在于，前者的 bar 可能是包 foo 中的一个模块，也可能是模块 foo 中的一个变量。而在后者中，bar 只能是一个模块或包，其他的都不行。

这很重要，因为如果 bar 确定是一个模块，那么 sys.modules 中的内容就足够用来填充它。如果 bar 可能是模块 foo 中的一个变量，那么解释器就必须实际查看 foo 的内容，但在导入 foo 的时候，这样做是不合法的；因为实际的模块还没有被加载。

在相对导入的情况下，我们理解 from . import bar 是从包含当前模块的包中导入 bar 模块，但这其实只是语法上的一种简化，. 这个符号会被转换成一个完整的名称，然后传递给 __import__()，所以看起来就像是模糊的 from foo import bar。

回答于 2025-04-16 由 Python大师

分享举报

首先，让我们来看看在Python中，from import是怎么工作的：

我们先来看看字节码：

>>> 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，然后它会从帧栈中弹出上一个执行的操作码IMPORT_NAME返回的值v，接着用这两个参数调用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，否则就返回这个属性。

那么这和相对导入有什么关系呢？

相对导入像from . import b，在某些情况下就等同于from pkg import b。

那么这是怎么发生的呢？为了理解这一点，我们需要看看Python的import.c模块，特别是get_parent()函数。这个函数比较长，不方便在这里列出，但一般来说，当它看到相对导入时，会尝试根据__main__模块替换掉点.，而在OP的问题中，__main__模块就是包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的情况，第二次导入就会发生，也就是导入导入语句中的模块。所以在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)。

免责声明：这是我自己努力理解解释器内部发生了什么，我还远不是专家。

编辑：这个回答经过重新表述，因为我在尝试再次阅读时发现我的回答表述得很糟糕，希望现在能更有用一些 :)

回答于 2025-04-16 由 Python大师

分享举报

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

3 个回答

撰写回答