基本的定义
让我们从一些基本的定义开始。
- 给定一个名为
C的类，在复杂的多继承场景下为它确定重载方法的顺序，即指定C的祖先的顺序，是非常重要的。 -
C祖先(包括C自己)的列表由近到远进行排序，被称为类优先级列表，或者C的线性化。 - 方法解析顺序(MRO)是构成这种线性化的一组规则。在Python中，
C的MRO和C的线性化是同一个意思。 - 例如，在单继承的情况下，如果
C是C1的子类，并且C1是C2的子类，则C的线性化仅仅是列表[C, C1, C2]。然而在多继承的情况下，线性化的构造更加麻烦，因为构建一个同时满足尊重局部优先级顺序和单调性的线性化是很困难的。 - 当满足以下条件时，MRO是单调的：如果在
C的MRO中C1排在C2之前，那么任何C的子类的MRO中C1都应该在C2中。如果违反了这样规则，可能就会引入一些不容易察觉的bug。 - 不是所有的类都允许线性化。在一些复杂的多继承场景下，既想符合所有期望的属性又想生成派生类是不可能的。
考虑下面的情况。
O = object
class X(O): pass
class Y(O): pass
class A(X, Y): pass
class B(Y, X): pass
class C(A, B): pass
不可能从A和B中派生出C，因为在A的MRO中X排在Y前面，而在B的MRO中Y排在X前面。因此C的MRO会是有歧义的。
在Python2.3或以上版本中，上面的情况会抛出一个异常。
TypeError: Error when calling the metaclass bases
Cannot create a consistent method resolution
order (MRO) for bases Y, X
C3 MRO
Python2.3使用了C3方法。
下面的示例中，均用C1C2...CN来表示列表[C1, C2, ..., CN]。
第一个元素是列表的头:
head = C1
其它列表中的元素是尾
tail = C2...CN
下面用
C + (C1C2...CN) = CC1C2...CN
来表示列表的相加
[C] + [C1,C2,...,CN]
下面来说明Python2.3中MRO的具体算法。
假设类C处于多继承的场景下，C继承于基类B1,B2,...BN。现在来计算C的MRO。
规则如下：
类C的线性化是C加上父类的线性化和父类列表的合并。
表达式如下:
L[C(B1...BN)] = C + merge(L(B1)...L[BN], B1...BN)
特别的，如果C是object，那么C的MRO为
L[object] = object
这里的关键在于merge。其输入是一组列表，按照如下方式输出一个列表:
- 检查第一个列表的
head，比如L[B1][0] - 如果这个列表的
head不在其它列表的tail中，则将其加到C的线性化中，并从merge的所有列表中删除这个元素，然后回到步骤1；否则，取出下一个列表的head，继续该步骤 - 重复上述步骤，知道列表为空或者不能再找出可以输出的元素。如果是前一种情况，算法结束；如果是后一种情况，说明无法构建继承关系，Python会抛出异常。
如果是在单继承的场景下，计算是很简单的。
L[C(B)] = C + merge(L[B], B) = C + L(B)
但是在多继承的情况下，会稍微麻烦一点。
例子
比如下面的代码
O = object
class F(O): pass
class E(O): pass
class D(O): pass
class C(D, F): pass
class B(D, E): pass
class A(B, C): pass
继承树
类O,D,E的MRO是很显然的
L[O] = O
L[D] = D O
L[E] = E O
L[F] = F O
类B的MRO公式如下
L[B] = B + merge(DO, EO, DE)
// D 没有在其它的列表的尾中出现，因此将其取出
L[B] = B D + merge(O, EO, E)
// O 在其它列表的尾中出现了。进入下一个列表
// E 没有在其它列表的尾中出现，因此将其取出
L[B] = B D E + merge(O, O)
// O 没有在其它列表的尾中出现，因此将其取出
L[B] = B D E O
通过同样的流程可以算出C的MRO
L[C] = C + merge(DO, FO, DF)
= C + D + merge(O, FO, F)
= C + D + F + merge(O, O)
= C D F O
现在再来计算A的MRO
L[A] = A + merge(BDEO, CDFO, BC)
= A + B + merge(DEO, CDFO, C)
= A + B + C + merge(DEO, DFO)
= A + B + C + D + merge(EO, FO)
= A + B + C + D + E + merge(O, FO)
= A + B + C + D + E + F + merge(O, O)
= A + B + C + D + E + F + O
上面的例子中，根据继承的级别线性化得到了正确的结果。但是并不是所有的情况都能算出结果。
比如下面的例子。
O = object
class F(O): pass
class E(O): pass
class D(O): pass
class C(D, F): pass
class B(E, D): pass
class A(B, C): pass
和上面的例子一样，可以很快算出O,X,Y,A,B的MRO。
L[O] = O
L[X] = X O
L[Y] = Y O
L[A] = A X Y O
L[B] = B Y X O
但是算到C的时候会有一点问题
L[C] = C + merge(AXYO, BYXO, AB)
= C + A + merge(XYO, BYXO, B)
= C + A + B + merge(XYO, YXO)
// X在YXO的尾部，Y在XYO的尾部，计算无法继续进行
这个时候Python2.3会抛出异常，阻止创建C。
