Python和多重继承中的方法顺序

Question

在Python中，如果您使用相同的方法定义两个类，并希望这两个类成为父类，则如下所示：

class A(object):
     def hello(self):
         print "hello from class a"

和：

class B(object):
     def hello(self):
         print "hello from class b"

当您定义子类并以A和B的顺序html" target="_blank">添加两个父类时：

class C(A, B):
     def __init__(self):
         self.hello()

调用self.method（）时使用的方法是属于A的方法，即继承列表中的第一个类：

>>> C()
hello from class a
<__main__.C object at 0x10571e9d0>

尽管在我所有的测试用例中似乎都是如此，但我无法在文档或在线中找到在任何平台和该语言实现中都可以安全使用的地方。任何人都可以肯定地说，假设列表中的第一个继承的类将始终是其他类所使用的方法（无论super（）.
init
（）调用如何），还是可以将我指向确认这一事实的官方文档呢？

谢谢，

Answer 1

是的，可以保证，如介绍新算法以计算方法分辨率顺序（即C3线性化）的文档中所述。

不使用此算法的mro实现并不真正符合python语言（2.3版以上）。AFAIK当前所有实现 都 使用C3线性化。

C3线性化满足局部优先级排序和单调性。本地优先级排序意味着一类C(B1, ..., Bn)将在mro基类Bi中具有在继承列表中列出的顺序。

一个例子也许可以更好地解释单调性：

>>> class A(object): pass
>>> class B(object): pass
>>> class C(object): pass
>>> class D(object): pass
>>> class E(object): pass
>>> class K1(A,B,C): pass
>>> class K2(D,B,E): pass
>>> class K3(D,A):   pass
>>> class Z(K1,K2,K3): pass

python2.2的旧mro（ 不是 单调的），这些是上述类的线性化：

L[A] = A O
L[B] = B O
L[C] = C O
L[D] = D O
L[E] = E O
L[K1]= K1 A B C O
L[K2]= K2 D B E O
L[K3]= K3 D A O
L[Z] = Z K1 K3 A K2 D B C E O
# in current versions of python (2.3+):
# L[Z] = Z K1 K2 K3 D A B C E O

在这里，您可以看到，在的线性化中Z，类位于A之前D，而在其线性化中K3则位于 之后
D。单调性是线性化的属性，因此在继承时不存在此类交换。如果某个类X在Y其父级的所有线性化中均在类之前，则Y在最终线性化中它也将在类之前。

现在，如果我们考虑一堂课C(B1, ..., Bn)。按照局部优先顺序，这些类B1, ..., Bn将在的线性化中按该顺序找到C。通过单调性，我们无法Bi在Bi自身之前找到s的子类。由此可见，的线性化（C如果存在）必须以C和开头B1。

请注意，在某些情况下，您 无法 计算线性化，而python会抱怨，例如：

>>> class A(object):pass
... 
>>> class B(object, A): pass
... 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Cannot create a consistent method resolution
order (MRO) for bases object, A

但是，如果交换类，则可以线性化层次结构：

>>> class B(A, object): pass
... 
>>> B.mro()
[<class '__main__.B'>, <class '__main__.A'>, <class 'object'>]

如果父类没有共同的基数（object显然不是其他基数），那么显然的线性化C(B1, ..., Bn)将以B1（除外object）的线性化开始，然后将遵循B2etc的线性化，并将以：的线性化结束Bn：

>>> class A(object): pass
... 
>>> class B(object): pass
... 
>>> class A1(A): pass
... 
>>> class A2(A1): pass
... 
>>> class B1(B): pass
... 
>>> class C(object): pass
... 
>>> class C1(C): pass
... 
>>> class C2(C1):pass
... 
>>> class C3(C2): pass
... 
>>> class D(A2, B1, C3): pass
... 
>>> D.mro()
[<class '__main__.D'>, <class '__main__.A2'>, <class '__main__.A1'>, <class '__main__.A'>, <class '__main__.B1'>, <class '__main__.B'>, <class '__main__.C3'>, <class '__main__.C2'>, <class '__main__.C1'>, <class '__main__.C'>, <class 'object'>]

当Bis之间有一些通用子类时，事情开始变得怪异，在这种情况下python找到了您期望的不违反局部优先顺序和单调性的顺序，否则将引发错误。