Python 的“钻石继承（Diamond Inheritance）”是多重继承里最经典的问题之一。

它最大的难点不是语法。

而是：

多个父类之间到底该按什么顺序初始化和调用方法。

很多人第一次接触时都会被：

super()

MRO

重复初始化

方法调用顺序

绕晕。

什么是钻石继承

结构像这样：

A

/ \

B C

\ /

D

也就是：

B 和 C 都继承 A

D 同时继承 B 和 C

代码：

class A:

pass

class B(A):

pass

class C(A):

pass

class D(B, C):

pass

因为继承关系像钻石：

所以叫：

Diamond Problem

最核心的问题

假设：

class A:

def hello(self):

print("A")

class B(A):

pass

class C(A):

pass

class D(B, C):

pass

调用：

D().hello()

问题来了：

到底应该走哪条路径？

是：

D -> B -> A

还是：

D -> C -> A

Python 的解决方案：MRO

Python 使用：

MRO

Method Resolution Order（方法解析顺序）

决定：

属性查找顺序

方法调用顺序

super() 行为

查看 MRO

print(D.__mro__)

输出：

(,

,

)

说明：

Python 查找顺序：

D → B → C → A → object

所以：

D().hello()

最终会找到：

A.hello

为什么不能简单 DFS？

很多语言早期就踩过坑。

如果简单深度优先：

D -> B -> A

D -> C -> A

那么：

A.__init__()

可能执行两次。

这就是经典钻石问题。

Python 如何避免重复调用

Python 使用：

C3 Linearization

规则核心：

保持继承顺序

保持局部优先级

每个类只出现一次

所以：

A

只会出现在 MRO 一次。

最大坑：手动调用父类

很多新手这样写：

class A:

def __init__(self):

print("A")

class B(A):

def __init__(self):

A.__init__(self)

print("B")

class C(A):

def __init__(self):

A.__init__(self)

print("C")

class D(B, C):

def __init__(self):

B.__init__(self)

C.__init__(self)

print("D")

输出：

A

B

A

C

D

问题：

A.__init__()

执行了两次。

这就是：

手动调用父类导致钻石重复初始化。

正确方案：super()

Python 的多继承核心不是：

父类名.__init__()

而是：

super()

正确写法：

class A:

def __init__(self):

print("A")

class B(A):

def __init__(self):

super().__init__()

print("B")

class C(A):

def __init__(self):

super().__init__()

print("C")

class D(B, C):

def __init__(self):

super().__init__()

print("D")

输出：

A

C

B

D

注意：

A

只执行一次。

为什么顺序这么奇怪？

很多人第一次看到：

A

C

B

D

会懵。

因为：

super()

不是：

调用父类

而是：

调用 MRO 中下一个类

D 的 MRO

D -> B -> C -> A -> object

调用链：

D.__init__()

→ B.__init__()

→ C.__init__()

→ A.__init__()

然后回退：

A

C

B

D

super() 真正的本质

很多人误解：

super()

是：

父类调用器

实际上不是。

它本质是：

“MRO 下一跳代理”。

所以：

super()

永远依赖：

__mro__

一个非常危险的问题

如果某个类不 cooperative：

例如：

class C(A):

def __init__(self):

print("C")

没有：

super().__init__()

那么：

MRO 链断掉

后面的类不会执行。

这是多继承里最难排查的问题之一。

参数传递也是大坑

例如：

class A:

def __init__(self, x):

self.x = x

多继承后：

每个类都必须：

接受 *args, **kwargs

继续向后传递

否则：

TypeError

非常容易出现。

标准 cooperative 写法：

class A:

def __init__(self, *args, **kwargs):

super().__init__(*args, **kwargs)

class B(A):

def __init__(self, name, **kwargs):

self.name = name

super().__init__(**kwargs)

mixin 为什么大量依赖 super()

Python 的：

Mixin

设计就是：

默认参与 cooperative multiple inheritance。

例如：

class LoggingMixin:

def save(self):

print("log")

super().save()

这要求：

所有类都遵守：

super()

协议。

object 为什么这么重要

Python 3：

class A:

实际上：

class A(object):

所有类最终：

→ object

这是：

MRO 终点

cooperative inheritance 链终点

MRO 冲突

有些继承结构：

Python 会直接拒绝。

例如：

class X: pass

class Y: pass

class A(X, Y): pass

class B(Y, X): pass

class C(A, B): pass

直接：

TypeError:

Cannot create a consistent method resolution order

因为：

MRO 无法同时满足：

X 在 Y 前

Y 在 X 前

Python 多继承真正的隐藏规则

Python 实际上要求：

所有类都必须 cooperative。

即：

都使用 super()

都遵守 MRO

都不直接点名父类

否则：

初始化重复

链断裂

方法漏调用

状态不一致

最佳实践

1. 永远用 super()

不要：

A.__init__(self)

2. 所有类都 cooperative

每层：

super().__init__()

3. 多继承主要用于 mixin

而不是复杂业务树。

4. 查看 MRO

调试神器：

print(Class.__mro__)

一句话总结

Python 的钻石继承真正难的不是：

“多个父类”。

而是：

super() 调用的根本不是“父类”，而是 MRO 链中的“下一跳”。

整个多继承体系本质上依赖：

C3 Linearization + cooperative super()

只要有一个类不配合：

整个继承链就可能出现诡异行为。

Python 中的多重继承钻石问题