一篇文章带你搞懂Python中的继承和多态

一、继承的介绍

 

继承是一种创建新的类的方式，新创建的叫子类，继承的叫父类、超类、基类。继承的特点就是子类可以使用父类的属性(特征、技能)。继承是类与类之间的关系。

继承可以减少代码冗余、提高重用性。

在现实生活中，继承一般指的是子女继承父辈的财产，如下图：

二、如何用继承?

 

1.继承语法

Class 派生类名(基类名)：#基类名写在括号里。

在继承关系中，已有的，设计好的类称为父类或基类，新设计的类称为子类或派生类。派生类可以继承父类的公有成员，但是不能继承其私有成员。

2. 继承的特点

在继承中基类的构造函数(init()方法)不会被自动调用，它需要在其派生类的构造中亲自专门调用。

如果需要在派生类中调用基类的方法时，通过“基类名.方法名()”的方法来实现，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self 参数。也可以使用内置函数super()实现这一目的。

Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找(先在本类查找调用的方法，找不到才去基类中找)。

3. 单继承

3.1 单继承

例：

1. class Animal: #父类 
2.     def eat(self):  
3.         print("-----吃-----") 
4.  
5.     def drink(self): 
6.         print("-----喝-----") 
7.  
8.  
9. class Dog(Animal): #子类继承父类 
10.     """ 
11.     def eat(self): 
12.         print("-----吃-----") 
13.  
14.     def drink(self): 
15.         print("-----喝-----") 
16.     """ 
17.     pass 
18.  
19.  
20. class Cat: 
21.     pass 
22.  
23.  
24. wang_cai = Dog() 
25. wang_cai.eat() 
26. wang_cai.drink() 

运行结果：

3.2 多层继承

例：

1. class Animal: 
2.     def eat(self): 
3.         print("-----吃-----") 
4.  
5.     def drink(self): 
6.         print("-----喝-----") 
7.  
8.  
9. class Dog(Animal): 
10.     def bark(self): 
11.         print("-----汪汪叫------") 
12.  
13.  
14. class XTQ(Dog): 
15.     """定义了一个哮天犬 类""" 
16.     pass 
17.  
18.  
19. class Cat(Animal): 
20.     def catch(self): 
21.         print("----捉老鼠----") 
22.  
23.  
24. xtq = XTQ() 
25. xtq.eat() 
26. xtq.bark() 

运行结果：

3.3 重写父类方法

例：

1. class Animal: #父类 
2.     def eat(self): 
3.         print("-----吃-----") 
4.  
5.     def drink(self): 
6.         print("-----喝-----") 
7.  
8.   
9. class Dog(Animal):  
10.     def bark(self): 
11.         print("-----汪汪叫------") 
12.  
13.  
14. class XTQ(Dog): #重写Dog方法 
15.     """定义了一个哮天犬 类""" 
16.     def bark(self): 
17.         print("----嗷嗷叫-----") 
18.  
19.  
20. class Cat(Animal): 
21.     def catch(self): 
22.         print("----捉老鼠----") 
23.  
24.  
25. xtq = XTQ() 
26. xtq.eat() 
27. xtq.bark() 

运行结果：

4. 多继承

4.1 多继承

从图中能够看出，所谓多继承，即子类有多个父类，并且具有它们的特征。

Python中多继承的格式如下:

1. # 定义一个父类 
2. class A: 
3.     def printA(self): 
4.         print('----A----') 
5.  
6. # 定义一个父类 
7. class B: 
8.     def printB(self): 
9.         print('----B----') 
10.  
11. # 定义一个子类，继承自A、B 
12. class C(A,B): 
13.     def printC(self): 
14.         print('----C----') 
15.  
16. obj_C = C() 
17. obj_C.printA() 
18. obj_C.printB() 

运行结果:

1. ----A---- 
2. ----B---- 

Python中是可以多继承的，父类中的方法、属性，子类会继承。

想一想:

如果在上面的多继承例子中，如果父类A和父类B中，有一个同名的方法，那么通过子类去调用的时候，调用哪个?

1. #coding=utf-8 
2. class base(object): 
3.     def test(self): 
4.         print('----base test----') 
5. class A(base): 
6.     def test(self): 
7.         print('----A test----') 
8.  
9. # 定义一个父类 
10. class B(base): 
11.     def test(self): 
12.         print('----B test----') 
13.  
14. # 定义一个子类，继承自A、B 
15. class C(A,B): 
16.     pass 
17.  
18.  
19. obj_C = C() 
20. obj_C.test() 
21.  
22. print(C.__mro__) #可以查看C类的对象搜索方法时的先后顺序 

运行结果：

5. 多态

5.1 什么是多态?

多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。

所谓多态：定义时的类型和运行时的类型不一样，此时就成为多态。

Python伪代码实现Java或C#的多态。

5.2 案例

Python “鸭子类型”

1. class Duck: 
2.     def quack(self): 
3.         print("Quaaaaaack!") 
4.  
5.  
6. class Bird: 
7.     def quack(self): 
8.         print("bird imitate duck.") 
9.  
10.  
11. class Doge: 
12.     def quack(self): 
13.         print("doge imitate duck.") 
14.  
15.  
16. def in_the_forest(duck): 
17.     duck.quack() 
18.  
19.  
20. duck = Duck() 
21. bird = Bird() 
22. doge = Doge() 
23. for x in [duck, bird, doge]: 
24.     in_the_forest(x) 

运行结果：

三、总结

 

本文以生活中的基础现象为切入点，主要介绍了Python基础中继承和多态，包括单继承、多继承的语法、多态常见的 “鸭子类型”、 以及如何重写父类的方法都做了详细的讲解。

用丰富的案例帮助大家更好理解，使用Python编程语言，方便大家更好理解，希望对大家的学习有帮助。

原文链接：https://mp.weixin.qq.com/s/XkBe1QlCt4WDQDG_Qf-kWA