Python super(钻石继承)

1.   Python的继承以及调用父类成员

python子类调用父类成员有2种方法,分别是普通方法和super方法

假设Base是基类

1class Base(object): 2   def __init__(self): 3     print “Base init” 4

则普通方法如下

1class Leaf(Base): 2 def __init__(self): 3 Base.__init__(self) 4 print “Leaf init” 5

super方法如下

1class Leaf(Base): 2 def __init__(self): 3 super(Leaf, self).__init__() 4 print “Leaf init” 5

在上面的简单场景下,两种方法的效果一致:

leaf = Leaf()

Base init

Leaf init

2.   钻石继承遇到的难题

当我们来到钻石继承场景时,我们就遇到了一个难题:

如果我们还是使用普通方法调用父类成员,代码如下:

1class Base(object): 2 def __init__(self): 3 print “Base init” 4 5class Medium1(Base): 6 def __init__(self): 7 Base.__init__(self) 8 print “Medium1 init” 9 10class Medium2(Base): 11 def __init__(self): 12 Base.__init__(self) 13 print “Medium2 init” 14 15class Leaf(Medium1, Medium2): 16 def __init__(self): 17 Medium1.__init__(self) 18 Medium2.__init__(self) 19 print “Leaf init” 20

当我们生成Leaf对象时,结果如下:

leaf = Leaf()

Base init

Medium1 init

Base init

Medium2 init

Leaf init

 

可以看到Base被初始化了 两次!这是由于Medium1和Medium2各自调用了Base的初始化函数导致的。

3.   各语言的解决方法

钻石继承中,父类被多次初始化是个非常难缠的问题,我们来看看其他各个语言是如何解决这个问题的:

3.1. C++

C++使用虚拟继承来解决钻石继承问题。

Medium1和Medium2虚拟继承Base。当生成Leaf对象时,Medium1和Medium2并不会自动调用虚拟基类Base的构造函数,而需要由Leaf的构造函数显式调用Base的构造函数。

3.2. Java

Java禁止使用多继承。

Java使用单继承+接口实现的方式来替代多继承,避免了钻石继承产生的各种问题。

3.3. Ruby

Ruby禁止使用多继承。

Ruby和Java一样只支持单继承,但它对多继承的替代方式和Java不同。Ruby使用Mixin的方式来替代,在当前类中mixin入其他模块,来做到代码的组装效果。

3.4. Python

Python和C++一样,支持多继承的语法。但Python的解决思路和C++完全不一样,Python使用的是super

我们把第2章的钻石继承用super重写一下,看一下输出结果

1class Base(object): 2 def __init__(self): 3 print “Base init” 4 5class Medium1(Base): 6 def __init__(self): 7 super(Medium1, self).__init__() 8 print “Medium1 init” 9 10class Medium2(Base): 11 def __init__(self): 12 super(Medium2, self).__init__() 13 print “Medium2 init” 14 15class Leaf(Medium1, Medium2): 16 def __init__(self): 17 super(Leaf, self).__init__() 18 print “Leaf init” 19

我们生成Leaf对象:

leaf = Leaf()

Base init

Medium2 init

Medium1 init

Leaf init

可以看到整个初始化过程符合我们的预期,Base只被初始化了1次。而且重要的是,相比原来的普通写法,super方法并没有写额外的代码,也没有引入额外的概念

4.   super的内核:mro

要理解super的原理,就要先了解mro。mro是method resolution order的缩写,表示了类继承体系中的成员解析顺序。

 

在python中,每个类都有一个mro的类方法。我们来看一下钻石继承中,Leaf类的mro是什么样子的:

Leaf.mro()

[<class 'main.Leaf'>, <class 'main.Medium1'>, <class 'main.Medium2'>, <class 'main.Base'>, <type 'object'>]

 

可以看到mro方法返回的是一个祖先类的列表。Leaf的每个祖先都在其中出现一次,这也是super在父类中查找成员的顺序。 

通过mro,python巧妙地将多继承的图结构,转变为list的顺序结构。super在继承体系中向上的查找过程,变成了在mro中向右的线性查找过程,任何类都只会被处理一次。

 

通过这个方法,python解决了多继承中的2大难题:

  1. 查找顺序问题。从Leaf的mro顺序可以看出,如果Leaf类通过super来访问父类成员,那么Medium1的成员会在Medium2之前被首先访问到。如果Medium1和Medium2都没有找到,最后再到Base中查找。

  2. 钻石继承的多次初始化问题。在mro的list中,Base类只出现了一次。事实上任何类都只会在mro list中出现一次。这就确保了super向上调用的过程中,任何祖先类的方法都只会被执行一次。

 

至于mro的生成算法,可以参考这篇wiki:https://en.wikipedia.org/wiki/C3_linearization

5.   super的具体用法

我们首先来看一下python中的super文档

help(super)

Help on class super in module builtin:

class super(object)

 |  super(type, obj) -> bound super object; requires isinstance(obj, type)

 |  super(type) -> unbound super object

 |  super(type, type2) -> bound super object; requires issubclass(type2, type)

 

光从字面来看,这可以算是python中最语焉不详的帮助文档之一了。甚至里面还有一些术语误用。那super究竟应该怎么用呢,我们重点来看super中的第1和第3种用法

5.1. super(type, obj)

当我们在Leaf的__init__中写这样的super时:

1class Leaf(Medium1, Medium2): 2 def __init__(self): 3 super(Leaf, self).__init__() 4 print “Leaf init” 5

super(Leaf, self).init()的意思是说:

  1. 获取self所属类的mro, 也就是[Leaf, Medium1, Medium2, Base]
  2. 从mro中Leaf右边的一个类开始,依次寻找__init__函数。这里是从Medium1开始寻找
  3. 一旦找到,就把找到的__init__函数绑定到self对象,并返回

 

从这个执行流程可以看到,如果我们不想调用Medium1的__init__,而想要调用Medium2的__init__,那么super应该写成:super(Medium1, self)init() 

5.2. super(type, type2)

当我们在Leaf中写类方法的super时:

1class Leaf(Medium1, Medium2): 2 def __new__(cls): 3 obj = super(Leaf, cls).__new__(cls) 4 print “Leaf new” 5 return obj 6

super(Leaf, cls).new(cls)的意思是说:

  1. 获取cls这个类的mro,这里也是[Leaf, Medium1, Medium2, Base]
  2. 从mro中Leaf右边的一个类开始,依次寻找__new__函数
  3. 一旦找到,就返回“

非绑定”的__new__函数

 

由于返回的是非绑定的函数对象,因此调用时不能省略函数的第一个参数。这也是这里调用__new__时,需要传入参数cls的原因

同样的,如果我们想从某个mro的某个位置开始查找,只需要修改super的第一个参数就行

6.   小结

至此,我们讲解了和super相关的用法及原理,小结一下我们讲过的内容有:

  1. python调用父类成员共有2种方法:普通方法,super方法
  2. 在钻石继承中,普通方法会遇到Base类两次初始化的问题
  3. 简述了其他语言对这个问题的解决方法,并用实例展示了python使用super可以解决此问题
  4. 在讲super具体用法前,先讲了super的内核:mro的知识和原理
  5. 讲解了super两种主要的用法及原理

 原文链接:http://www.cnblogs.com/testview/p/4651198.html?utm_source=tuicool&utm_medium=referral

代码交流 2021