Python导入含静态方法的相互依赖类失败问题咨询

这个问题其实包含两个核心问题：循环导入冲突和无限递归调用，咱们一步步拆解来解决。

问题根源分析 #

1. 循环导入问题：你的a.py在模块顶部就导入了b，b.py又尝试导入a，形成了循环依赖。虽然你用sys.modules做了检查，但Python模块加载机制是：开始执行模块代码前，就会把模块名加入sys.modules——这时候a模块还没完成类定义，b里调用A.a()就可能碰到未完全初始化的类对象，触发异常。
2. 无限递归问题：A.a()调用B.b()，B.b()又调用A.a()，没有终止条件，运行时会直接触发RecursionError栈溢出，这也是你程序崩溃的直接原因之一。

解决方案 #

方案1：延迟导入+添加递归终止（快速修复） #

把导入语句移到静态方法内部，避免模块加载阶段的循环冲突；同时给方法添加终止逻辑，解决无限递归问题。

修改后的a.py：

class A:
    @staticmethod
    def a(count=0):
        # 添加终止条件，避免无限递归
        if count >= 2:
            print("终止递归")
            return
        print('a')
        # 延迟导入B，仅在调用方法时才执行导入
        from b import B
        B.b(count + 1)

修改后的b.py：

class B:
    @staticmethod
    def b(count=0):
        if count >= 2:
            print("终止递归")
            return
        print('b')
        # 延迟导入A，仅在调用方法时才执行导入
        from a import A
        A.a(count + 1)

主程序代码保持不变：

import sys
sys.path.append('./static_classes')
from a import A
from b import B
A.a()
B.b()

运行后会输出：

a
b
a
终止递归
b
a
b
终止递归

方案2：重构代码，彻底消除循环依赖 #

如果业务逻辑允许，更优雅的方式是重构代码，把相互依赖的逻辑抽离到独立模块，从根源上避免循环导入。

比如新建common.py：

def execute_with_limit(target_func, count):
    if count >= 2:
        print("终止递归")
        return
    target_func(count)

然后a.py：

from common import execute_with_limit
class A:
    @staticmethod
    def a(count=0):
        print('a')
        from b import B
        execute_with_limit(B.b, count + 1)

b.py：

from common import execute_with_limit
class B:
    @staticmethod
    def b(count=0):
        print('b')
        from a import A
        execute_with_limit(A.a, count + 1)

这种方式让每个类的职责更清晰，也彻底解决了循环导入的问题。

为什么原代码的sys.modules检查没用？ #

Python加载模块时，会在开始执行模块代码前就把模块名加入sys.modules。所以当a.py导入b.py时，b.py检查到'A'在sys.modules里，就跳过了from a import A，但此时A类还没完成定义——如果后续B.b()调用A.a()，在某些场景下会触发AttributeError。即使导入没问题，无限递归也会直接让程序崩溃。

内容的提问来源于stack exchange，提问作者user6039980