# 7.5 【基础】类的继承(Inheritance)
类的继承,跟人类繁衍的关系相似。
被继承的类称为基类(也叫做父类),继承而得的类叫派生类(也叫子类),这种关系就像人类的父子关系。
继承最大的好处是子类获得了父类的全部变量和方法的同时,又可以根据需要进行修改、拓展。
继承的语法结构是
```python
class 子类(父类):
```
## 1. 单继承
举个例子:下面的代码中。先是定义了一个 People 类,里面有一个 speak 方法。然后再定义一个 Student 类,并继承自 People 类。
```python
# 父类定义
class People:
def __init__(self, name, age, weight):
self.name = name
self.age = age
def speak(self):
print(f"{self.name} 说: 我{self.age}岁。")
# 单继承示例
class Student(People):
def __init__(self, name, age, weight, grade):
# 调用父类的实例化方法
People.__init__(self, name, age, weight)
self.grade = grade
```
由于继承的机制,Student 实例会拥有 People 类所有属性和方法,比如下边我可以直接调用 People 类的 speak 方法。
```python
>>> xm = Student(name="小明", age=10, weight=50, grade="三年级")
>>> xm.speak()
小明 说: 我 10 岁。
```
你如果不想使用父类的方法,你可以重写它以覆盖父类的 `speak` 方法。
```python
# 单继承示例
class Student(People):
def __init__(self, name, age, weight, grade):
# 调用父类的实例化方法
People.__init__(self, name, age, weight)
self.grade = grade
# 重写父类的speak方法
def speak(self):
print(f"{self.name} 说: 我{self.age}岁了,我在读{self.grade}")
```
此时,再调用的话,就会调用自己的方法了
```python
>>> xm = Student(name="小明", age=10, weight=50, grade="三年级")
>>> xm.speak()
小明 说: 我10岁了,我在读三年级
```
## 2. 多继承
Python 还支持多继承,可以继承自多个类。
```python
class 子类(父类1, 父类2, 父类3...):
```
多继承的话,情况会比单继承复杂得多。
假设多个父类都有一个 foo 方法,并且子类没有重写 foo 方法,那么 子类 的实例在调用 foo 方法时,应该使用哪个父类的 foo 方法呢?
关于这一点,只要简单的做个验证就行啦。
有如下代码,定义了 7 个类
```python
class D:pass
class C(D):pass
class B(C):
def show(self):
print("i am B")
class G:pass
class F(G):pass
class E(F):
def show(self):
print("i am E")
class A(B, E):pass
```
它们的继承关系是
![](http://image.iswbm.com/image-20201213150058921.png)
运行后的结果如下
```python
>>> a = A()
>>> a.show()
i am B
```
在类A中,没有show()这个方法,于是它只能去它的父类里查找,它首先在B类中找,结果找到了,于是直接执行B类的show()方法。可见,在A的定义中,继承参数的书写有先后顺序,写在前面的被优先继承。
## 3. 继承顺序
那如果B没有show方法,而是D有呢?
```python
class D:
def show(self):
print("i am D")
class C(D):pass
class B(C):pass
class G:pass
class F(G):pass
class E(F):
def show(self):
print("i am E")
class A(B, E):pass
```
执行结果是
```python
>>> a = A()
>>> a.show()
i am D
```
由此可见,多继承的顺序使用的是从左向右再深度优先的原则。
![](http://image.iswbm.com/image-20201213151434342.png)
## 4. MRO 算法
上面的继承案例是只是非常简单的一种场景,在实际应用中,会远比这个来得复杂。
此时如果你单纯的将其理解成
- 从左向右
- 深度优先
就会发现很场景下想要理清的方法解析顺序(MRO)是非常难的。
在这种情况下,你还可以有两种方法:
1. 使用 `__mro__` 来查询
2. 使用 merge算法进行推导
### 使用 mro 查询
比如在下面这个菱形继承中
```python
class A(object):pass
class B(A):pass
class C(A):pass
class D(B, C):pass
```
![](http://image.iswbm.com/20201004123106.png)
可以使用 `__mro__`
```python
>>> print(D.__mro__)
```
或者借助 inspect 模块
```python
>>> import inspect
>>> print inspect.getmro(D)
```
得到的结果都将是
```python
(<class '__main__.D'>,
<class '__main__.B'>,
<class '__main__.C'>,
<class '__main__.A'>,
<class 'object'>)
```
### 使用 merge 推导
![](http://image.iswbm.com/20201004123115.png)
1. 检查第一个列表的头元素(如 L[B1] 的头),记作 H。
2. 若 H 未出现在其它列表的尾部,则将其输出,并将其从所有列表中删除,然后回到步骤1;否则,取出下一个列表的头部记作 H,继续该步骤。
3. 重复上述步骤,直至列表为空或者不能再找出可以输出的元素。如果是前一种情况,则算法结束;如果是后一种情况,说明无法构建继承关系,Python 会抛出异常。
你可以在草稿纸上,参照上面的merge算法,写出如下过程
```
L[object] = [object]
L[D] = [D, object]
L[E] = [E, object]
L[F] = [F, object]
L[B] = [B, D, E, object]
L[C] = [C, D, F, object]
L[A] = [A] + merge(L[B], L[C], [B], [C])
= [A] + merge([B, D, E, object], [C, D, F, object], [B], [C])
= [A, B] + merge([D, E, object], [C, D, F, object], [C])
= [A, B, C] + merge([D, E, object], [D, F, object])
= [A, B, C, D] + merge([E, object], [F, object])
= [A, B, C, D, E] + merge([object], [F, object])
= [A, B, C, D, E, F] + merge([object], [object])
= [A, B, C, D, E, F, object]
```
## 附录:参考文章
---
- https://www.python.org/download/releases/2.3/mro/
- https://www.cnblogs.com/whatisfantasy/p/6046991.html
- 第一章:安装运行
- 1.1 【环境】快速安装 Python 解释器
- 1.2 【环境】Python 开发环境的搭建
- 1.3 【基础】两种运行 Python 程序方法
- 第二章:数据类型
- 2.1 【基础】常量与变量
- 2.2 【基础】字符串类型
- 2.3 【基础】整数与浮点数
- 2.4 【基础】布尔值:真与假
- 2.5 【基础】学会输入与输出
- 2.6 【基础】字符串格式化
- 2.6 【基础】运算符(超全整理)
- 第三章:数据结构
- 3.1 【基础】列表
- 3.2 【基础】元组
- 3.3 【基础】字典
- 3.4 【基础】集合
- 3.5 【基础】迭代器
- 3.6 【基础】生成器
- 第四章:控制流程
- 4.1 【基础】条件语句:if
- 4.2 【基础】循环语句:for
- 4.3 【基础】循环语句:while
- 4.4 【进阶】五种推导式
- 第五章:学习函数
- 5.1 【基础】普通函数
- 5.2 【基础】匿名函数
- 5.3 【基础】高阶函数
- 5.4 【基础】反射函数
- 5.5 【基础】偏函数
- 5.6 【进阶】泛型函数
- 5.7 【基础】变量的作用域
- 5.8 【进阶】上下文管理器
- 5.9 【进阶】装饰器的六种写法
- 第六章:错误异常
- 6.1 【基础】什么是异常?
- 6.2 【基础】如何抛出和捕获异常?
- 6.3 【基础】如何自定义异常?
- 6.4 【进阶】如何关闭异常自动关联上下文?
- 6.5 【进阶】异常处理的三个好习惯
- 第七章:类与对象
- 7.1 【基础】类的理解与使用
- 7.2 【基础】静态方法与类方法
- 7.3 【基础】私有变量与私有方法
- 7.4 【基础】类的封装(Encapsulation)
- 7.5 【基础】类的继承(Inheritance)
- 7.6 【基础】类的多态(Polymorphism)
- 7.7 【基础】类的 property 属性
- 7.8 【进阶】类的 Mixin 设计模式
- 7.9 【进阶】类的魔术方法(超全整理)
- 7.10 【进阶】神奇的元类编程(metaclass)
- 7.11 【进阶】深藏不露的描述符(Descriptor)
- 第八章:包与模块
- 8.1 【基础】什么是包、模块和库?
- 8.2 【基础】安装第三方包的八种方法
- 8.3 【基础】导入单元的构成
- 8.4 【基础】导入包的标准写法
- 8.5 【进阶】常规包与空间命名包
- 8.6 【进阶】花式导包的八种方法
- 8.7 【进阶】包导入的三个冷门知识点
- 8.8 【基础】pip 的超全使用指南
- 8.9 【进阶】理解模块的缓存
- 8.10 【进阶】理解查找器与加载器
- 8.11 【进阶】实现远程导入模块
- 8.12 【基础】分发工具:distutils和setuptools
- 8.13 【基础】源码包与二进制包有什么区别?
- 8.14 【基础】eggs与wheels 有什么区别?
- 8.15 【进阶】超详细讲解 setup.py 的编写
- 8.16 【进阶】打包辅助神器 PBR 是什么?
- 8.17 【进阶】开源自己的包到 PYPI 上
- 第九章:调试技巧
- 9.1 【调试技巧】超详细图文教你调试代码
- 9.2 【调试技巧】PyCharm 中指定参数调试程序
- 9.3 【调试技巧】PyCharm跑完后立即进入调试模式
- 9.4 【调试技巧】脚本报错后立即进入调试模式
- 9.5 【调试技巧】使用 PDB 进行无界面调试
- 9.6 【调试技巧】如何调试已经运行的程序?
- 9.7 【调试技巧】使用 PySnopper 调试疑难杂症
- 9.8 【调试技巧】使用 PyCharm 进行远程调试
- 第十章:并发编程
- 10.1 【并发编程】从性能角度初探并发编程
- 10.2 【并发编程】创建多线程的几种方法
- 10.3 【并发编程】谈谈线程中的“锁机制”
- 10.4 【并发编程】线程消息通信机制
- 10.5 【并发编程】线程中的信息隔离
- 10.6 【并发编程】线程池创建的几种方法
- 10.7 【并发编程】从 yield 开始入门协程
- 10.8 【并发编程】深入理解yield from语法
- 10.9 【并发编程】初识异步IO框架:asyncio 上篇
- 10.10 【并发编程】深入异步IO框架:asyncio 中篇
- 10.11 【并发编程】实战异步IO框架:asyncio 下篇
- 10.12 【并发编程】生成器与协程,你分清了吗?
- 10.14 【并发编程】浅谈线程安全那些事儿
- 第十二章:虚拟环境
- 12.1 【虚拟环境】为什么要有虚拟环境?
- 12.2 【虚拟环境】方案一:使用 virtualenv
- 12.3 【虚拟环境】方案二:使用 pipenv
- 12.4 【虚拟环境】方案三:使用 pipx
- 12.5 【虚拟环境】方案四:使用 poetry
- 第十三章:绝佳工具
- 13.1 【静态检查】mypy 的使用
- 13.2 【代码测试】pytest 的使用
- 13.3 【代码提交】pre-commit hook
- 13.4 【项目生成】cookiecutter 的使用
- 第十四章:数据可视化
- 14.1 【可视化之matplotlib】一图带你入门matplotlib
- 14.2 【可视化之matplotlib】详解六种可视化图表
- 14.3 【可视化之matplotlib】 绘制正余弦函数图象
- 14.4 【可视化之matplotlib】难点:子图与子区
- 14.5 【可视化之matplotlib】绘制酷炫的gif动态图
- 14.6 【可视化之matplotlib】自动生成图像视频
- 14.7 【可视化神器】最高级的可视化神器: plotly_express