Python 如何实例化相互依赖的类？

我有一个

PlayoffCreator

类来创建季后赛比赛。此类有一个

方括号

实例，该实例生成方括号的结构，该结构中的每个匹配项都是一个

节点

，由类

元素

的两个实例组成

然后

PlayoffCreator

遍历

方括号中的每个
节点
并对其进行处理，创建比赛并执行其他必要的操作。处理
节点
时，两个
元素
都会被处理：这个
元素
类有多个子类，每个子类定义了不同的
过程（）
行为

问题是通过传递两个
元素来实例化
节点
：

class Node:
    def __init__(self, bracket, home_element, away_element):
        pass

但是
元素
也通过传递
节点
来实例化，因为
process（）
方法作用于在
括号
和
PlayoffCreator
中找到的数据，两者都可以通过
节点
访问

class Element:
    def __init__(self, node):
        pass

人们通常如何处理实例化问题的这种循环依赖性？
我认为有两种可能性

1-实例化这两个元素，然后设置依赖项

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

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

a = A()
b = B()
a.b = b
b.a = a

您可以通过在
a
的构造函数中添加一个默认为
None
的
b
可选参数，并对
b
执行同样的操作来进一步推动这一点：

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

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

这允许您通过传递第一个实例来实例化第二个实例：

a = A()
b = B(a)
a.b = b

2-在
A
实例化中实例化
B
，然后获取该实例

class A:
    def __init__(self):
        self.b = B(self)

class B:
    def __init__(self, a):
        self.a = a

a = A()
b = a.b


两种方法各有优缺点。
我更喜欢n°1，因为它更灵活，因为对称。
但是，如果两个类之间存在逻辑层次结构，也可以使用n°2