python 钻石继承_Python的继承以及调用父类成员：super用法

电玩女神 2022-12-31 10:27 165阅读 0赞

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

假设Base是基类

class Base(object):

def \_\_init\_\_(self):

print “Base init”

则普通方法如下

class Leaf(Base):

def \_\_init\_\_(self):

Base.\_\_init\_\_(self)

print “Leaf init”

super方法如下

class Leaf(Base):

def \_\_init\_\_(self):

super(Leaf, self).\_\_init\_\_()

print “Leaf init”

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

>>> leaf = Leaf()

Base init

Leaf init

2. 钻石继承遇到的难题

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

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

class Base(object):

def \_\_init\_\_(self):

print “Base init”

class Medium1(Base):

def \_\_init\_\_(self):

Base.\_\_init\_\_(self)

print “Medium1 init”

class Medium2(Base):

def \_\_init\_\_(self):

Base.\_\_init\_\_(self)

print “Medium2 init”

class Leaf(Medium1, Medium2):

def \_\_init\_\_(self):

Medium1.\_\_init\_\_(self)

Medium2.\_\_init\_\_(self)

print “Leaf init”

当我们生成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重写一下，看一下输出结果

class Base(object):

def \_\_init\_\_(self):

print “Base init”

class Medium1(Base):

def \_\_init\_\_(self):

super(Medium1, self).\_\_init\_\_()

print “Medium1 init”

class Medium2(Base):

def \_\_init\_\_(self):

super(Medium2, self).\_\_init\_\_()

print “Medium2 init”

class Leaf(Medium1, Medium2):

def \_\_init\_\_(self):

super(Leaf, self).\_\_init\_\_()

print “Leaf init”

我们生成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()

\[Leaf, Medium1, Medium2, Base\]

可以看到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时：

class Leaf(Medium1, Medium2):

def \_\_init\_\_(self):

super(Leaf, self).\_\_init\_\_()

print “Leaf init”

super(Leaf, self).\_\_init\_\_()的意思是说：

获取self所属类的mro, 也就是\[Leaf, Medium1, Medium2, Base\]

从mro中Leaf右边的一个类开始，依次寻找\_\_init\_\_函数。这里是从Medium1开始寻找

一旦找到，就把找到的\_\_init\_\_函数绑定到self对象，并返回

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

5.2. super(type, type2)

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

class Leaf(Medium1, Medium2):

def \_\_new\_\_(cls):

obj = super(Leaf, cls).\_\_new\_\_(cls)

print “Leaf new”

return obj

super(Leaf, cls).\_\_new\_\_(cls)的意思是说：

获取cls这个类的mro，这里也是\[Leaf, Medium1, Medium2, Base\]

从mro中Leaf右边的一个类开始，依次寻找\_\_new\_\_函数

一旦找到，就返回“ 非绑定 ”的\_\_new\_\_函数

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

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

6. 小结

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

python调用父类成员共有2种方法：普通方法，super方法

在钻石继承中，普通方法会遇到Base类两次初始化的问题

简述了其他语言对这个问题的解决方法，并用实例展示了python使用super可以解决此问题

在讲super具体用法前，先讲了super的内核：mro的知识和原理

讲解了super两种主要的用法及原理

python 钻石继承_Python的继承以及调用父类成员：super用法

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Python类继承问题：理解super()的用法

相关【C++】继承 ② ( 继承语法 | 三种继承 - 共有继承 / 保护继承 / 私有继承 | 继承与父类私有成员 | 子类访问父类私有成员 | 代码示例 )

相关 python 类多次继承_Python类的继承关系及super的用法

相关 python 钻石继承_Python的继承以及调用父类成员：super用法

相关 Python 继承，子类调用父类成员与方法

相关 python 中的多继承和super()不仅是找父类

相关 python面向对象3（钻石继承的问题，多继承的super用法）

相关继承的super的用法

相关 Java super关键字：super调用父类的构造方法、利用super访问父类成员

相关 python的多继承如何调用父类同名的方法！