Python 中的循环（或循环）导入

Question

如果两个模块相互导入会发生什么？

为了概括这个问题，Python 中的循环导入呢？

Answer 1

去年在comp.lang.python 上对此进行了非常好的讨论。它非常彻底地回答了您的问题。

导入确实非常简单。请记住以下几点：

'import' 和 'from xxx import yyy' 是可执行语句。他们执行 当正在运行的程序到达该行时。

如果模块不在 sys.modules 中，则导入会创建新模块 进入 sys.modules 然后执行模块中的代码。它不是 将控制权返回给调用模块，直到执行完成。

如果 sys.modules 中确实存在一个模块，那么导入只会返回该模块 模块是否已完成执行。这就是为什么 循环导入可能会返回部分为空的模块。

最后，执行脚本运行在一个名为 __main__ 的模块中，导入 以它自己的名字命名的脚本将创建一个与它无关的新模块 __main__.

综合考虑，导入时不会有任何意外 模块。

Answer 2

循环导入终止，但您需要注意不要在模块初始化期间使用循环导入的模块。

考虑以下文件：

a.py:

print "a in"
import sys
print "b imported: %s" % ("b" in sys.modules, )
import b
print "a out"

b.py：

print "b in"
import a
print "b out"
x = 3

如果你执行a.py，你会得到如下：

$ python a.py
a in
b imported: False
b in
a in
b imported: True
a out
b out
a out

在第二次导入 b.py 时（在第二次 a in 中），Python 解释器不会再次导入 b，因为它已经存在于模块 dict 中。

如果您在模块初始化期间尝试从a 访问b.x，您将获得AttributeError。

将以下行追加到a.py:

print b.x

那么，输出是：

$ python a.py
a in                    
b imported: False
b in
a in
b imported: True
a out
Traceback (most recent call last):
  File "a.py", line 4, in <module>
    import b
  File "/home/shlomme/tmp/x/b.py", line 2, in <module>
    import a
 File "/home/shlomme/tmp/x/a.py", line 7, in <module>
    print b.x
AttributeError: 'module' object has no attribute 'x'

这是因为模块在导入时执行，在访问b.x 时，x = 3 行尚未执行，这只会在b out 之后发生。

Answer 3

如果您执行import foo（在bar.py 内）和import bar（在foo.py 内），它将正常工作。当任何东西实际运行时，两个模块都将完全加载并相互引用。

问题是当您改为使用from foo import abc（在bar.py 内）和from bar import xyz（在foo.py 内）时。因为现在每个模块都需要另一个模块已经被导入（这样我们正在导入的名称就存在）才能被导入。

Answer 4

这里有一个让我印象深刻的例子！

foo.py

import bar

class gX(object):
    g = 10

bar.py

from foo import gX

o = gX()

ma​​in.py

import foo
import bar

print "all done"

在命令行： $ python main.py

Traceback (most recent call last):
  File "m.py", line 1, in <module>
    import foo
  File "/home/xolve/foo.py", line 1, in <module>
    import bar
  File "/home/xolve/bar.py", line 1, in <module>
    from foo import gX
ImportError: cannot import name gX

Answer 5

好的，我想我有一个很酷的解决方案。 假设您有文件a 和文件b。 你有一个def 或一个class 在文件b 中你想在模块a 中使用，但你还有别的东西，要么是def，class，要么是来自文件a 的变量您需要在文件b 中的定义或类中。 您可以做的是，在文件a 的底部，在调用文件a 中需要的文件b 中的函数或类之后，但在从文件b 中调用您需要的函数或类之前对于文件a，比如import b 然后，这里是关键部分，在文件b 中需要文件a 中的def 或class 的所有定义或类中（我们称之为CLASS )，你说from a import CLASS

这是可行的，因为您可以导入文件 b，而无需 Python 执行文件 b 中的任何导入语句，因此您可以避开任何循环导入。

例如：

文件a：

class A(object):

     def __init__(self, name):

         self.name = name

CLASS = A("me")

import b

go = B(6)

go.dostuff

文件 b：

class B(object):

     def __init__(self, number):

         self.number = number

     def dostuff(self):

         from a import CLASS

         print "Hello " + CLASS.name + ", " + str(number) + " is an interesting number."

瞧。

Answer 6

正如其他答案描述的那样，这种模式在 python 中是可以接受的：

def dostuff(self):
     from foo import bar
     ...

这将避免在文件被其他模块导入时执行导入语句。只有存在逻辑循环依赖，才会失败。

大多数循环导入实际上不是逻辑循环导入，而是引发 ImportError 错误，因为 import() 在调用时评估整个文件的*语句的方式。

如果您确实希望将导入放在首位，这些ImportErrors 几乎总是可以避免的：

考虑这个循环导入：

应用 A

# profiles/serializers.py

from images.serializers import SimplifiedImageSerializer

class SimplifiedProfileSerializer(serializers.Serializer):
    name = serializers.CharField()

class ProfileSerializer(SimplifiedProfileSerializer):
    recent_images = SimplifiedImageSerializer(many=True)

应用 B

# images/serializers.py

from profiles.serializers import SimplifiedProfileSerializer

class SimplifiedImageSerializer(serializers.Serializer):
    title = serializers.CharField()

class ImageSerializer(SimplifiedImageSerializer):
    profile = SimplifiedProfileSerializer()

来自 David Beazley 的精彩演讲 Modules and Packages: Live and Let Die! - PyCon 2015、1:54:00，这是一种在 python 中处理循环导入的方法：

try:
    from images.serializers import SimplifiedImageSerializer
except ImportError:
    import sys
    SimplifiedImageSerializer = sys.modules[__package__ + '.SimplifiedImageSerializer']

这会尝试导入SimplifiedImageSerializer，如果引发ImportError，因为它已经被导入，它将从导入缓存中拉取。

PS：你必须用 David Beazley 的声音阅读整篇文章。

Answer 7

我完全同意 pythoneer 在这里的回答。但是我偶然发现了一些循环导入存在缺陷的代码，并在尝试添加单元测试时引起了问题。因此，要在不更改所有内容的情况下快速修补它，您可以通过动态导入来解决问题。

# Hack to import something without circular import issue
def load_module(name):
    """Load module using imp.find_module"""
    names = name.split(".")
    path = None
    for name in names:
        f, path, info = imp.find_module(name, path)
        path = [path]
    return imp.load_module(name, f, path[0], info)
constants = load_module("app.constants")

再次重申，这不是永久性修复，但可能会帮助想要修复导入错误而不更改太多代码的人。

干杯！

Answer 8

循环导入可能会造成混淆，因为导入会做两件事：

1. 它执行导入的模块代码
2. 将导入模块添加到导入模块全局符号表中

前者只执行一次，而后者在每个导入语句中执行。循环导入会在导入模块使用导入的部分执行代码时产生情况。因此它不会看到在 import 语句之后创建的对象。下面的代码示例演示了它。

循环进口并不是要不惜一切代价避免的终极邪恶。在一些像 Flask 这样的框架中，它们是非常自然的，并且调整你的代码以消除它们并不会使代码变得更好。

main.py

print 'import b'
import b
print 'a in globals() {}'.format('a' in globals())
print 'import a'
import a
print 'a in globals() {}'.format('a' in globals())
if __name__ == '__main__':
    print 'imports done'
    print 'b has y {}, a is b.a {}'.format(hasattr(b, 'y'), a is b.a)

b.by

print "b in, __name__ = {}".format(__name__)
x = 3
print 'b imports a'
import a
y = 5
print "b out"

a.py

print 'a in, __name__ = {}'.format(__name__)
print 'a imports b'
import b
print 'b has x {}'.format(hasattr(b, 'x'))
print 'b has y {}'.format(hasattr(b, 'y'))
print "a out"

使用 cmets 输出 python main.py

import b
b in, __name__ = b    # b code execution started
b imports a
a in, __name__ = a    # a code execution started
a imports b           # b code execution is already in progress
b has x True
b has y False         # b defines y after a import,
a out
b out
a in globals() False  # import only adds a to main global symbol table 
import a
a in globals() True
imports done
b has y True, a is b.a True # all b objects are available

Answer 9

模块 a.py：

import b
print("This is from module a")

模块 b.py

import a
print("This is from module b")

运行“Module a”会输出：

>>> 
'This is from module a'
'This is from module b'
'This is from module a'
>>> 

它输出这 3 行，而由于循环导入，它应该输出 infinitial。 此处列出了运行“Module a”时逐行发生的情况：

1. 第一行是import b。所以它会访问模块 b
2. 模块 b 的第一行是import a。所以它会访问模块a
3. 模块 a 的第一行是 import b 但请注意，此行将不再执行，因为 python 中的每个文件只执行一个导入行这一次，无论何时何地执行都无关紧要。所以它将传递到下一行并打印"This is from module a"。
4. 从模块 b 访问完整个模块 a 后，我们仍然在模块 b。所以下一行将打印"This is from module b"
5. 模块 b 行已完全执行。所以我们将回到我们开始模块 b 的模块 a。
6. import b 行已经执行，不会再执行。下一行将打印"This is from module a"，程序将完成。

Answer 10

我通过以下方式解决了问题，并且运行良好，没有任何错误。 考虑两个文件a.py 和b.py。

我将此添加到 a.py 并且它有效。

if __name__ == "__main__":
        main ()

a.py:

import b
y = 2
def main():
    print ("a out")
    print (b.x)

if __name__ == "__main__":
    main ()

b.py:

import a
print ("b out")
x = 3 + a.y

我得到的输出是

>>> b out 
>>> a out 
>>> 5

Answer 11

这里有很多很棒的答案。虽然问题通常有快速的解决方案，其中一些感觉比其他的更 Pythonic，如果你有做一些重构的奢侈，另一种方法是分析你的代码的组织，并尝试删除循环依赖。例如，您可能会发现：

文件 a.py

from b import B

class A:
    @staticmethod
    def save_result(result):
        print('save the result')

    @staticmethod
    def do_something_a_ish(param):
        A.save_result(A.use_param_like_a_would(param))

    @staticmethod
    def do_something_related_to_b(param):
        B.do_something_b_ish(param)

文件 b.py

from a import A

class B:
    @staticmethod
    def do_something_b_ish(param):
        A.save_result(B.use_param_like_b_would(param))

在这种情况下，只需将一个静态方法移动到一个单独的文件中，比如c.py：

文件 c.py

def save_result(result):
    print('save the result')

将允许从 A 中删除 save_result 方法，从而允许从 b 中的 a 中删除 A 的导入：

重构文件 a.py

from b import B
from c import save_result

class A:
    @staticmethod
    def do_something_a_ish(param):
        A.save_result(A.use_param_like_a_would(param))

    @staticmethod
    def do_something_related_to_b(param):
        B.do_something_b_ish(param)

重构文件 b.py

from c import save_result

class B:
    @staticmethod
    def do_something_b_ish(param):
        save_result(B.use_param_like_b_would(param))

总而言之，如果您有一个工具（例如 pylint 或 PyCharm）报告可以是静态的方法，那么仅仅在它们上扔一个 staticmethod 装饰器可能不是消除警告的最佳方法。尽管该方法看起来与类相关，但最好将其分开，特别是如果您有几个密切相关的模块可能需要相同的功能并且您打算练习 DRY 原则。

Answer 12

假设您正在运行一个名为 request.py 的测试 python 文件 在 request.py 中，你写

import request

所以这也很可能是循环导入。

解决方案：

只需将您的测试文件更改为其他名称，例如aaa.py，而不是request.py。

不要使用其他库已经使用的名称。

Answer 13

令我惊讶的是，还没有人提到由类型提示引起的循环导入。
如果由于类型提示而仅有循环导入，则可以以干净的方式避免它们。

考虑main.py，它利用了另一个文件中的异常：

from src.exceptions import SpecificException

class Foo:
    def __init__(self, attrib: int):
        self.attrib = attrib

raise SpecificException(Foo(5))

还有专用的异常类exceptions.py：

from src.main import Foo

class SpecificException(Exception):
    def __init__(self, cause: Foo):
        self.cause = cause

    def __str__(self):
        return f'Expected 3 but got {self.cause.attrib}.'

这将通过 main.py 导入 exception.py 并通过 Foo 和 SpecificException 轻松提升 ImportError。

因为Foo 在类型检查期间仅在exceptions.py 中是必需的，所以我们可以使用typing 模块中的TYPE_CHECKING 常量安全地使其有条件导入。类型检查时常量只有True，这样我们可以有条件地导入Foo，从而避免循环导入错误。
在 Python 3.6 中，使用前向引用：

from typing import TYPE_CHECKING
if TYPE_CHECKING:  # Only imports the below statements during type checking
   ​from src.main import Foo

class SpecificException(Exception):
   ​def __init__(self, cause: 'Foo'):  # The quotes make Foo a forward reference
       ​self.cause = cause

   ​def __str__(self):
       ​return f'Expected 3 but got {self.cause.attrib}.'

在 Python 3.7+ 中，延迟评估注释（在 PEP 563 中引入）允许使用“普通”类型而不是前向引用：

from __future__ import annotations
from typing import TYPE_CHECKING
if TYPE_CHECKING:  # Only imports the below statements during type checking
   ​from src.main import Foo

class SpecificException(Exception):
   ​def __init__(self, cause: Foo):  # Foo can be used in type hints without issue
       ​self.cause = cause

   ​def __str__(self):
       ​return f'Expected 3 but got {self.cause.attrib}.'

在 Python 3.11+ 中，from __future__ import annotations 默认处于活动状态，因此可以省略。

此答案基于 Stefaan Lippens 的 Yet another solution to dig you out of a circular import hole in Python。