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 ave Bave leave B enter leave enter 紙A leave D leave F

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

   object
  |      
  |        A
  |          
     E    |
          |
         F

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

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

F E B C D A object

　　從而說明了為什麼在C.__init__中使用super(C, self).__init__self)會調用類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()，執行結果：

f = F()，執行結果：com A leave D leave C leave B leave E leave F

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

小結

　　1. super並不是一個函數，是一個類名，形如super(B, self)事實上調用了super類的初始化函數，
      產生了一個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順序的實現，