Python面向對象中super用法與MRO機制

1. 引言

　　最近在研究django rest_framework的源碼，老是遇到super，搞得一團蒙，多番查看各路大神博客，總算明白了一點，今天做一點總結。

2. 為什么要用super

1）讓代碼維護更加簡單

　　Python是一門面向對象的語言，定義類時經常用到繼承的概念，既然用到繼承就少不得要在子類中引用父類的屬性，我們可以通過“父類名.屬性名”的方式來調用，代碼如下：

class A:
    def fun(self):
        print('A.fun')

class B(A):
    def fun(self):
        A.fun(self)
        print('B.fun')

　　上述代碼中，我們在子類B中調用了父類A的方法，這時候如果我們改變了A類的類名也只需要在B類中修改一下就好了，但是如果有幾十上百個類繼承了A類呢？一旦A類類名改了，我們就要分別到那幾十上百個子類中修改，不但要改繼承時用到的A類名，調用A類方法時用到的A類名也要改，繁瑣的很，用super就好多了：

class A:
    def fun(self):
        print('A.fun')

class B(A):
    def fun(self):
        super().fun()
        print('B.fun')

　　這時候，就算A類類名改了，也只需要在子類聲明繼承關系時修改就好了，簡單得大多。

2）解決多繼承帶來的重復調用（菱形繼承）、查找順序（MRO）問題
　　上面說到的例子是單繼承，用“父類名.屬性”的方法調用出來代碼維護時繁瑣一點也並無不可，但Python是的繼承機制是多繼承，還是用這種方法來調用父類屬性就會就回帶來許多問題。假如有A、B、C、D這4個類，繼承關系如下，我們要在各子類方法中顯式調用父類的方法（姑且不考慮是否符合需求）：

圖1

　　用“父類名.屬性名” 的方式調用，代碼如下：

class A:
    def fun(self):
        print('A.fun')

class B(A):
    def fun(self):
        A.fun(self)
        print('B.fun')

class C(A):
    def fun(self):
        A.fun(self)
        print('C.fun')

class D(B , C):
    def fun(self):
        B.fun(self)
        C.fun(self)
        print('D.fun')

D().fun()

　　輸出結果為：

　　A.fun
　　B.fun
　　A.fun
　　C.fun
　　D.fun
　　可見，A類被實例化了兩次。這就是多繼承帶來的重復調用（菱形繼承）的問題。使用super可以很好的解決這一問題：

class A:
    def fun(self):
        print('A.fun')

class B(A):
    def fun(self):
        super(B , self).fun()
        print('B.fun')

class C(A):
    def fun(self):
        super(C , self).fun()
        print('C.fun')

class D(B , C):
    def fun(self):
        super(D , self).fun()
        print('D.fun')

D().fun()

　　輸出結果如下：
　　A.fun
　　C.fun
　　B.fun
　　D.fun
　　那么，為什么輸出順序是A->C->B->D而不是A->B->C->D呢？這就涉及到Python繼承中的MRO（Method Resolution Order）：方法解析順序。

3. super與mro機制

　　事實上，在每個類聲明之后，Python都會自動為創建一個名為“__mro__”的內置屬性，這個屬性就是Python的MRO機制生成的，該屬性是一個tuple，定義的是該類的方法解析順序（繼承順序），當用super調用父類的方法時，會按照__mro__屬性中的元素順序去挨個查找方法。我們可以通過“類名.__mro__”或“類名.mro()”來查看上面代碼中D類的__mro__屬性值：

print(D.__mro__)
print(D.mro())

　　輸出結果為：

　　(<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'>]
　　一個是tuple，一個list，但本質上是一個東西。這個順序是怎么生成的呢？在Python新式類中（Python3中也只存在新式類了），采用的是C3算法（可不是廣度優先，更不是深度優先）。我們通過如下圖所示的繼承關系來簡單介紹C3算法（箭頭指向父類）。

 

圖2

　　當要生成F的繼承順序時，C3算法過程如下：首先將入度（指向該節點的箭頭數量）為零的節點放入列表，並將F節點及與F節點有關的箭頭從上圖樹中刪除；繼續找入度為0的節點，找到D和E，左側優先，故而現將D放入列表，並從上圖樹中刪除D，這是列表中就有了F、D。繼續找入度為0的節點，有A和E滿足，左側優先，所以是A，將A從上圖中取出放入列表，列表中順序為F、D、E；接下來入度為0的節點只剩下E，取出E放入列表；只剩下B和C節點，且入度都為0，但左側優先，二先將B放入列表，然后才是后才是C；不過別忘了，Python所有類都有一個共同的父類，那就是object類，所以，最好還會把object放入列表末尾。最終生成列表中元素順序為：F->D->A->E->B->C->object。我們用代碼驗證一下：

class A(object):
    pass

class B(object):
    pass

class C(object):
    pass

class D(A,B):
    pass

class E(B, C):
    pass

class F(D, E):
    pass

print(F.__mro__)

　　輸出結果為：

　　(<class '__main__.F'>, <class '__main__.D'>, <class '__main__.A'>, <class '__main__.E'>, <class '__main__.B'>, <class '__main__.C'>, <class 'object'>)
　　所以，圖1中的繼承順序為什么是D->B->C->A就好解釋了。但還沒弄清楚圖1用super實現的代碼輸出順序的問題，所以，我們還要繼續看super的用法。

4. 怎么用super

　　super是一個類（不是方法），實例化之后得到的是一個代理的對象，而不是得到了父類，並且我們使用這個代理對象來調用父類或者兄弟類的方法。使用格式如下：

super([type[, object-or-type]])

　　將這個格式展開來就有一下幾種傳參方式：

super()
super(type , obj)
super(type_1 , type_2)

　　注意，可沒有super(type)這種方式。下面說說上面三種傳參方式。

4.1 super(type , obj)

　　先說super(type , obj)，這個方式要傳入兩個常數，第一個參數type必須是一個類名，第二個參數是一個該類的實例化對象，不過可以不是直接的實例化對象，該類的子類的實例化對象也行。在上文中已經說到，super會按照__mro__屬性中的順序去查找方法，super(type , obj)兩個參數中type作用是定義在__mro__數組中的那個位置開始找，obj定義的是用哪個類的__mro__元素。我們用代碼來說明，將圖2的代碼各個類中添加一個fun方法，繼承關系不變，代碼如下：

class A(object):
    def fun(self):
        print('A.fun')

class B(object):
    def fun(self):
        print('B.fun')

class C(object):
    def fun(self):
        print('C.fun')

class D(A,B):
    def fun(self):
        print('D.fun')

class E(B, C):
    def fun(self):
        print('E.fun')

class F(D, E):
    def fun(self):
        print('F.fun')

　　然后嘗試super(type , obj)兩個參數的不同組合，看看輸出結果。

　　先讓obj都為F類的實例，嘗試不同type下的輸出結果：

super(E , F()).fun() # 輸出結果：B.fun
super(D , F()).fun() # 輸出結果：A.fun
super(F , F()).fun() # 輸出結果：D.fun

　　再回顧一下__mro__的順序：F->D->A->E->B->C->object，發現規律沒？調用的都是type對應的類在__mro__順序中的下一個類的fun方法。所以，我們可以通過type參數來指定調用父類的范圍。

　　再讓type保持不變，obj嘗試不同的實例：

super(B , F()).fun() # 輸出結果：C.fun
super(B , E()).fun() # 輸出結果：C.fun
super(B , B()).fun() # 這是錯誤的，會報錯

　　發現規律了嗎？上面這個類繼承關系太簡單，可能規律並不明顯。事實上，obj參數指定的是用那個類的__mro__屬性。

　　好了，我們現在回到圖2中使用super()之后的代碼，來解釋一下為什么輸出順序是A->C->B->D。首先我們要明白，D類的__mro__順序是D->B->C->A，在D類中調用fun方法，然后在D類fun方法中遇到super(D , self).fun()，這個self指的是D類的實例化對象，所以用的是D類的__mro__順序，而且指明位置是D后面也就是B類，所以繼續調用B類的fun方法，遇到super(B , self).fun()，這時候需要注意，這里的self還是原來的D類實例（千萬注意不是B類實例），所以還是用D類的__mro__順序，那就繼續調用下一個C類的fun方法，同理繼續調用下一個父類，也就是A類的fun方法，執行完A類的fun方法后，回到C的fun方法中，打印輸出，然后回到B類的fun方法，知道D類的fun方法打印輸出完。懂了嗎？

4.2 super()

　　super()事實上是懶人版的super(type , obj)，這種方式只能用在類體內部，Python會自動把兩個參數填充上，type指代當前類，obj指導當前類的實例對象，相當於super(__class__ , self)。所以，以下三種代碼是完全等效的：
　　代碼一：

class B(A):
    def fun(self):
        super().fun()
        print('B.fun')

　　代碼二：

class B(A):
    def fun(self):
        super(B , self).fun()
        print('B.fun')

　　　　代碼三：

class B(A):
    def fun(self):
        super(__class__ , self).fun()
        print('B.fun')

4.3 super(type_1 , type_2)

　　當super傳入的兩個參數都是類名是，type_2必須是type_1的子類。功能上與super(type , obj)有什么不同呢？我們繼續上一小節的代碼輸出測試：

print(super(F , F())) #輸出結果為：<super: <class 'F'>, <F object>>
print(super(F , F)) #輸出結果為：<super: <class 'F'>, <F object>>

　　輸出結果是一樣的，那你就以為super(type_1 , type_2)與super(type , obj)一樣嗎？看下面輸出：

print(super(F , F()).fun()) #輸出結果為：D.fun
print(super(F , F).fun()) # 報錯：TypeError: fun() missing 1 required positional argument: 'self'

　　所以，super(type_1 , type_2)與super(type , obj)有區別，在看一下下列輸出：

print(super(F , F()).fun)# 輸出結果：<bound method D.fun of <__main__.F object at 0x000001BD44A98B38>>
print(super(F , F).fun) # 輸出結果：<function D.fun at 0x000001BD44A9EE18>
print(D.fun) # 輸出結果：<function D.fun at 0x000001BD44A9EE18>

　　所以，當super傳入的兩個傳輸都是類時，得到的就是一個指向繼承順序下的類的代理，並未綁定實例，要調用D類的fun方法，還需傳入實例：

print(super(F , F).fun(F())) #輸出結果：D.fun

　　所以，當super傳入的兩個參數都是類的時候，最好只用來調用類的靜態方法或者類方法。靜態方法、類方法、實例方法在我的上一篇博文中已詳細講述了。

5. 總結

　　最好，在實際寫代碼時，最好不要用諸如super(self.__class__, self) 的寫法，容易導致異常，super 的第一個參數盡量為當前的類。至此，super的總結就結束了。