Python循环导入？

Question

所以我收到了这个错误

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

你可以看到我在前面使用了相同的导入语句并且它有效吗？循环进口有什么不成文的规定吗？如何在调用堆栈的下方使用相同的类？

Answer 1

我认为answer by 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。

Answer 2

当您第一次导入一个模块（或其中的一个成员）时，模块内的代码会像任何其他代码一样按顺序执行；例如，它的处理方式与函数体没有任何不同。 import 和其他命令一样只是一个命令（赋值、函数调用、def、class）。假设您的导入发生在脚本的顶部，那么这就是正在发生的事情：

• 当您尝试从world 导入World 时，world 脚本将被执行。
• world 脚​​本导入 Field，这会导致 entities.field 脚本得到执行。
• 此过程一直持续到您到达 entities.post 脚本，因为您尝试导入 Post
• entities.post 脚本导致 physics 模块被执行，因为它试图导入 PostBody
• 最后，physics 尝试从entities.post 导入Post
• 我不确定entities.post 模块是否存在于内存中，但这并不重要。要么模块不在内存中，要么模块还没有Post 成员，因为它尚未完成定义Post
• 无论如何都会出错，因为Post 不存在可以导入

所以不，它不是“在调用堆栈中进一步工作”。这是错误发生位置的堆栈跟踪，这意味着它在尝试在该类中导入 Post 时出错。您不应该使用循环导入。充其量，它的好处可以忽略不计（通常，没有好处），它会导致这样的问题。它会给维护它的任何开发人员带来负担，迫使他们在蛋壳上行走以避免破坏它。重构你的模块组织。

Answer 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。很快它就遇到了需要 Y2 的 X.py 中的导入语句。但是Y2是未定义的，所以编译失败。

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

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

from X import Y

任何时候你认为可能存在循环导入，你也应该避免在编译时引用其他模块中的变量。考虑一下看起来很无辜的代码：

import X
z = X.Y

假设模块 X 在此模块导入 X 之前导入此模块。进一步假设 Y 在 import 语句之后在 X 中定义。那么在这个模块被导入的时候Y就不会被定义了，你会得到一个编译错误。如果这个模块首先导入 Y，你可以侥幸逃脱。但是，当您的一位同事无意中更改了第三个模块中的定义顺序时，代码就会中断。

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

请注意，在模块中向下移动 import 语句会掩盖您正在执行的操作。使用模块顶部的注释来弥补这一点，如下所示：

#import X   (actual import moved down to avoid circular dependency)

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

Answer 4

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

"...要引用另一个应用程序中定义的模型，您可以显式指定具有完整应用程序标签的模型。例如，如果上面的制造商模型是在另一个名为生产的应用程序中定义的，则需要使用：

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

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

Answer 5

我能够（仅）在需要此模块中的对象的函数中导入模块：

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

Answer 6

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

Answer 7

我正在使用以下内容：

from module import Foo

foo_instance = Foo()

但为了摆脱circular reference，我做了以下事情并且成功了：

import module.foo

foo_instance = foo.Foo()