Python的程序结构[2] -> 类/Class[2] -> 方法解析顺序 MRO

方法解析顺序 / MRO (Method Resolution Order)

---

关于方法解析顺序（MRO）的详细内容可以参考文末链接，这里主要对 MRO 进行简要的总结说明以及一些练习示例。

 

经典类和新式类的 MRO

---

经典类

描述: 一种不能继承的类，如果经典类为父类，其子类调用父类的构造函数时会报错。且不具备 __mro__ 属性。

MRO: Deepth First Search (DFS) / 深度优先搜索

新式类

描述: 新式类是一种为了解决经典类中只能继承不能重写的问题而引入的，新式类默认继承自 object，且子类可以调用父类构造函数，在 Python 之后均为新式类。

MRO: C3算法

下面的代码以 Python2.7 和 Python3.4 分别运行将产生不一样的结果，这是由于在 Python3 中默认使用了新式类，因此采用了 C3 搜索，而 Python2 中默认为经典类，采用 DFS 搜索，因此产生了不同，若将 A 的基类指定为 object 则输出将变为相同。

"""
    A
   /\
  /  \
 B    C
  \  /
   \/
   D
"""
from distutils.log import warn as printf

class A:
    def __init__(self):
        pass

    def show(self):
        printf("This is A")


class B(A): pass


class C(A):
    def show(self):
        printf("This is C")

class D(B, C): pass

d = D()
d.show()    
# Python2 --> This is A
# Python3 --> This is C

 

DFS / BFS / C3

---

主要以正常继承和菱形继承为例分别说明三种算法的缺陷和优势。

DFS深度优先搜索

利用深度优先搜索，对于正常继承可以很好的完成搜索，但当出现菱形继承时，则会出现搜索的缺陷，在菱形继承中 MRO 的顺序为 ABDC，若此时 C 重写了 D 的方法，可由于继承顺序的问题，将导致优先搜索到 D 的方法，也就是说，C 的重写是无效的，C 对于 D 只能继承，不能重写。

 

BFS广度优先搜索

       广度优先搜索则恰好和深度优先搜索相反，在菱形继承中能够很好的完成搜索，而在普通搜索中却出现了一定缺陷，普通搜索的顺序为ABCDE，但这却违反了单调性原则，即B和C是两个互不相关的父类，在B搜索结束后应该优先搜索D而非C。

C3算法

       基于上述的两种算法缺陷，Python2.3之后的新式类中MRO全都采用了C3算法，这种算法解决了DFS的只能继承无法重写的问题和BFS的单调性问题。

 

Merge List公式

---

C3 算法的继承模式主要采用了 merge list 公式，首先假设类的线性化 MRO 记为 L[C]=[C1, C2, C3]，则称 C1 为 L[C] 的头，其余为尾。若 C 继承自 B1，B2…，则可以根据以下公式计算出 L[C]，

L[object] = [object]   
L[C(B1…BN)] = [C] + merge(L[B1]…L[BN], [B1]…[BN])   

整个计算公式的关键在于 merge，输入为一组列表，输出为一个列表，输出方式为，

1. 检查第一个列表的头元素(如 L[B1] 的头)，记为 H;

2. 若 H 未出现在其他列表的尾部，则输出该元素，并删除所有列表中的 H，然后重复步骤 1。若 H 出现在其他列表的尾部，则取下一个列表的头部继续步骤。

3. 重复步骤直至列表为空，则算法结束，若列表不为空且无法输出元素，则说明无法构建继承关系，此时抛出异常。

下面分别举例来构建一个异常的继承关系和正常的继承进行对比，

异常继承

"""
     ________
    /        \   
    X   Y    |
    \  /\   /
     \/  \ /
      A   B
      \  /
       \/
       C
"""

class X(object): pass

class Y(object): pass

class A(X, Y): pass

class B(Y, X): pass

class C(A, B): pass

print(C.__mro__)

这段代码最终会报错，

Traceback (most recent call last):
  File "C:\Users\EKELIKE\Documents\Python Note\3_Program_Structure\3.3_Class\mro_c3_error.py", line 21, in <module>
    class C(A, B): pass
TypeError: Cannot create a consistent method resolution
order (MRO) for bases X, Y

原因在于 merge 公式计算到最后无法输出参数，即构建继承失败，计算过程如下，

C3 Algothrim Calculation:
L[object] = [object]
L[X] = [X] + merge(L[object]) = [X, object]
L[Y] = [Y] + merge(L[object]) = [Y, object]
L[A] = [A] + merge(L[X], L[Y], [X], [Y]) = [A, X, Y, object]
L[B] = [B] + merge(L[Y], L[X], [Y], [X]) = [B, Y, X, object]
L[C] = [C] + merge(L[A], L[B], [A], [B])
     = [C] + merge([A, X, Y, object], [B, Y, X, object], [A], [B])
     = [C, A, B] + merge([X, Y, object], [Y, X, objcet])
--> Raise Error

 

正常继承

下面给出几个正常继承的示例及其代码，

# C3 MRO
# ----------------------
"""
    Object
    /  |  \
   /   |   \
  X _  Y   Z
  \  \/  /
   \ /\ /
    A  B
     \/
     C
"""

class X(object): pass

class Y(object): pass

class Z(object): pass

class A(X, Y): pass

class B(X, Z): pass

class C(A, B): pass

print(C.__mro__)
# ----------------------

 

# ----------------------
"""
    Object
    /  |  \
   /   |   \
  D    E    F
  \   / \  /
   \ /   \/
    J    K
     \  /
      L
"""

class D(object): pass

class E(object): pass

class F(object): pass

class J(D, E): pass

class K(E, F): pass

class L(J, K): pass

print(L.__mro__)

其中第二种继承的MRO计算公式如下，

C3 Algorithm Calculation:
L[object] = [object]
L[D] = [D] + merge(L[object]) = [D, object]
L[E] = [E] + merge(L[object]) = [E, object]
L[F] = [F] + merge(L[object]) = [F, object]
L[J] = [J] + merge(L[D], L[E], [D], [E]) = [J, D, E, object]
L[K] = [K] + merge(L[E], L[F], [E], [F]) = [K, E, F, object]
L[L] = [L] + merge(L[J], L[K], [J], [K]) 
     = [L, J] + merge([D, E, object], [K, E, F, object], [K])
     = [L, J, D] + merge([E, object], [K, E, F, object], [K])
     = [L, J, D, K] + merge([E, object], [E, F, object])
     = [L, J, D, K, E] + merge([object], [F, object])
     = [L, J, D, K, E, F] + merge([object], [object])
     = [L, J, D, K, E, F, object]

 

查看MRO

---

当然，在使用时我们不必要每次都对类继承顺序进行计算，在 Python 中可以使用以下两种方式来查看一个类的 MRO。

import inspect

# Diamond inherit
class A: pass

class B(A): pass

class C(A): pass

class D(B, C): pass

print(inspect.getmro(D))
print(D.__mro__)

最终得到输出的结果如下，这一结果即是通过 MRO C3 算法进行计算得出的。

(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

 

参考链接

---

http://ju.outofmemory.cn/entry/137896

http://blog.csdn.net/lis_12/article/details/52859376