python 多繼承詳解

class A(object):    # A must be new-style class   def __init__(self):    print "enter A"    print "leave A"  class B(C):     # A --> C   def __init__(self):    print "enter B"    super(B, self).__init__()    print "leave B"

在我們的印象中，對於super(B, self).__init__()是這樣理解的：super(B, self)首先找到B的父類（就是類A），然後把類B的對象self轉換為類A的對象，然後“被轉換”的類A對象調用自己的__init__函數。

有一天某同事設計了一個相對複雜的類體繫結構（我們先不要管這個類體系設計得是否合理，僅把這個例子作為一個題目來研究就好），代碼如下

程式碼片段4：

class A(object):    def __init__(self):        print "enter A"        print "leave A"  class B(object):    def __init__(self):        print "enter B"        print "leave B"  class C(A):    def __init__(self):        print "enter C"        super(C, self).__init__()        print "leave C"  class D(A):    def __init__(self):        print "enter D"        super(D, self).__init__()        print "leave D"        class E(B, C):        def __init__(self):        print "enter E"        B.__init__(self)        C.__init__(self)        print "leave E"  class F(E, D):    def __init__(self):        print "enter F"        E.__init__(self)        D.__init__(self)        print "leave F"

f = F() ，結果如下：

enter F enter E enter B leave B enter C enter D enter A leave A leave D leave C leave E enter D enter A leave A leave D leave F

明顯地，類A和類D的初始化函數被重複調用了2次，這並不是我們所期望的結果！我們所期望的結果是最多隻有類A的初始化函數被調用2次——其實這是多繼承的類體系必須面對的問題。我們把程式碼片段4的類體系畫出來，如：

object
| \
| A
| / |
B C D
\ / |
E |
\ |
F

按我們對super的理解，可以看出，在調用類C的初始化函數時，應該是調用類A的初始化函數，但事實上卻調用了類D的初始化函數。好一個詭異的問題！

也就是說，mro中記錄了一個類的所有基類的類類型序列。查看mro的記錄，發覺包含7個元素，7個類名分別為：

F E B C D A object

　　從而說明了為什麼在C.__init__中使用super(C, self).__init__()會調用類D的初始化函數了。 ???

　　我們把程式碼片段4改寫為：

程式碼片段5：

class A(object):    def __init__(self):        print "enter A"        super(A, self).__init__()  # new        print "leave A"  class B(object):    def __init__(self):        print "enter B"        super(B, self).__init__()  # new        print "leave B"  class C(A):    def __init__(self):        print "enter C"        super(C, self).__init__()        print "leave C"  class D(A):    def __init__(self):        print "enter D"        super(D, self).__init__()        print "leave D"        class E(B, C):        def __init__(self):        print "enter E"        super(E, self).__init__()  # change        print "leave E"  class F(E, D):    def __init__(self):        print "enter F"        super(F, self).__init__()  # change        print "leave F"

f = F()，執行結果：

enter F enter E enter B enter C enter D enter A leave A leave D leave C leave B leave E leave F

可見，F的初始化不僅完成了所有的父類的調用，而且保證了每一個父類的初始化函數只調用一次。

小結

　　1. super並不是一個函數，是一個類名，形如super(B, self)事實上調用了super類的初始化函數，
產生了一個super對象；
　　2. super類的初始化函數並沒有做什麼特殊的操作，只是簡單記錄了類類型和具體執行個體；
　　3. super(B, self).func的調用並不是用於調用當前類的父類的func函數；
　　4. Python的多繼承類是通過mro的方式來保證各個父類的函數被逐一調用，而且保證每個父類函數
只調用一次（如果每個類都使用super）；
　　5. 混用super類和非綁定的函數是一個危險行為，這可能導致應該調用的父類函數沒有調用或者一
個父類函數被調用多次。

一些更深入的問題：各位可以看到，print F.__mro__時發現裡面元素的順序是 F E B C D A object，這就是F的基類尋找順序，至於為什麼是這樣的順序，以及python內建的多繼承順序是怎麼實現的，這涉及到mro順序的實現，python 2.3以後的版本中是採用的一個叫做C3的演算法，在下篇部落格中進行介紹。

