如何实现Python多类非循环跨属性依赖的类实例初始化？

你的类代码出现RecursionError是因为A的初始化会新建B实例，B的初始化又会新建A实例，形成无限循环调用构造方法，最终导致栈溢出。下面给出几种替代字典逻辑的可行实现方式：

方案1：先实例化，后赋值依赖属性 #

这种方式和字典的实现逻辑最接近，先创建实例容器，再逐步计算依赖属性：

class A:
    def __init__(self):
        self.A1 = 10
        # 先不初始化依赖属性A2

class B:
    def __init__(self):
        self.B1 = 2
        # 先不初始化依赖属性B2

# 第一步：创建所有实例
a = A()
b = B()

# 第二步：计算并赋值跨依赖属性
b.B2 = b.B1 * a.A1
a.A2 = b.B2 * 3

print(a.A1, a.A2)  # 输出：10 60
print(b.B1, b.B2)  # 输出：2 20

方案2：使用@property延迟计算，实例互相引用 #

通过@property让依赖属性在被访问时才计算，初始化时仅传递对方的实例引用，避免循环创建实例：

class A:
    def __init__(self, b_instance):
        self.A1 = 10
        self.b = b_instance  # 引用已存在的B实例

    @property
    def A2(self):
        # 访问时才计算A2的值
        return self.b.B2 * 3

class B:
    def __init__(self, a_instance):
        self.B1 = 2
        self.a = a_instance  # 引用已存在的A实例

    @property
    def B2(self):
        # 访问时才计算B2的值
        return self.B1 * self.a.A1

# 先创建实例并互相绑定引用
a = A(None)
b = B(a)
a.b = b

print(a.A1, a.A2)  # 输出：10 60
print(b.B1, b.B2)  # 输出：2 20

方案3：用工厂函数封装实例创建过程 #

把实例初始化、互相绑定的逻辑封装到工厂函数中，简化外部调用：

class A:
    def __init__(self):
        self.A1 = 10
        self.b = None

    @property
    def A2(self):
        return self.b.B2 * 3

class B:
    def __init__(self):
        self.B1 = 2
        self.a = None

    @property
    def B2(self):
        return self.B1 * self.a.A1

def create_dependent_instances():
    a = A()
    b = B()
    a.b = b
    b.a = a
    return a, b

# 直接通过工厂函数获取绑定好的实例
a, b = create_dependent_instances()
print(a.A1, a.A2)  # 输出：10 60
print(b.B1, b.B2)  # 输出：2 20

核心思路：避免在类的__init__方法中新建对方的实例，而是通过引用已存在的实例、延迟属性计算这两种方式，打破循环创建的链条。

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