pythonsuper多重继承_Python多重继承引发的问题——牛逼的super
少說廢話多做事先上一個圖，此圖用win7下的畫圖工具所畫，當然，這不是重點
需要清楚的一個事情是：
任何類，都默認并隱式的繼承object類（根類），在上面的圖中，Transformers類同時繼承了Car和Ship類。那么Car和Ship又隱式的繼承了object類，注意，這個object類不是我自己定義的
而是python的。
根據上面的圖，編寫代碼
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
class?Car:
#描述汽車
call_car_record=?0?#記錄調用次數
def?__init__(self,?car_name):
self.car_name=?car_name
def?land_run(self):
print("{0}?Run?on?land".format(self.car_name))
self.call_car_record+=?1
class?Ship:
#描述輪船
call_ship_record=?0?#記錄調用次數
def?__init__(self,?ship_name):
self.ship_name=?ship_name
def?running_in_sea(self):
print("{0}?Running?in?the?sea".format(self.ship_name))
self.call_ship_record+=?1
class?Transformers(Car,?Ship):
#變形金剛
call_tran_record=?0?#記錄調用次數
def?__init__(self,?car_name,?ship_name,?tran_name):
Car.__init__(self,?car_name)
Ship.__init__(self,?ship_name)
self.tran_name=?tran_name
def?transfiguration(self):
print("{0}?start?Transfiguration...".format(self.tran_name))
self.call_tran_record+=?1
if?__name__==?'__main__':
t=?Transformers("byd","gz01","toby")
t.land_run()
t.running_in_sea()
t.transfiguration()
print(t.call_tran_record,?t.call_car_record,?t.call_ship_record)
"""
輸出的結果:
byd?Run?on?land
gz01?Running?in?the?sea
toby?start?Transfiguration...
1?1?1
"""
那么，上面的代碼，面臨的問題正是我在上圖中的描述，也就是說object類被隱式的調用了兩次，只是目前沒有察覺到，但是確實存在。
OK！！！我想證明這個問題，證實它是不是被調用兩次。我再上一個圖，如下：
上面的圖，就是傳說中的磚石繼承，啥是磚石繼承？只是這個類的繼承視圖看起來和磚石一樣，當然這只是我的理解。
如果用這個圖來證明BaseClass會不會被調用2次，那么需要轉化成代碼。代碼如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
class?BaseClass:
num_base_calls=?0?#記錄基類被調用次數
def?work(self):
print("work?method?of?calling?base?class")
self.num_base_calls+=?1
class?AClass(BaseClass):
num_aclass_calls=?0?#記錄被調用次數
def?work(self):
BaseClass.work(self)
print("work?method?of?calling?AClass?class")
self.num_aclass_calls+=?1
class?BClass(BaseClass):
num_bclass_calls=?0?#記錄被調用次數
def?work(self):
BaseClass.work(self)
print("work?method?of?calling?BClass?class")
self.num_bclass_calls+=?1
class?CClass(AClass,?BClass):
num_cclass_calls=?0?#記錄被調用次數
def?work(self):
AClass.work(self)
BClass.work(self)
print("Calling?work?method?on?CClass")
self.num_cclass_calls+=?1
if?__name__==?'__main__':
c=?CClass()
c.work()
print(c.num_cclass_calls,?c.num_aclass_calls,?c.num_bclass_calls,?c.num_base_calls)
"""
結果輸出：
work?method?of?calling?base?class
work?method?of?calling?AClass?class
work?method?of?calling?base?class
work?method?of?calling?BClass?class
Calling?work?method?on?CClass
1?1?1?2
"""
從輸出的結果來看，BaseClass真的被調用了兩次，這個基類是我自己定義的，這不是隱式調用，是明目張膽的在調用啊！！！
如何解決這個問題？專業人士說用super，我不信，所以我嘗試了一下，改進后的代碼如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
class?BaseClass:
num_base_calls=?0?#記錄基類被調用次數
def?work(self):
print("work?method?of?calling?base?class")
self.num_base_calls+=?1
class?AClass(BaseClass):
num_aclass_calls=?0?#記錄被調用次數
def?work(self):
super().work()
print("work?method?of?calling?AClass?class")
self.num_aclass_calls+=?1
class?BClass(BaseClass):
num_bclass_calls=?0?#記錄被調用次數
def?work(self):
super().work()
print("work?method?of?calling?BClass?class")
self.num_bclass_calls+=?1
class?CClass(AClass,?BClass):
num_cclass_calls=?0?#記錄被調用次數
def?work(self):
super().work()
print("Calling?work?method?on?CClass")
self.num_cclass_calls+=?1
if?__name__==?'__main__':
c=?CClass()
c.work()
print(c.num_cclass_calls,?c.num_aclass_calls,?c.num_bclass_calls,?c.num_base_calls)
"""
輸出結果：
work?method?of?calling?base?class
work?method?of?calling?BClass?class
work?method?of?calling?AClass?class
Calling?work?method?on?CClass
1?1?1?1
"""
事實證明，BaseClass這個基類真的只被調用了一次，這就是super的威力。然而，不管你信不信，反正我是信了。
那分析一下他的調用順序，我又畫了個圖：
看圖分析：1、CClass類的work()方法調用了super.work，其實是引用了AClass.work()2、在AClass.work()中，調用了super.work()，這時候是引用了BClass.work()，而不是BaseClass.work()，這就是所謂的下一個方法3、接著在BClass.work()中調用了super.work()方法，這時候才是去調用BaseClass.work()方法
現在回到第一個多重繼承的例子，在多重繼承的例子中，Transformers類的__init__方法中，為了實現能調用兩個父類的__init__()方法
我最初的做法是，分別寫了兩次調用。這里面臨的問題是，有兩個父類的初始化方法要調用，而且還是需要不同的參數。
那么，我一開始就寫成如下面代碼這樣，不是不行，而是不是我追求的目標，我是一個追求完美的人，所以我決定改進它，也是用super去做
1
2
3
4
5
6
7
class?Transformers(Car,?Ship):
#變形金剛
call_tran_record=?0
def?__init__(self,?car_name,?ship_name,?tran_name):
Car.__init__(self,?car_name)#調用Car類的初始化方法
Ship.__init__(self,?ship_name)#調用Ship類的初始化方法
self.tran_name=?tran_name
改進后的代碼如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
class?Car:
#描述汽車
call_car_record=?0?#記錄調用次數
def?__init__(self,?car_name=None,**kwargs):
super().__init__(**kwargs)
self.car_name=?car_name
def?land_run(self):
print("{0}?Run?on?land".format(self.car_name))
self.call_car_record+=?1
class?Ship:
#描述輪船
call_ship_record=?0?#記錄調用次數
def?__init__(self,?ship_name=None,**kwargs):
super().__init__(**kwargs)
self.ship_name=?ship_name
def?running_in_sea(self):
print("{0}?Running?in?the?sea".format(self.ship_name))
self.call_ship_record+=?1
class?Transformers(Car,?Ship):
#變形金剛
call_tran_record=?0?#記錄調用次數
def?__init__(self,?tran_name=None,**kwargs):
super().__init__(**kwargs)
self.tran_name=?tran_name
def?transfiguration(self):
print("{0}?start?Transfiguration...".format(self.tran_name))
self.call_tran_record+=?1
if?__name__==?'__main__':
t=?Transformers(tran_name="toby",?car_name="byd",?ship_name="qq")
t.land_run()
t.running_in_sea()
t.transfiguration()
print(t.call_tran_record,?t.call_car_record,?t.call_ship_record)
關于如何分析它的執行順序？請用“下一個方法”的思路去理解它。
最后，再總結一下super的牛逼之處
1、在類的繼承層次結構中，只想調用"下一個方法"，而不是父類的方法
2、super的目標就是解決復雜的多重繼承問題（基類被調用兩次的問題）
3、super是絕對的保證，在類的繼承層次結構中每一個方法只被執行一次
本文轉自 TtrToby 51CTO博客，原文鏈接:http://blog.51cto.com/freshair/2063290
總結
以上是生活随笔為你收集整理的pythonsuper多重继承_Python多重继承引发的问题——牛逼的super的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： python怎么写中文至excel_[
- 下一篇： 花椒的功效与作用