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()
　　
　　複製程式碼
　　
　　輸出結果為：
　　
　　A.fun
　　
　　B.fun
　　
　　A.fun
　　
　　C.fun
　　
　　D.fun
　　
　　可見，A類被例項化了兩次。這就是多繼承帶來的重複呼叫（菱形繼承）的問題。使用super可以很好的解決這一問題：
　　
　　A.fun
　　
　　C.fun
　　
　　B.fun
　　
　　D.fun
　　
　　那麼，為什麼輸出是A->C->B->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 www.gcyl158.com'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__屬性。
　　
　　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__ www.feifanyule.cn/, 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的總結就結束了。