少说废话多做事先上一个图,此图用win7下的画图工具所画,当然,这不是重点
需要清楚的一个事情是:
任何类,都默认并隐式的继承object类(根类),在上面的图中,Transformers类同时继承了Car和Ship类。那么Car和Ship又隐式的继承了object类,注意,这个object类不是我自己定义的
而是python的。
根据上面的图,编写代码
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次,那么需要转化成代码。代码如下:
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,我不信,所以我尝试了一下,改进后的代码如下:
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去做
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
改进后的代码如下:
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是绝对的保证,在类的继承层次结构中每一个方法只被执行一次
原文地址:http://blog.51cto.com/freshair/2063290