解释一下Python的MRO（方法解析顺序）。

夢幻星辰

发布时间：2025-09-05 22:23:01

936人浏览过

来源于php中文网

原创

Python的MRO通过C3线性化算法确定多重继承中方法的查找顺序，解决菱形继承问题，确保调用的确定性与一致性，避免歧义，并为super()提供调用链依据，使类间的协作式继承得以实现。

解释一下python的mro（方法解析顺序）。

Python的MRO，也就是方法解析顺序，说白了，就是Python在处理类继承，特别是当一个类从多个父类那里继承东西的时候，它到底该去哪个父类那里找方法和属性的规则。它给出了一个明确的查找顺序，这样我们就知道，当调用一个方法时，Python会沿着哪条路径去找到它，确保了行为的稳定性和可预测性。

MRO的出现，很大程度上是为了解决多重继承带来的复杂性，特别是所谓的“菱形继承问题”（Diamond Problem）。想象一下，A是B和C的父类，B和C又都是D的父类。如果B和C都重写了A的一个方法，那么D在调用这个方法时，到底应该用B的版本还是C的版本？Python的MRO通过C3线性化算法给出了一个优雅的解决方案。

C3算法有几个核心原则，理解它们对于把握MRO至关重要：

局部优先顺序： 子类永远优先于其父类被检查。也就是说，一个类自身的方法会优先于其父类的方法被找到。
单调性： 如果一个类在某个MRO序列中出现在另一个类之前，那么在所有继承自这个类的子类的MRO中，这个顺序也必须保持。这保证了MRO的逻辑一致性。
头部优先： 在构建MRO列表时，总是从当前类的MRO和其所有父类的MRO中选择“头部”元素。这个头部元素必须满足一个条件：它不能出现在任何一个剩余的MRO列表中作为非头部元素。

简单来说，C3算法会尝试创建一个扁平化的类列表，这个列表既要尊重每个类的继承关系（子类在父类之前），又要尊重同级别父类之间的相对顺序。如果这些条件导致冲突，Python会抛出

TypeError

，告诉你“Cannot create a consistent method resolution order”。

立即学习“Python免费学习笔记（深入）”；

每个类都有一个特殊的

__mro__

属性，它是一个元组，包含了该类及其所有父类按照MRO顺序排列的列表。我们也可以通过

ClassName.mro()

方法来获取这个列表。

class A:
    def greet(self):
        print("Hello from A")

class B(A):
    def greet(self):
        print("Hello from B")

class C(A):
    def greet(self):
        print("Hello from C")

class D(B, C):
    pass

d = D()
d.greet()
print(D.__mro__)
# 预期输出: Hello from B (因为B在D的MRO中优先于C)
# (, , , , )

在这个例子中，

继承自

和

。根据MRO，

会比

更早被访问到，所以

d.greet()

会调用

的

greet

方法。这是C3算法确保的一个确定性行为。

Python MRO解决了哪些多重继承的痛点？

多重继承在很多语言中都被视为一个复杂且容易出错的特性。其中最典型的，就是我前面提到的“菱形继承问题”。如果没有一个明确的规则，当一个子类从多个父类继承，而这些父类又共享一个共同的祖先时，方法调用就会变得模糊不清。

MRO的存在，就是为了给这种复杂性提供一个清晰、无歧义的解决方案。它确保了几点：

确定性： 无论继承结构多复杂，MRO总能给出一个唯一的、可预测的方法查找顺序。这避免了开发者在面对多重继承时，需要猜测或依赖编译器/解释器的具体实现。
避免歧义： 通过C3线性化算法，MRO解决了“菱形问题”带来的方法冲突。它会按照一个严格的规则（局部优先、单调性等）来决定哪个父类的方法应该被调用，而不是随机选择或抛出难以理解的错误。
所有基类被访问： MRO保证了在查找过程中，所有相关的基类都会被访问到，并且每个基类只会被访问一次。这避免了无限递归，也确保了继承链的完整性。
协作式继承的基础： MRO为
```
super()
```
函数的正确运作提供了基础。没有一个明确的MRO，
```
super()
```
就无法知道“下一个”应该调用的方法是哪个，也就无法实现类之间方法调用的协作。

在我看来，MRO不仅仅是一个技术实现细节，它更是Python设计哲学中“显式优于隐式”的一个体现。它将多重继承的复杂性暴露出来，并通过一套可理解的规则加以规范，而不是试图隐藏它或完全禁止它，这让开发者能够更安全、更有效地利用多重继承的强大功能。

如何查看和理解一个类的MRO？

理解MRO的关键在于能够正确地查看和解读它。Python为我们提供了两种主要方式来获取一个类的MRO：

使用Python进行socket编程中文WORD版

本文档主要讲述的是使用Python进行socket编程；作为一种解释性语言，Python 很容易使用，并且能够快速验证我们的想法和开发原型软件。Python 程序可以作为一个整体进行解释，也可以一行行地解释。有需要的朋友可以下载看看

下载

```
__mro__
```
属性： 这是一个只读的元组，直接存储在每个类对象上。
```
class Base: pass
class Mixin1(Base): pass
class Mixin2(Base): pass
class MyClass(Mixin1, Mixin2): pass

print(MyClass.__mro__)
# 输出示例: (, , , , )
```
这个元组的第一个元素总是类本身，最后一个元素总是
```
object
```
（除非该类就是
```
object
```
）。中间的顺序就是Python查找方法和属性的路径。
```
mro()
```
方法： 这是一个类方法，返回一个列表，与
```
__mro__
```
的内容相同，但它是可变的（虽然通常我们不应该去修改它）。
```
print(MyClass.mro())
# 输出示例: [, , , , ]
```
两者功能基本一致，
```
mro()
```
方法更常用在需要动态获取MRO的场景，或者在交互式环境中直接调用。

理解MRO的顺序，其实就是理解C3线性化算法的结果。当你看一个MRO列表时，记住以下几点：

左侧优先： 在多重继承中，排在基类列表左侧的类，通常在MRO中会更早出现。比如
```
class D(B, C)
```
，
```
B
```
会在
```
C
```
之前被检查。
子类优先于父类： 任何时候，一个类都会在它的父类之前被检查。
共同祖先只出现一次： 即使有共同的祖先（如菱形继承中的
```
A
```
），它也只会在MRO中出现一次，并且会放在所有继承它的子类之后，但又在
```
object
```
之前。

举个稍微复杂点的例子：

class Grandparent:
    def who_am_i(self): print("Grandparent")

class Parent1(Grandparent):
    def who_am_i(self): print("Parent1")

class Parent2(Grandparent):
    def who_am_i(self): print("Parent2")

class Child(Parent1, Parent2):
    # 如果Child没有who_am_i，它会调用Parent1的
    pass

print(Child.__mro__)
# 预期输出: (, , , , )

child_obj = Child()
child_obj.who_am_i() # 会输出 Parent1

从MRO可以看出，查找顺序是