【一】什么是继承#

继承是一种创建新类的方式，新建的类可以继承一个或多个父类（python支持多继承），父类又可称为基类或超类，新建的类称为派生类或子类。
子类会“”遗传”父类的属性，从而解决代码重用问题（去掉冗余的代码）
python中类的继承分为：单继承和多继承

【二】单继承和多继承#

1
# 定义父类
2
class ParentClass1:
3
    pass
4

5

6
# 定义父类
7
class ParentClass2:
8
    pass
9

10

11
# 单继承，基类是ParentClass1，派生类是SubClass
12
class SubClass1(ParentClass1):
13
    pass
14

15

16
# python支持多继承，用逗号分隔开多个继承的类
17
class SubClass2(ParentClass1, ParentClass2):
18
    pass

【三】查看继承#

1
# 定义父类
2
class ParentClass1:
3
    pass
4

5

6
# 定义父类
7
class ParentClass2:
8
    pass
9

10

11
# 单继承，基类是ParentClass1，派生类是SubClass
12
class SubClass1(ParentClass1):
13
    pass
14

15

16
# python支持多继承，用逗号分隔开多个继承的类
17
class SubClass2(ParentClass1, ParentClass2):
18
    pass
19

20

21
# __base__只查看从左到右继承的第一个子类，
22
# __bases__则是查看所有继承的父类
23
print(SubClass1.__bases__)
24
# (<class '__main__.ParentClass1'>,)
25

26
print(SubClass2.__bases__)
27
# (<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

【四】经典类与新式类#

只有在python2中才分新式类和经典类，python3中统一都是新式类
在python2中，没有显式的继承object类的类，以及该类的子类，都是经典类
在python2中，显式地声明继承object的类，以及该类的子类，都是新式类
在python3中，无论是否继承object，都默认继承object，即python3中所有类均为新式类

提示：如果没有指定基类，python的类会默认继承object类，object是所有python类的基类，它提供了一些常见方法（如__str__）的实现。

1
# 定义父类
2
class ParentClass1:
3
    pass
4

5

6
# 定义父类
7
class ParentClass2:
8
    pass
9

10

11
print(ParentClass1.__bases__)
12
# (<class 'object'>,)
13

14
print(ParentClass2.__bases__)
15
# (<class 'object'>,)

【五】继承与抽象(先抽象再继承)#

继承描述的是子类与父类之间的关系，是一种什么是什么的关系。
要找出这种关系，必须先抽象再继承
抽象即抽取类似或者说比较像的部分

【1】抽象#

抽象分成两个层次
- 将奥巴马和梅西这俩对象比较像的部分抽取成类；
- 将人，猪，狗这三个类比较像的部分抽取成父类。
抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度）

【2】继承#

继承：是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构。
抽象只是分析和设计的过程中，一个动作或者说一种技巧，通过抽象可以得到类

【六】继承与重用性#

【1】单独成类#

猫可以：喵喵叫、吃、喝、拉、撒
狗可以：汪汪叫、吃、喝、拉、撒
如果我们要分别为猫和狗创建一个类，那么就需要为猫和狗实现他们所有的功能

1
#猫和狗有大量相同的内容
2
class 猫：
3

4
    def 喵喵叫(self):
5
        print '喵喵叫'
6

7
    def 吃(self):
8
        # do something
9

10
    def 喝(self):
11
        # do something
12

13
    def 拉(self):
14
        # do something
15

16
    def 撒(self):
17
        # do something
18

19
class 狗：
20

21
    def 汪汪叫(self):
22
        print '喵喵叫'
23

24
    def 吃(self):
25
        # do something
26

27
    def 喝(self):
28
        # do something
29

30
    def 拉(self):
31
        # do something
32

33
    def 撒(self):
34
        # do something

【2】继承总类#

上述代码不难看出，吃、喝、拉、撒是猫和狗都具有的功能，而我们却分别的猫和狗的类中编写了两次。
如果使用继承的思想，如下实现：
- 动物：吃、喝、拉、撒
- 猫：喵喵叫（猫继承动物的功能）
- 狗：汪汪叫（狗继承动物的功能）

1
class 动物:
2

3
    def 吃(self):
4
        # do something
5

6
    def 喝(self):
7
        # do something
8

9
    def 拉(self):
10
        # do something
11

12
    def 撒(self):
13
        # do something
14

15
# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
16
class 猫(动物)：
17

18
    def 喵喵叫(self):
19
        print '喵喵叫'
20

21
# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
22
class 狗(动物)：
23

24
    def 汪汪叫(self):
25
        print '喵喵叫'

【3】代码实现#

继承的代码实现

1
class Animal:
2

3
    def eat(self):
4
        print("%s 吃 " % self.name)
5

6
    def drink(self):
7
        print("%s 喝 " % self.name)
8

9
    def shit(self):
10
        print("%s 拉 " % self.name)
11

12
    def pee(self):
13
        print("%s 撒 " % self.name)
14

15

16
class Cat(Animal):
17

18
    def __init__(self, name):
19
        self.name = name
20
        self.breed = '猫'
21

22
    def cry(self):
23
        print('喵喵叫')
24

25

26
class Dog(Animal):
27

28
    def __init__(self, name):
29
        self.name = name
30
        self.breed = '狗'
31

32
    def cry(self):
33
        print('汪汪叫')
34

35

36
c1 = Cat('小白家的小黑猫')
37
c1.eat()
38
# 小白家的小黑猫 吃
39

40
c2 = Cat('小黑的小白猫')
41
c2.drink()
42
# 小黑的小白猫 喝
43

44
d1 = Dog('胖子家的小瘦狗')
45
d1.eat()
46
# 胖子家的小瘦狗 吃

【4】代码重用#

在开发程序的过程中，如果我们定义了一个类A，然后又想新建立另外一个类B，但是类B的大部分内容与类A的相同时
我们不可能从头开始写一个类B，这就用到了类的继承的概念。
通过继承的方式新建类B，让B继承A，B会‘遗传’A的所有属性(数据属性和函数属性)，实现代码重用

1
class Hero:
2
    def __init__(self, nickname, aggressivity, life_value):
3
        self.nickname = nickname
4
        self.aggressivity = aggressivity
5
        self.life_value = life_value
6

7
    def move_forward(self):
8
        print('%s move forward' % self.nickname)
9

10
    def move_backward(self):
11
        print('%s move backward' % self.nickname)
12

13
    def move_left(self):
14
        print('%s move forward' % self.nickname)
15

16
    def move_right(self):
17
        print('%s move forward' % self.nickname)
18

19
    def attack(self, enemy):
20
        enemy.life_value -= self.aggressivity
21

22

23
class Garen(Hero):
24
    pass
25

26

27
class Riven(Hero):
28
    pass
29

30

31
g1 = Garen('草丛伦', 100, 300)
32
r1 = Riven('锐雯雯', 57, 200)
33

34
print(g1.life_value)
35
r1.attack(g1)
36
print(g1.life_value)
37

38
'''
39
运行结果
40
243
41
'''

【5】小结#

提示：用已经有的类建立一个新的类，这样就重用了已经有的软件中的一部分设置大部分，大大生了编程工作量，这就是常说的软件重用，不仅可以重用自己的类，也可以继承别人的，比如标准库，来定制新的数据类型，这样就是大大缩短了软件开发周期，对大型软件开发来说，意义重大.
注意：像g1.life_value之类的属性引用，会先从实例中找life_value然后去类中找，然后再去父类中找…直到最顶级的父类。

【七】属性查找顺序#

【1】不隐藏属性#

有了继承关系，对象在查找属性时
- 先从对象自己的__dict__中找
- 如果没有则去子类中找
- 然后再去父类中找……

1
class Foo:
2
    def f1(self):
3
        print('Foo.f1')
4

5
    # 【3】发现父类中找到了 f2 方法
6
    def f2(self):
7
        print('Foo.f2')
8
        # 【4】
9
        # 但是这里犯了难，这个 self 到底是 Foo 还是 Bar ？
10
        # 我们要时刻记得，源头是谁，这个self就是谁
11
        # 我们是从 对象 b 来的，而对象 b 又是 Bar 的对象
12
        # 我们从 Bar 找到了 Foo 类里面，所以我们的源头就是 Bar
13
        # 那这个 self 就是 Bar ， 而 Bar 类里面有 f1 方法
14
        # 所以我们就会回到 Bar 类里面
15
        self.f1()
16

17

18
class Bar(Foo):
19
    # 【2】来到 Bar 类里面寻找 f2 方法，但是发现自己没有
20
    # 于是向上查找，去父类 Foo 中查找
21
    def f1(self):
22
        # 【5】 找到了 Bar 中的方法
23
        print('Bar.f1')
24

25

26
# 实例化类得到对象
27
b = Bar()
28
# 【1】对象调用方法
29
b.f2()
30
# 【6】所以打印的顺序是 Foo 类中的 f2 ， Bar 类中的 f1
31
# Foo.f2
32
# Bar.f1

b.f2()会在父类Foo中找到f2
- 先打印Foo.f2
- 然后执行到self.f1(),即b.f1()
仍会按照：对象本身->类Bar->父类Foo的顺序依次找下去
- 在类Bar中找到f1
- 因而打印结果为Foo.f1

【2】隐藏属性#

父类如果不想让子类覆盖自己的方法，可以采用双下划线开头的方式将方法设置为私有的

1
class Foo:
2
    # 变形为_Foo__fa
3
    def __f1(self):
4
        print('Foo.f1')
5

6
    def f2(self):
7
        print('Foo.f2')
8
        # 变形为self._Foo__fa,因而只会调用自己所在的类中的方法
9
        self.__f1()
10

11

12
class Bar(Foo):
13
    # 变形为_Bar__f1
14
    def __f1(self):
15
        print('Bar.f1')
16

17

18
b = Bar()
19
# 在父类中找到f2方法，进而调用b._Foo__f1()方法，同样是在父类中找到该方法
20
b.f2()
21
# Foo.f2
22
# Foo.f1

【八】继承实现的原理#

【1】非菱形结构继承顺序#

在Java和C#中子类只能继承一个父类，而Python中子类可以同时继承多个父类，如A(B,C,D)
如果继承关系为非菱形结构，则会按照先找B这一条分支，然后再找C这一条分支，最后找D这一条分支的顺序直到找到我们想要的属性

【2】菱形结构继承顺序#

如果继承关系为菱形结构，那么属性的查找方式有两种，分别是：深度优先和广度优先

（1）深度优先#

当类是经典类时，多继承情况下，在查找属性不存在时，会按照深度优先的方式查找下去

（2）广度优先#

当类是新式类时，多继承情况下，在查找属性不存在时，会按照广度优先的方式查找下去

（3）代码#

1
class A(object):
2
    def test(self):
3
        print('from A')
4

5

6
class B(A):
7
    def test(self):
8
        print('from B')
9

10

11
class C(A):
12
    def test(self):
13
        print('from C')
14

15

16
class D(B):
17
    def test(self):
18
        print('from D')
19

20

21
class E(C):
22
    def test(self):
23
        print('from E')
24

25

26
class F(D, E):
27
    # def test(self):
28
    #     print('from F')
29
    pass
30

31

32
f1 = F()
33
f1.test()
34
# 只有新式才有这个属性可以查看线性列表，经典类没有这个属性
35
print(F.__mro__)
36

37
# 新式类继承顺序:F->D->B->E->C->A
38
# 经典类继承顺序:F->D->B->A->E->C
39
# python3中统一都是新式类
40
# pyhon2中才分新式类与经典类

【3】继承原理（Python如何实现的继承）#

python到底是如何实现继承的，对于你定义的每一个类，python会计算出一个方法解析顺序(MRO)列表，这个MRO列表就是一个简单的所有基类的线性顺序列表

1
class A(object):
2
    def test(self):
3
        print('from A')
4

5

6
class B(A):
7
    def test(self):
8
        print('from B')
9

10

11
class C(A):
12
    def test(self):
13
        print('from C')
14

15

16
class D(B):
17
    def test(self):
18
        print('from D')
19

20

21
class E(C):
22
    def test(self):
23
        print('from E')
24

25

26
class F(D, E):
27
    # def test(self):
28
    #     print('from F')
29
    pass
30

31

32
f1 = F()
33
f1.test()
34

35
print(F.mro())
36
# [<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

为了实现继承,python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。
而这个MRO列表的构造是通过一个C3线性化算法来实现的。
我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:
- 子类会先于父类被检查
- 多个父类会根据它们在列表中的顺序被检查
- 如果对下一个类存在两个合法的选择,选择第一个父类

【九】Mixins机制#

【1】引入#

一个子类可以同时继承多个父类，这样的设计常被人诟病
- 一来它有可能导致可恶的菱形问题
- 二来在人的世界观里继承应该是个”is-a”关系。
比如轿车类之所以可以继承交通工具类，是因为基于人的世界观
- 我们可以说：轿车是一个(“is-a”)交通工具
- 而在人的世界观里，一个物品不可能是多种不同的东西，

【2】多重继承问题#

因此多重继承在人的世界观里是说不通的
- 它仅仅只是代码层面的逻辑。
- 不过有没有这种情况，一个类的确是需要继承多个类呢？
答案是有，我们还是拿交通工具来举例子:
- 民航飞机、直升飞机、轿车都是一个（is-a）交通工具
  - 前两者都有一个功能是飞行fly，但是轿车没有
  - 所以如下所示我们把飞行功能放到交通工具这个父类中是不合理的

1
# 交通工具总类
2
class Vehicle:
3
    def fly(self):
4
        '''
5
        飞行功能相应的代码
6
        '''
7
        print("I am flying")
8

9

10
# 民航飞机类
11
class CivilAircraft(Vehicle):
12
    pass
13

14

15
# 直升飞机类
16
class Helicopter(Vehicle):
17
    pass
18

19

20
# 汽车并不会飞，但按照上述继承关系，汽车也能飞了
21
class Car(Vehicle):
22
    pass

但是如果民航飞机和直升机都各自写自己的飞行fly方法，又违背了代码尽可能重用的原则
- （如果以后飞行工具越来越多，那会重复代码将会越来越多）。

【3】多重继承问题解决#

怎么办？？？
- 为了尽可能地重用代码，那就只好在定义出一个飞行器的类，然后让民航飞机和直升飞机同时继承交通工具以及飞行器两个父类
- 这样就出现了多重继承。这时又违背了继承必须是”is-a”关系。
- 这个难题该怎么解决？
不同的语言给出了不同的方法，让我们先来了解Java的处理方法。
- Java提供了接口interface功能，来实现多重继承：

1
// 抽象基类：交通工具类
2
public abstract class Vehicle {
3
}
4

5
// 接口：飞行器
6
public interface Flyable {
7
    public void fly();
8
}
9

10
// 类：实现了飞行器接口的类，在该类中实现具体的fly方法，这样下面民航飞机与直升飞机在实现fly时直接重用即可
11
public class FlyableImpl implements Flyable {
12
    public void fly() {
13
        System.out.println("I am flying");
14
    }
15
}
16

17

18

19
// 民航飞机，继承自交通工具类，并实现了飞行器接口
20
public class CivilAircraft extends Vehicle implements Flyable {
21
    private Flyable flyable;
22

23
    public CivilAircraft() {
24
        flyable = new FlyableImpl();
25
    }
26

27
    public void fly() {
28
        flyable.fly();
29
    }
30
}
31

32
// 直升飞机，继承自交通工具类，并实现了飞行器接口
33
public class Helicopter extends Vehicle implements Flyable {
34
    private Flyable flyable;
35

36
    public Helicopter() {
37
        flyable = new FlyableImpl();
38
    }
39

40
    public void fly() {
41
        flyable.fly();
42
    }
43
}
44

45
// 汽车，继承自交通工具类，
46
public class Car extends Vehicle {
47
}

现在我们的飞机同时具有了交通工具及飞行器两种属性
- 而且我们不需要重写飞行器中的飞行方法，同时我们没有破坏单一继承的原则。
- 飞机就是一种交通工具，可飞行的能力是飞机的属性，通过继承接口来获取。
回到主题，Python语言可没有接口功能
- 但Python提供了Mixins机制
- 简单来说Mixins机制指的是子类混合(mixin)不同类的功能
- 而这些类采用统一的命名规范（例如Mixin后缀）
- 以此标识这些类只是用来混合功能的，并不是用来标识子类的从属”is-a”关系的
- 所以Mixins机制本质仍是多继承，但同样遵守”is-a”关系

1
# 交通工具
2
class Vehicle:
3
    pass
4

5

6
class FlyableMixin:
7
    def fly(self):
8
        '''
9
        飞行功能相应的代码
10
        '''
11
        print("I am flying")
12

13

14
# 民航飞机
15
class CivilAircraft(FlyableMixin, Vehicle):
16
    pass
17

18

19
# 直升飞机
20
class Helicopter(FlyableMixin, Vehicle):
21
    pass
22

23

24
# 汽车
25
class Car(Vehicle):
26
    pass
27

28
# ps: 采用某种规范（如命名规范）来解决具体的问题是python惯用的套路

可以看到，上面的CivilAircraft、Helicopter类实现了多继承
- 不过它继承的第一个类我们起名为FlyableMixin，而不是Flyable
- 这个并不影响功能，但是会告诉后来读代码的人，这个类是一个Mixin类，表示混入(mix-in)
- 这种命名方式就是用来明确地告诉别人（python语言惯用的手法），这个类是作为功能添加到子类中，而不是作为父类
- 它的作用同Java中的接口。
- 所以从含义上理解，CivilAircraft、Helicopter类都只是一个Vehicle，而不是一个飞行器。

【4】小结#

使用Mixin类实现多重继承要非常小心
- 首先它必须表示某一种功能，而不是某个物品，python 对于mixin类的命名方式一般以 Mixin, able, ible 为后缀
- 其次它必须责任单一，如果有多个功能，那就写多个Mixin类，一个类可以继承多个Mixin，为了保证遵循继承的“is-a”原则，只能继承一个标识其归属含义的父类
- 然后，它不依赖于子类的实现
- 最后，子类即便没有继承这个Mixin类，也照样可以工作，就是缺少了某个功能。（比如飞机照样可以载客，就是不能飞了）
Mixins是从多个类中重用代码的好方法，但是需要付出相应的代价
- 我们定义的Minx类越多，子类的代码可读性就会越差
- 并且更恶心的是，在继承的层级变多时，代码阅读者在定位某一个方法到底在何处调用时会晕头转向

1
class Displayer:
2
    def display(self, message):
3
        print(message)
4

5

6
class LoggerMixin:
7
    def log(self, message, filename='logfile.txt'):
8
        with open(filename, 'a') as fh:
9
            fh.write(message)
10

11
    def display(self, message):
12
        super().display(message) # super的用法请参考下一小节
13
        self.log(message)
14

15

16
class MySubClass(LoggerMixin, Displayer):
17
    def log(self, message):
18
        super().log(message, filename='subclasslog.txt')
19

20

21
obj = MySubClass()
22
obj.display("This string will be shown and logged in subclasslog.txt")
23

24

25
# 属性查找的发起者是obj,所以会参照类MySubClass的MRO来检索属性
26
#[<class '__main__.MySubClass'>, <class '__main__.LoggerMixin'>, <class '__main__.Displayer'>, <class 'object'>]
27

28
# 1、首先会去对象obj的类MySubClass找方法display，没有则去类LoggerMixin中找，找到开始执行代码
29
# 2、执行LoggerMixin的第一行代码：执行super().display(message)，参照MySubClass.mro(),super会去下一个类即类Displayer中找，找到display，开始执行代码，打印消息"This string will be shown and logged in subclasslog.txt"
30
# 3、执行LoggerMixin的第二行代码：self.log(message)，self是对象obj，即obj.log(message)，属性查找的发起者为obj，所以会按照其类MySubClass.mro(),即MySubClass->LoggerMixin->Displayer->object的顺序查找，在MySubClass中找到方法log，开始执行super().log(message, filename='subclasslog.txt')，super会按照MySubClass.mro()查找下一个类，在类LoggerMixin中找到log方法开始执行，最终将日志写入文件subclasslog.txt

Java只允许接口的多重继承。接口本质上是抽象基类，具有所有抽象方法，没有数据成员。
与java一样，python也有抽象类的概念但是同样需要借助模块实现，抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化，继承的子类必须实现抽象基类规定的方法，这样便可保证始终只有一个特定方法或属性的实现，并且不会产生歧义，因而也可以起到避免菱形问题的作用

音乐

音乐

【一】什么是继承#

【二】单继承和多继承#

【三】查看继承#

【四】经典类与新式类#

【五】继承与抽象(先抽象再继承)#

【1】抽象#

【2】继承#

【六】继承与重用性#

【1】单独成类#

【2】继承总类#

【3】代码实现#

【4】代码重用#

【5】小结#

【七】属性查找顺序#

【1】不隐藏属性#

【2】隐藏属性#

【八】继承实现的原理#

【1】非菱形结构继承顺序#

【2】菱形结构继承顺序#

（1）深度优先#

（2）广度优先#

（3）代码#

【3】继承原理（Python如何实现的继承）#

【九】Mixins机制#

【1】引入#

【2】多重继承问题#

【3】多重继承问题解决#

【4】小结#

支持与分享

音乐

Python面向对象之继承

【一】什么是继承#

【二】单继承和多继承#

【三】查看继承#

【四】经典类与新式类#

【五】继承与抽象(先抽象再继承)#

【1】抽象#

【2】继承#

【六】继承与重用性#

【1】单独成类#

【2】继承总类#

【3】代码实现#

【4】代码重用#

【5】小结#

【七】属性查找顺序#

【1】不隐藏属性#

【2】隐藏属性#

【八】继承实现的原理#

【1】非菱形结构继承顺序#

【2】菱形结构继承顺序#

（1）深度优先#

（2）广度优先#

（3）代码#

【3】继承原理（Python如何实现的继承）#

【九】Mixins机制#

【1】引入#

【2】多重继承问题#

【3】多重继承问题解决#

【4】小结#

支持与分享