Python循环导入？

Traceback (most recent call last):
  File "/Users/alex/dev/runswift/utils/sim2014/simulator.py", line 3, in <module>
    from world import World
  File "/Users/alex/dev/runswift/utils/sim2014/world.py", line 2, in <module>
    from entities.field import Field
  File "/Users/alex/dev/runswift/utils/sim2014/entities/field.py", line 2, in <module>
    from entities.goal import Goal
  File "/Users/alex/dev/runswift/utils/sim2014/entities/goal.py", line 2, in <module>
    from entities.post import Post
  File "/Users/alex/dev/runswift/utils/sim2014/entities/post.py", line 4, in <module>
    from physics import PostBody
  File "/Users/alex/dev/runswift/utils/sim2014/physics.py", line 21, in <module>
    from entities.post import Post
ImportError: cannot import name Post

#1 楼

我认为jpmc26的答案虽然绝对没有错，但在循环进口方面却过于严格。如果正确设置它们，它们可以正常工作。

最简单的方法是使用import my_module语法，而不是from my_module import some_object。即使my_module包含了我们的进口，前者几乎总是可以使用。后者仅在my_object中已定义my_module时才有效，在循环导入中可能不是这种情况。

要针对您的情况：尝试更改entities/post.py以执行import physics，然后参考physics.PostBody比直接PostBody更多。同样，将physics.py更改为import entities.post，然后使用entities.post.Post而不是Post。

#2 楼

首次导入模块（或其成员）时，模块内的代码将像其他任何代码一样依次执行。例如，对函数主体的处理没有任何不同。 import只是与其他命令一样的命令（赋值，函数调用，def和class）。假设您的导入发生在脚本的顶部，那么将发生以下情况：


当您尝试从World导入world时，将执行world脚本。
world脚本导入Field，这将导致执行entities.field脚本。
此过程一直持续到到达entities.post脚本为止，因为您尝试导入Post

entities.post脚本导致physics模块被执行。尝试导入PostBody

最后，physics尝试从Post导入entities.post

我不确定entities.post模块是否已存在于内存中，但这并不重要。该模块不在内存中，或者该模块还没有Post成员，因为它尚未完成执行对Post的定义

无论哪种方式，都会发生错误，因为Post不存在导入的

所以不，它不是“在调用堆栈中进一步工作”。这是错误发生位置的堆栈跟踪，这意味着它在尝试导入Post时出错。您不应该使用循环导入。充其量，它的收益微不足道（通常没有收益），并且会引起类似的问题。这给所有开发人员维护它带来了负担，迫使他们在蛋壳上行走以避免损坏它。重构您的模块组织。

#3 楼

要了解循环依赖关系，您需要记住Python本质上是一种脚本语言。方法外部的语句执行在编译时发生。导入语句的执行就像方法调用一样，要理解它们，您应该像方法调用一样考虑它们。

进行导入时，发生的情况取决于导入的文件是否已存在于文件中。模块表。如果是这样，Python将使用符号表中当前使用的任何内容。如果没有，Python将开始读取模块文件，编译/执行/导入其找到的文件。能否找到在编译时引用的符号，取决于它们是否已被编译器看到。

假设您有两个源文件：

文件X.py

def X1:
    return "x1"

from Y import Y2

def X2:
    return "x2"

文件Y.py

def Y1:
    return "y1"

from X import X1

def Y2:
    return "y2"

现在假设您编译文件X。 PY。编译器首先定义方法X1，然后在X.py中命中import语句。这将导致编译器暂停X.py的编译并开始编译Y.py。此后不久，编译器在Y.py中命中import语句。由于X.py已经在模块表中，因此Python使用现有的不完整X.py符号表来满足请求的所有引用。 X.py中import语句之前出现的所有符号现在都在符号表中，但之后的任何符号都没有。由于X1现在出现在import语句之前，因此已成功导入。然后，Python恢复编译Y.py。这样，它定义了Y2并完成了Y.py的编译。然后，它恢复X.py的编译，并在Y.py符号表中找到Y2。编译最终完成而没有错误。

如果尝试从命令行编译Y.py，则会发生非常不同的事情。在编译Y.py时，编译器会在定义Y2之前命中import语句。然后，它开始编译X.py。很快，它在X.py中命中了需要Y2的import语句。但是Y2是未定义的，因此编译会失败。

请注意，如果您修改X.py以导入Y1，则无论您编译哪个文件，编译都将始终成功。但是，如果您修改文件Y.py以导入符号X2，则不会编译任何文件。

每当模块X或X导入的任何模块可能导入当前模块时，请勿使用：

from X import Y

任何时候，只要您认为可能会有循环导入，就应该避免编译时引用其他模块中的变量。考虑一下看起来很纯洁的代码：假设模块X在此模块导入X之前先导入了此模块。另外，假设Y在import语句之后在X中定义了Y。然后，在导入此模块时将不会定义Y，并且会出现编译错误。如果此模块首先导入Y，那么您可以摆脱它。但是，当您的一位同事无辜地更改第三个模块中的定义顺序时，代码将中断。

在某些情况下，您可以通过将导入语句下移到所需的符号定义下方来解决循环依赖性。通过其他模块。在上面的示例中，import语句之前的定义永远不会失败。取决于编译的顺序，import语句之后的定义有时会失败。只要在编译时不需要导入的符号，甚至可以将import语句放在文件的末尾。

请注意，将import语句向下移入模块会使您的工作变得晦涩。为此，请在模块顶部添加注释，如下所示：

import X
z = X.Y

一般来说，这是一个不好的做法，但有时很难避免。

#4 楼

对于像我一样从Django来解决此问题的人，您应该知道该文档提供了解决方案：
https://docs.djangoproject.com/en/1.10/ref/models/fields/ #foreignkey

“ ...要引用在另一个应用程序中定义的模型，可以显式指定带有完整应用程序标签的模型。例如，如果上述制造商模型是在另一个称为production的应用程序中定义的，则需要使用：

class Car(models.Model):
    manufacturer = models.ForeignKey(
        'production.Manufacturer',
        on_delete=models.CASCADE,
)

这种引用在解决两个应用程序之间的循环导入依赖关系时非常有用....“

#5 楼

我能够（仅）将需要该模块中对象的功能导入模块：

def my_func():
    import Foo
    foo_instance = Foo()

#6 楼

如果您在一个相当复杂的应用程序中遇到此问题，则重构所有导入内容可能会很麻烦。 PyCharm为此提供了一个快速修复程序，该修复程序还将自动更改导入符号的所有用法。

#7 楼

我正在使用以下代码：

from module import Foo

foo_instance = Foo()

但是要摆脱circular reference，我做了以下工作，并且有效：

import module.foo

foo_instance = foo.Foo()