Python面向对象中super用法与MRO机制
1. 引言
最近在研究django rest_framework的源碼，老是遇到super，搞得一團蒙，多番查看各路大神博客，總算明白了一點，今天做一點總結。
2. 為什么要用super
1）讓代碼維護更加簡單
Python是一門面向對象的語言，定義類時經常用到繼承的概念，既然用到繼承就少不得要在子類中引用父類的屬性，我們可以通過“父類名.屬性名”的方式來調用，代碼如下：
''' 遇到問題沒人解答？小編創建了一個Python學習交流QQ群：857662006 尋找有志同道合的小伙伴，互幫互助,群里還有不錯的視頻學習教程和PDF電子書！ ''' 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就好多了：
''' 遇到問題沒人解答？小編創建了一個Python學習交流QQ群：857662006 尋找有志同道合的小伙伴，互幫互助,群里還有不錯的視頻學習教程和PDF電子書！ ''' 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
用“父類名.屬性名” 的方式調用，代碼如下：
''' 遇到問題沒人解答？小編創建了一個Python學習交流QQ群：857662006 尋找有志同道合的小伙伴，互幫互助,群里還有不錯的視頻學習教程和PDF電子書！ ''' 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.funB.funA.funC.funD.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.funC.funB.funD.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。我們用代碼驗證一下：
''' 遇到問題沒人解答？小編創建了一個Python學習交流QQ群：857662006 尋找有志同道合的小伙伴，互幫互助,群里還有不錯的視頻學習教程和PDF電子書！ ''' class A(object):passclass B(object):passclass C(object):passclass D(A,B):passclass E(B, C):passclass F(D, E):passprint(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方法，繼承關系不變，代碼如下：
''' 遇到問題沒人解答？小編創建了一個Python學習交流QQ群：857662006 尋找有志同道合的小伙伴，互幫互助,群里還有不錯的視頻學習教程和PDF電子書！ ''' 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(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的總結就結束了。
總結
以上是生活随笔為你收集整理的Python面向对象中super用法与MRO机制的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Python面向对象：反射(hasatt
- 下一篇： 网络爬虫中Fiddler抓取PC端网页数