C3 线性化算法与 MRO之Python中的多继承

python 中的方法解析顺序（method resolution order, mro）定义了多继承存在时 python 解释器查找函数解析的正确方式。当 python 版本从 2.2 发展到 2.3 再到现在的 python 3，mro算法也随之发生了相应的变化。这种变化在很多时候影响了我们使用不同版本 python 编程的过程。

什么是 mro

mro 全称方法解析顺序（method resolution order）。它定义了 python 中多继承存在的情况下，解释器查找函数解析的具体顺序。什么是函数解析顺序？我们首先用一个简单的例子来说明。请仔细看下面代码：

class a():
    def who_am_i(self):
        print("i am a")
        
class b(a):
    pass
        
class c(a):
    def who_am_i(self):
        print("i am c")

class d(b,c):
    pass
    
d = d()

如果我问在 python 2 中使用 d 的实例调用 d.who_am_i()，究竟执行的是 a 中的 who_am_i() 还是 c 中的 who_am_i()，我想百分之九十以上的人都会不假思索地回答：肯定是 c 中的 who_am_i()，因为 c 是 d 的直接父类。然而，如果你把代码用 python 2 运行一下就可以看到 d.who_am_i() 打印的是 i am a。

是不是觉得很混乱很奇怪？感到奇怪就对了！！！

这个例子充分展示了 mro 的作用：决定基类中的函数到底应该以什么样的顺序调用父类中的函数。可以明确地说，python 发展到现在，mro 算法已经不是一个凭借着执行结果就能猜出来的算法了。如果没有深入到 mro 算法的细节，稍微复杂一点的继承关系和方法调用都能彻底绕晕你。

new-style class vs. old-style class

在介绍不同版本的 mro 算法之前，我们有必要简单地回顾一下 python 中类定义方式的发展历史。尽管在 python 3 中已经废除了老式的类定义方式和 mro 算法，但对于仍然广泛使用的 python 2 来说，不同的类定义方式与 mro 算法之间具有紧密的联系。了解这一点将帮助我们从 python 2 向 python 3 迁移时不会出现莫名其妙的错误。

在 python 2.1 及以前，我们定义一个类的时候往往是这个样子（我们把这种类称为 old-style class)：

class a:
    def __init__(self):
        pass

python 2.2 引入了新的模型对象（new-style class），其建议新的类型通过如下方式定义：

class a(object):
    def __init__(self):
        pass

注意后一种定义方式显示注明类 a 继承自 object。python 2.3 及后续版本为了保持向下兼容，同时提供以上两种类定义用以区分 old-style class 和 new-style class。python 3 则完全废弃了 old-style class 的概念，不论你通过以上哪种方式书写代码，python 3 都将明确认为类 a 继承自 object。这里我们只是引入 old-style 和 new-style 的概念，如果你对他们的区别感兴趣，可以自行看。

理解 old-style class 的 mro

我们使用前文中的类继承关系来介绍 python 2 中针对 old-style class 的 mro 算法。如果你在前面执行过那段代码，你可以看到调用 d.who_am_i() 打印的应该是 i am a。为什么 python 2 的解释器在确定 d 中的函数调用时要先搜索 a 而不是先搜索 d 的直接父类 c 呢？

这是由于 python 2 对于 old-style class 使用了非常简单的基于深度优先遍历的 mro 算法（关于深度优先遍历，我想大家肯定都不陌生）。当一个类继承自多个类时，python 2 按照从左到右的顺序深度遍历类的继承图，从而确定类中函数的调用顺序。这个过程具体如下：

检查当前的类里面是否有该函数，如果有则直接调用。
检查当前类的第一个父类里面是否有该函数，如果没有则检查父类的第一个父类是否有该函数，以此递归深度遍历。
如果没有则回溯一层，检查下一个父类里面是否有该函数并按照 2 中的方式递归。

上面的过程与标准的深度优先遍历只有一点细微的差别：步骤 2 总是按照继承列表中类的先后顺序来选择分支的遍历顺序。具体来说，类 d 的继承列表中类顺序为 b, c，因此，类 d 按照先遍历 b 分支再遍历 c 分支的顺序来确定 mro。

我们继续用第一个例子中的函数继承图来说明这个过程：

按照上述深度递归的方式，函数 d.who_am_i() 调用的搜索顺序是 d, b, a, c, a。由于一个类不能两次出现，因此在搜索路径中去除掉重复出现的 a，得到最终的方法解析顺序是 d, b, a, c。这样一来你就明白了为什么 d.who_am_i() 打印的是 i am a 了。

在 python 2 中，我们可以通过如下方式来查看 old-style class 的 mro：

>>> import inspect
>>> inspect.getmro(d)

理解 new-style class 的 mro

从上面的结果可以看到，使用深度优先遍历的查找算法并不合理。因此，python 3 以及 python 2 针对 new-style class 采用了新的 mro 算法。如果你使用 python 3 重新运行一遍上述脚本，你就可以看到函数 d.who_am_i() 的打印结果是 i am c。

>>> d.who_am_i()
i am c
>>> d.__mro__
(<class 'test.d'>, <class 'test.b'>, <class 'test.c'>, <class 'test.a'>, <class 'object'>)

新算法与基于深度遍历的算法类似，但是不同在于新算法会对深度优先遍历得到的搜索路径进行额外的检查。其从左到右扫描得到的搜索路径，对于每一个节点解释器都会判断该节点是不是好的节点。如果不是好的节点，那么将其从当前的搜索路径中移除。

那么问题在于，什么是一个好的节点？我们说 n 是一个好的节点当且仅当搜索路径中 n 之后的节点都不继承自 n。我们还以上述的类继承图为例，按照深度优先遍历得到类 d 中函数的搜索路径 d, b, a, c, a。之后 python 解释器从左向右检查时发现第三个节点 a 不是一个好的节点，因为 a 之后的节点 c 继承自 a。因此其将 a 从搜索路径中移除，然后得到最后的调用顺序 d, b, c, a。

采用上述算法，d 中的函数调用将优先查找其直接父类 b 和 c 中的相应函数。