Python循环导入问题深度解析与四种规避策略

前言

在Python项目开发中，使用package时遭遇循环导入问题十分常见。为了清晰说明这一现象，我们构建如下package结构作为示例：

pkg
 ├── __init__.py
 ├── module_a.py
 └── module_b.py

其中，

__init__.py 文件将pkg指定为一个标准的Python package。

在module_a.py中定义了一个action_a()函数，该函数内部引用了module_b.py中的某个attribute（例如一个函数或变量）。

与此同时，module_b.py中定义了一个action_b()函数，该函数也引用了module_a.py中的某个attribute（例如一个函数或变量）。

在这种情况下，直接执行该package会抛出circular import error错误，即循环引用错误。这是因为module_a在尝试引入module_b时，而module_b首先需要引入module_a，这种相互依赖导致Python解释器无法顺利完成执行流程。

然而，通过采用一些巧妙的编码技巧，我们可以让上述逻辑正常工作，同时有效避免循环引入引发的错误。

那么，具体在哪些场景下它能正常工作，哪些场景下会失败，而那些能够正常工作的情况背后的原因又是什么呢？

何时它能正常工作？

1. 在module顶部引入，不使用from语句，采用相对引入，此方法仅在Python 2中有效。

在module的顶部使用import语句，例如import another_module，module中的函数通过another_module.attribute的方式引用another_module中的函数或变量等。这种方式之所以有效，是因为import another_module是基于当前目录的相对引用，且属于一种隐式引用机制。需要注意的是，如果从另一个package中引入该module时，这种方式可能会失效。另外，import another_module这种语法在Python 3中已经不再支持，因此不建议在代码中使用这种方法来避免循环引入。

如：

# pkg/module_a.py 
from __future__ import print_function
import module_b
 
def action_a():
 print(module_b.action_b.__name__)
 
 
# pkg/module_b.py
from __future__ import print_function
import module_a
 
def action_b():
 print(module_a.action_a.__name__)

2. 在module的顶部引入，不使用from语句，采用绝对引入。

在module的顶部使用import语句，并使用从package开始的绝对路径，例如import package.another_module，module中的函数通过package.another_module.attribute的方式引用another_module中的函数或变量等。之所以需要挂上package name来引入，是因为import .another_module这种形式的“相对引入”会报语法错误，而挂上package的绝对引入方式，Python 2和Python 3均提供支持。

案例：

# pkg/module_a.py
from __future__ import print_function
import pkg2.module_b
 
def action_a():
 print(pkg2.module_b.action_b.__name__)
 
 
# pkg/module_b.py
from __future__ import print_function
import pkg2.module_a
 
def action_b():
 print(pkg2.module_a.action_a.__name__)

3. 在module底部引入another module的attribute，而非直接引入another module，使用from语句。

在module的底部进行import操作（至少要在被引用的attribute定义之后import），直接引入another module的attribute，例如from package.another_module import attribute。相对引入也支持，如from .another_module import attribute，module中的函数可以直接使用被引用的attribute即可。

如：

# pkg/module_a.py
from __future__ import print_function
 
def action_a():
 print(action_b.__name__)
 
from .module_b import action_b
 
 
# pkg/module_b.py
from __future__ import print_function
 
def action_b():
 print(action_a.__name__)
 
from .module_a import action_a

4. 在函数顶部引入，可以使用from语句。

在module的function顶部进行import操作，例如from package import another_module，该方法也支持相对引入，引入module或attribute均可。

如：

# pkg/module_a.py
from __future__ import print_function
 
def action_a():
 from . import module_b
 print(module_b.action_b.__name__)
 
 
# pkg/module_b.py
from __future__ import print_function
 
def action_b():
 from . import module_a
 print(module_a.action_a.__name__)

或

# pkg/module_a.py
from __future__ import print_function
 
def action_a():
 from .module_b import action_b
 print(action_b.__name__)
 
 
# pkg/module_b.py
from __future__ import print_function
def action_b():
 from .module_a import action_a
 print(action_a.__name__)

这种方式虽然Python 2和Python 3都支持，但编码风格不够优雅，且会影响代码的可读性，因此不建议使用。

注

本文讨论的问题，核心在于Python中调用package时，应如何避免循环引入。

当直接在命令行执行一个Python module时，适用情况可能与package内部调用不完全相同。

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值。如果有疑问大家可以留言交流，谢谢大家对本站的支持。