前言
Python 中使用package时，出现循环导入问题十分常见，我们创建如下package来说明这个问题:
|
1
2
3
4
|
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这种语法在Python3 中已经不支持了，所以不要在代码中用这种方法来避免循环引入。
如：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
# pkg/module_a.py from __future__ import print_functionimport module_b def action_a(): print(module_b.action_b.__name__) # pkg/module_b.pyfrom __future__ import print_functionimport 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和3都支持
案例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
# pkg/module_a.pyfrom __future__ import print_functionimport pkg2.module_b def action_a(): print(pkg2.module_b.action_b.__name__) # pkg/module_b.pyfrom __future__ import print_functionimport 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即可。
如：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
# pkg/module_a.pyfrom __future__ import print_function def action_a(): print(action_b.__name__) from .module_b import action_b # pkg/module_b.pyfrom __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均可。
如：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
# pkg/module_a.pyfrom __future__ import print_function def action_a(): from . import module_b print(module_b.action_b.__name__) # pkg/module_b.pyfrom __future__ import print_function def action_b(): from . import module_a print(module_a.action_a.__name__) |
或
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
# pkg/module_a.pyfrom __future__ import print_function def action_a(): from .module_b import action_b print(action_b.__name__) # pkg/module_b.pyfrom __future__ import print_functiondef action_b(): from .module_a import action_a print(action_a.__name__) |
这种方式虽然Python 2和3都支持，但编码不够优雅，影响代码可读性，不建议使用
注
本文讨论的问题，是Python中调用package时，应如何避免循环引入
当直接在命令行执行一个Python module时，适用情况不完全相同
总结
以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对服务器之家的支持。
原文链接：http://dataunion.org/31167.html
