開始之前，先出一道題：

1 #super函數探討 2 class A(object): 3 def __init__(self): 4 print 'A.__init__' 5 6 class B(A): 7 def __init__(self): 8 super(B, self).__init__() 9 print 'B.__init__' 10 11 class C(A): 12 def __init__(self): 13 super(C, self).__init__() 14 print 'C.__init__' 15 16 class D(B, C): 17 def __init__(self): 18 super(D, self).__init__() 19 print 'D.__init__' 20 21 d = D() View Code

上面的運行結果是什么？

是下面的結果嗎？

A.__init__ B.__init__ D.__init__

正確答案：

A.__init__ C.__init__ B.__init__ D.__init__

有沒有疑惑？super()函數不是調用指定類的父類的方法嗎！打印了A.__init__下一句為什么是C.__init__呢？

根本原因是：

super?和父類沒有實質性的關聯

首先，我們知道新式類采用廣度優先算法，我們來看一下上面的繼承關系：

那么，Python是如何實現繼承的，繼承順序又是由誰決定的呢？ 對于你定義的每一個類而已，Python會計算出一個所謂的方法解析順序(MRO Method?Resolution Order)列表。類的繼承順序就是由這個MRO決定的。

MRO通過class.__mro__來查看，我們來打印一下上面例子中的MRO：

print D.__mro__ (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <type 'object'>)

注意__mro__是類的屬性，實例沒有該屬性

這個MRO列表就是一個簡單的所有基類的線性順序表。為了實現繼承，Python會在MRO列表上從左到右開始查找基類，直到找到第一個匹配這個屬性的類為止。

而這個MRO列表的構造是通過一個C3線性化算法來實現的。 它實際上就是合并所有父類的MRO列表并遵循如下三條準則：

1）子類會先于父類被檢查

2）多個父類會根據它們在列表中的順序被檢查

3）如果對下一個類存在兩個合法的選擇，選擇第一個父類

好像還是沒明白為什么例子中，打印了A.__init__下一句為什么是C.__init__呢？

我們使用一個函數來解釋一下super的原理：

def super(cls, inst):mro = inst.__class__.mro()return mro[mro.index(cls) + 1]

其中，cls 代表類，inst 代表實例，上面的代碼做了兩件事：

1）獲取 inst 的 MRO 列表

2）查找 cls 在當前 MRO 列表中的 index, 并返回它的下一個類，即 mro[index + 1]

當你使用?super(cls, inst)?時，Python 會在 inst 的 MRO 列表上搜索 cls 的下一個類。

是不是有一種豁然開朗的趕腳！讓我們回到例子中，這里我畫出了整個流程；

從上面的流程圖就可以看出打印的順序是對的！

了解了super的原理，那么也就可以理解下面這段有趣的代碼了：

1）執行下面代碼

1 class A(object): 2 def go(self): 3 print 'A go' 4 super(A, self).go() 5 6 a = A() 7 a.go() View Code

會報錯：

AttributeError: 'super' object has no attribute 'go'

2）執行下面代碼：

1 class A(object): 2 def go(self): 3 print 'A go' 4 super(A, self).go() 5 6 class B(object): 7 def go(self): 8 print 'B go' 9 10 class C(A, B): 11 pass 12 13 c = C() 14 c.go() View Code

不會報錯，結果為：

A go B go

充分說明了super?和父類沒有實質性的關聯

另外，我們想出了super以外，還有一種直接調用父類方法的方法，如下：

1 #super函數探討 2 class A(object): 3 def __init__(self): 4 print 'A.__init__' 5 6 class B(A): 7 def __init__(self): 8 # super(B, self).__init__() 9 A.__init__(self) 10 print 'B.__init__' 11 12 class C(A): 13 def __init__(self): 14 # super(C, self).__init__() 15 A.__init__(self) 16 print 'C.__init__' 17 18 class D(B, C): 19 def __init__(self): 20 # super(D, self).__init__() 21 B.__init__(self) 22 C.__init__(self) 23 print 'D.__init__' 24 25 d = D() View Code

為什么不用這種方法呢？我們運行一下，看一下，結果為：

A.__init__ B.__init__ A.__init__ C.__init__ D.__init__

很明顯，A的構造函數運行了兩次，這不是我們所希望的；所以還是用super吧！

轉載于:https://www.cnblogs.com/deeper/p/7453759.html

與50位技術專家面對面20年技術見證，附贈技術全景圖

總結

以上是生活随笔為你收集整理的super函数没有那么简单-super原理剖析的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。