什么是MRO（方法解析顺序）？它是如何工作的？

幻影之瞳

发布时间：2025-09-05 20:18:01

1067人浏览过

来源于php中文网

原创

MRO通过C3线性化算法确定多重继承中方法的调用顺序，解决菱形继承的歧义问题；例如类C(A, B)时，MRO为[C, A, B, O]，确保方法查找顺序明确且一致，支持super()的协作调用。

什么是mro（方法解析顺序）？它是如何工作的？

MRO，即方法解析顺序（Method Resolution Order），是Python在处理类继承，尤其是在多重继承场景下，确定方法或属性查找顺序的机制。它决定了当你调用一个对象的方法时，Python解释器会沿着哪个路径去查找并执行这个方法。说白了，就是Python如何决定哪个父类的方法才是“正确”的那个。

Python的MRO机制，在我看来，是其面向对象设计中一个非常精妙且实用的部分，尤其是在应对多重继承带来的复杂性时。它主要通过C3线性化算法来确定一个类的MRO。这个算法确保了方法查找的顺序是确定且一致的，避免了多重继承中常见的“菱形问题”（Diamond Problem）带来的歧义。

当一个类继承自多个父类时，Python需要一个明确的规则来决定如果多个父类都有同名方法，到底应该调用哪一个。C3算法的核心思想是：

子类优先于父类： 如果子类自己定义了某个方法，那么肯定优先使用子类的方法。
基类优先于其兄弟类： 如果一个类有多个父类，并且这些父类之间也存在继承关系，那么会优先考虑更“左边”的基类。
保持局部顺序： 父类列表中的相对顺序必须保留。如果
```
A
```
继承自
```
B
```
和
```
C
```
(
```
class A(B, C):
```
)，那么在
```
A
```
的MRO中，
```
B
```
必须出现在
```
C
```
之前。
单调性原则： 如果一个类
```
C
```
在其父类
```
P
```
的MRO中出现在
```
X
```
之前，那么
```
C
```
也必须出现在任何
```
P
```
的子类的MRO中
```
X
```
之前。

这些规则共同作用，生成了一个唯一的、线性的类列表，这就是该类的MRO。你可以通过访问

类名.__mro__

属性或使用

inspect.getmro(类名)

函数来查看任何类的MRO。这个顺序对于

super()

函数的正确工作至关重要，

super()

正是依赖MRO来确定下一个要调用的方法。

为什么Python需要MRO，它解决了哪些多重继承的难题？

在我看来，Python引入MRO主要是为了解决多重继承中的核心痛点——方法解析的歧义性，特别是经典的“菱形问题”。设想一下，你有一个基类

，然后有两个类

和

都继承自

。接着，你又创建了一个类

，它同时继承自

和

。现在，如果

中都有一个同名的方法

foo()

，那么当你在

的实例上调用

d.foo()

时，Python应该调用哪个

foo()

呢？

如果没有一个明确的MRO机制，这就会变成一个难以预测的“坑”。不同的语言有不同的处理方式，有些可能直接报错，有些可能采用深度优先或广度优先的简单规则，但这往往会导致行为不一致或难以调试。Python的C3线性化算法，正是为了提供一个确定性、一致且可预测的方法查找顺序。它确保了：

避免重复调用基类方法： 在菱形继承中，基类
```
A
```
可能会被
```
B
```
和
```
C
```
分别继承。MRO确保
```
A
```
只在MRO列表中出现一次，并且在所有其子类之前。
维护继承链的逻辑性： 它尊重了子类优先于父类，以及在多重继承声明中“从左到右”的优先顺序，这符合我们直观上的设计意图。
支持
super()
的协作式多重继承： MRO是
```
super()
```
能够正常工作的基石。
```
super()
```
并不是简单地调用父类，而是根据MRO找到当前类在MRO中的下一个类，从而实现协作式的、非侵入性的方法调用链。这让多重继承在Python中变得更加实用和健壮。

简而言之，MRO把一个潜在的混乱局面，变成了一个有章可循、可预测的系统，让开发者在设计复杂的类层次结构时，能有更强的信心和控制力。

Sesame AI

一款开创性的语音AI伴侣，具备先进的自然对话能力和独特个性。

下载

C3线性化算法是如何确定MRO的，能举例说明吗？

C3线性化算法，听起来有点高深，但它其实是一套相当优雅的规则集合，旨在为类生成一个唯一的、单调的MRO。我个人觉得，理解C3算法最好的方式就是通过一个具体的例子来追踪它的每一步。

C3算法计算一个类

的MRO (

L[C]

) 的基本公式是：

L[C] = C + merge(L[P1], L[P2], ..., L[Pn], P1...Pn)

其中，

P1...Pn

是

的直接父类列表（按照它们在类定义中出现的顺序）。

merge

函数是关键，它会从所有父类的MRO列表和父类列表中选择“好的”头部元素。一个元素

被认为是“好的”头部，当且仅当

不出现在任何其他列表的尾部。如果找到一个“好的”头部，就把它添加到

L[C]

，然后从所有列表中移除

，重复这个过程直到所有列表都为空。

我们来看一个经典的菱形继承例子：

class O: pass
class A(O): pass
class B(O): pass
class C(A, B): pass

# 我们来手动推导 C 的 MRO
# L[O] = [O]
# L[A] = [A] + merge(L[O], [O]) = [A, O]
# L[B] = [B] + merge(L[O], [O]) = [B, O]

# 现在计算 L[C] = [C] + merge(L[A], L[B], [A, B])
# L[A] = [A, O]
# L[B] = [B, O]
# [A, B] 是 C 的直接父类列表

# merge([A, O], [B, O], [A, B]) 的过程：
# 1. 检查第一个列表的头部：A。A不在其他列表的尾部。所以，取 A。
#    结果: [A]
#    剩余列表: [O], [B, O], [B]

# 2. 检查第一个列表的头部：O。O在第二个列表的尾部，不能取。
#    检查第二个列表的头部：B。B不在其他列表的尾部。所以，取 B。
#    结果: [A, B]
#    剩余列表: [O], [O], []

# 3. 检查第一个列表的头部：O。O不在其他列表的尾部。所以，取 O。
#    结果: [A, B, O]
#    剩余列表: [], [], []

# 最终 L[C] = [C] + [A, B, O] = [C, A, B, O]

通过