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

import request

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

解决方案:

只需将测试文件更改为另一个名称，例如aaa.py，而不是request.py。

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

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

Imports are pretty straightforward really. Just remember the following: 'import' and 'from xxx import yyy' are executable statements. They execute when the running program reaches that line. If a module is not in sys.modules, then an import creates the new module entry in sys.modules and then executes the code in the module. It does not return control to the calling module until the execution has completed. If a module does exist in sys.modules then an import simply returns that module whether or not it has completed executing. That is the reason why cyclic imports may return modules which appear to be partly empty. Finally, the executing script runs in a module named __main__, importing the script under its own name will create a new module unrelated to __main__. Take that lot together and you shouldn't get any surprises when importing modules.

这里有个例子让我震惊!

foo.py

import bar

class gX(object):
    g = 10

bar.py

from foo import gX

o = gX()

main.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

我完全同意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")

同样，这不是一个永久性的修复，但可以帮助那些希望在不修改太多代码的情况下修复导入错误的人。

干杯!

我用下面的方法解决了这个问题，没有任何错误。 考虑两个文件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

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

文件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):
        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原则。