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添加两个父类时：

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

是的，保证如document中所述，它引入了计算方法解析顺序的新算法（C3 linearization）。

不对其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的线性化开始（{{1除外） }}），然后将遵循object等的线性化，它将以B2的线性化结束：

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'>]之间有一些共同的子类时，事情开始变得奇怪了，在这种情况下，python会发现你期望的顺序不违反本地优先顺序和单调性，或者它会引发错误。

Answer 2

以下是详细解释的方法解决顺序：http://www.python.org/download/releases/2.3/mro/

Python docs（词汇表）实际上指向了这一点。

根据我的经验，跨实现使用是安全的。您可以使用__mro__或mro()检查分辨率顺序。

class A(object):
    def hello(self):
        print 'hello from A'

class B(object):
    def hello(self):
        print 'hello from B'

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

>>> C()
hello from A
>>> print C.__mro__
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <type 'object'>)
>>> print C.mro()
[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <type 'object'>]

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

2 个答案: