假设我有以下目录结构：
a\
__init__.py
b\
__init__.py
c\
__init__.py
c_file.py
d\
__init__.py
d_file.py
在a包中__init__.py，c包被导入。但c_file.py进口a.b.d。
程序失败，尝试导入b时说不存在。（它真的不存在，因为我们正在导入它。）c_file.pya.b.d
如何解决这个问题？
您可以推迟导入，例如a/__init__.py：
def my_function():
from a.b.c import Blah
return Blah()
也就是说，将导入推迟到真正需要时。但是，我也会仔细查看我的包定义/使用，因为像所指出的那样的循环依赖可能表明存在设计问题。
如果 a 依赖于 c 并且 c 依赖于 a，那么它们实际上不是同一个单元吗？
您应该真正检查为什么将 a 和 c 拆分为两个包，因为要么您有一些代码应该拆分到另一个包中（使它们都依赖于该新包，但不依赖于彼此），或者您应该合并它们成一个包。
我有几次想知道这一点（通常是在处理需要相互了解的模型时）。简单的解决方案就是导入整个模块，然后引用你需要的东西。
所以而不是做
from models import Student
合而为一，并且
from models import Classroom
在另一个，只是做
import models
在其中之一中，然后models.Classroom在需要时调用。
有了类型提示，就有更多机会创建循环导入。幸运的是，有一个使用特殊常量的解决方案：typing.TYPE_CHECKING.
下面的例子定义了一个Vertex类和一个Edge类。一条边由两个顶点定义，一个顶点维护一个它所属的相邻边的列表。
class Vertex:
def __init__(self, label):
self.label = label
self.adjacency_list = []
class Edge:
def __init__(self, v1, v2):
self.v1 = v1
self.v2 = v2
ImportError：无法从部分初始化的模块“edge”导入名称“Edge”（很可能是由于循环导入）
from typing import List
from edge import Edge
class Vertex:
def __init__(self, label: str):
self.label = label
self.adjacency_list: List[Edge] = []
from vertex import Vertex
class Edge:
def __init__(self, v1: Vertex, v2: Vertex):
self.v1 = v1
self.v2 = v2
from typing import List, TYPE_CHECKING
if TYPE_CHECKING:
from edge import Edge
class Vertex:
def __init__(self, label: str):
self.label = label
self.adjacency_list: List['Edge'] = []
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from vertex import Vertex
class Edge:
def __init__(self, v1: 'Vertex', v2: 'Vertex'):
self.v1 = v1
self.v2 = v2
在 3.10 之前的 Python 版本中，有条件导入的类型必须用引号括起来，使它们成为“前向引用”，从而将它们从解释器运行时隐藏起来。
在 Python 3.7、3.8 和 3.9 中，一种解决方法是使用以下特殊导入。
from __future__ import annotations
这允许使用不带引号的类型提示和条件导入。
在 Python 3.10 中，函数和变量注释将不再在定义时进行评估。相反，字符串形式将保留在相应的注释字典中。静态类型检查器不会看到行为差异，而在运行时使用注释的工具将不得不执行延迟评估。
字符串形式是在编译步骤期间从 AST 获得的，这意味着字符串形式可能不会保留源的确切格式。注意：如果一个注解已经是一个字符串文字，它仍然会被包裹在一个字符串中。
问题是当从一个目录运行时，默认情况下只有子目录的包作为候选导入可见，所以你不能导入 abd 你可以导入 bd，因为 b 是 a 的子包。
如果您真的想导入 abd in，c/__init__.py您可以通过将系统路径更改为 a 上方的一个目录并将导入更改a/__init__.py为 import abc来完成此操作
你a/__init__.py应该是这样的：
import sys
import os
# set sytem path to be directory above so that a can be a
# package namespace
DIRECTORY_SCRIPT = os.path.dirname(os.path.realpath(__file__))
sys.path.insert(0,DIRECTORY_SCRIPT+"/..")
import a.b.c
当您想将 c 中的模块作为脚本运行时，会出现另一个困难。这里包 a 和 b 不存在。您可以破解__int__.pyc 目录中的 sys.path 指向顶级目录，然后导入__init__c 内的任何模块，以便能够使用完整路径导入 abd 我怀疑导入是一种好习惯，__init__.py但它适用于我的用例。
我建议以下模式。使用它将允许自动完成和类型提示正常工作。
循环导入a.py
import playground.cyclic_import_b
class A(object):
def __init__(self):
pass
def print_a(self):
print('a')
if __name__ == '__main__':
a = A()
a.print_a()
b = playground.cyclic_import_b.B(a)
b.print_b()
循环导入b.py
import playground.cyclic_import_a
class B(object):
def __init__(self, a):
self.a: playground.cyclic_import_a.A = a
def print_b(self):
print('b1-----------------')
self.a.print_a()
print('b2-----------------')
您不能使用此语法导入类 A 和 B
from playgroud.cyclic_import_a import A
from playground.cyclic_import_b import B
您不能在类 B __ init __ 方法中声明参数 a 的类型，但您可以通过这种方式“强制转换”它：
def __init__(self, a):
self.a: playground.cyclic_import_a.A = a
另一种解决方案是使用 d_file 的代理。
例如，假设您想与 c_file 共享 blah 类。因此，d_file 包含：
class blah:
def __init__(self):
print("blah")
这是您在 c_file.py 中输入的内容：
# do not import the d_file !
# instead, use a place holder for the proxy of d_file
# it will be set by a's __init__.py after imports are done
d_file = None
def c_blah(): # a function that calls d_file's blah
d_file.blah()
在 a 的init .py 中：
from b.c import c_file
from b.d import d_file
class Proxy(object): # module proxy
pass
d_file_proxy = Proxy()
# now you need to explicitly list the class(es) exposed by d_file
d_file_proxy.blah = d_file.blah
# finally, share the proxy with c_file
c_file.d_file = d_file_proxy
# c_file is now able to call d_file.blah
c_file.c_blah()