前言
Python是一門面向對象的語言，定義類時經常要用到繼承，在類的繼承中，子類繼承父類中已經封裝好的方法，不需要再次編寫，如果子類如果重新定義了父類的某一方法，那么該方法就會覆蓋父類的同名方法，但是有時我們希望子類保持父類方法的基礎上進行擴展，而不是直接覆蓋，就需要先調用父類的方法，然后再進行功能的擴展，這時就可以通過super來實現對父類方法的調用。
super的用法
看下面一個例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
class
A:
def
func(
self
):
print
(
"A的func執行"
)
class
B(A):
def
func(
self
):
super
().func()
print
(
"B擴展的func執行"
)
b
=
B()
b.func()
# 輸出結果為：
# A的func執行
# B擴展的func執行
|
上面程序中，A是父類，B是A的子類，我們在A類中重定義了func()方法，在B類中重新定義了func()方法，在方法中通過super().func()又調用了父類的方法，所以執行結果才會有A類func()方法輸出。
如果經常看Python內置庫及第三方庫源碼的話，你會發現，super用的非常多的地方是在子類中調用父類的初始化__init__()方法，這種用法非常常見。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class
A:
def
__init__(
self
, x):
self
.x
=
x
class
B(A):
def
__init__(
self
, x, y):
super
().__init__(x)
self
.y
=
y
b
=
B(
1
,
2
)
print
(b.x, b.y)
|
看到這，你會想到super就是用來獲取父類並用來調用父類方法的，這樣說對不對呢，其實是不對的，使用supper獲取的不是父類，而是MRO列表中的下一個類，所謂MRO列表即方法解析順序(Method Resolution Order)列表，它代表着類繼承的順序，我們可以使用以下幾種獲得某個類的MRO列表：
|
1
2
3
|
C.mro()
C.__mro__
c.__class__.__mro__
|
MRO列表的順序確定經歷了很多次的變遷，最新的是通過C3線性化算法來實現的，感興趣的話可以自行了解一下，總的來說，一個類的MRO列表就是合並所有父類的MRO列表，並遵循以下三條原則：
- 子類永遠在父類前面
- 如果有多個父類，會根據它們在列表中的順序被檢查
- 如果對下一個類存在兩個合法的選擇，選擇第一個父類
下面來看一下下面這個例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
class
A(Base):
def
func(
self
):
print
(
"A的func執行"
)
super
().func()
print
(
"A的func執行完畢"
)
class
B(Base):
def
func(
self
):
print
(
"B的func執行"
)
super
().func()
print
(
"B的func執行完畢"
)
class
C(A, B):
def
func(
self
):
print
(
"C的func執行"
)
super
().func()
print
(
"C的func執行完畢"
)
c
=
C()
c.func()
# 獲取MRO列表
print
(c.__class__.__mro__)
|
執行結果如下：
上述程序中，Base是父類，A、B都繼承自Base，C繼承自 A、B，它們的繼承關系就是一個典型的菱形繼承，如下：
通過結果我們可以看出，super（https://suowo.cn）並不是獲取父類並用來調用父類的方法，而是根據MRO列表一次調用下一個類，使用c.__class__.__mro__可以獲取MRO列表，MRO列表的順序是C、A、B、Base、object。
super的原理
super計算方法解析順序中的下一個類，可以接收兩個參數：
|
1
2
3
|
def
super
(
cls
, inst):
mro
=
inst.__class__.mro()
return
mro[mro.index(
cls
)
+
1
]
|
- 通過inst負責生成MRO列表
- 通過cls定位在MRO列表中的index, 並返回mro[index + 1]
Python super()使用注意事項
Python 中，由於基類不會在 __init__() 中被隱式地調用，需要程序員顯式調用它們。這種情況下，當程序中包含多重繼承的類層次結構時，使用 super 是非常危險的，往往會在類的初始化過程中出現問題。
混用super與顯式類調用
分析如下程序，C 類使用了 __init__() 方法調用它的基類，會造成 B 類被調用了 2 次：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
class
A:
def
__init__(
self
):
print
(
"A"
,end
=
" "
)
super
().__init__()
class
B:
def
__init__(
self
):
print
(
"B"
,end
=
" "
)
super
().__init__()
class
C(A,B):
def
__init__(
self
):
print
(
"C"
,end
=
" "
)
A.__init__(
self
)
B.__init__(
self
)
print
(
"MRO:"
,[x.__name__
for
x
in
C.__mro__])
C()
|
運行結果為：
MRO: ['C', 'A', 'B', 'object']
C A B B
出現以上這種情況的原因在於，C 的實例調用 A.__init__(self)，使得 super(A,self).__init__() 調用了 B.__init__() 方法。換句話說，super 應該被用到整個類的層次結構中。
但是，有時這種層次結構的一部分位於第三方代碼中，我們無法確定外部包的這些代碼中是否使用 super()，因此，當需要對某個第三方類進行子類化時，最好查看其內部代碼以及 MRO 中其他類的內部代碼。
不同種類的參數
使用 super 的另一個問題是初始化過程中的參數傳遞。如果沒有相同的簽名，一個類怎么能調用其基類的 __init__() 代碼呢？這會導致下列問題：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
class
commonBase:
def
__init__(
self
):
print
(
"commonBase"
)
super
().__init__()
class
base1(commonBase):
def
__init__(
self
):
print
(
"base1"
)
super
().__init__()
class
base2(commonBase):
def
__init__(
self
):
print
(
"base2"
)
super
().__init__()
class
myClass(base1,base2):
def
__init__(
self
,arg):
print
(
"my base"
)
super
().__init__(arg)
myClass(
10
)
|
運行結果為：
my base
Traceback (most recent call last):
File "C:\Users\mengma\Desktop\demo.py", line 20, in <module>
myClass(10)
File "C:\Users\mengma\Desktop\demo.py", line 19, in __init__
super().__init__(arg)
TypeError: __init__() takes 1 positional argument but 2 were given
一種解決方法是使用 *args 和 **kwargs 包裝的參數和關鍵字參數，這樣即使不使用它們，所有的構造函數也會傳遞所有參數，如下所示：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
class
commonBase:
def
__init__(
self
,
*
args,
*
*
kwargs):
print
(
"commonBase"
)
super
().__init__()
class
base1(commonBase):
def
__init__(
self
,
*
args,
*
*
kwargs):
print
(
"base1"
)
super
().__init__(
*
args,
*
*
kwargs)
class
base2(commonBase):
def
__init__(
self
,
*
args,
*
*
kwargs):
print
(
"base2"
)
super
().__init__(
*
args,
*
*
kwargs)
class
myClass(base1,base2):
def
__init__(
self
,arg):
print
(
"my base"
)
super
().__init__(arg)
myClass(
10
)
|
運行結果為：
my base
base1
base2
commonBase
不過，這是一種很糟糕的解決方法，由於任何參數都可以傳入，所有構造函數都可以接受任何類型的參數，這會導致代碼變得脆弱。另一種解決方法是在 MyClass 中顯式地使用特定類的 __init__() 調用，但這無疑會導致第一種錯誤。