1.继承介绍
1.1什么是继承
继承是一种创建新类的方式，在Python中，新建的类可以继承一个或多个父类，新建的类可称为子类或派生类，父类又可称为基类或超类
class Parent1:
x = 11
class Parent2:
pass
class Sub1(Parent1):
pass
class Sub2(Parent1, Parent2):
pass
通过类的内置属性__bases__可以查看类继承的所有父类
print(Sub1.__bases__) # 查看sub1的父类
print(Sub2.__bases__) # 查看sub2的父类
补充 :
ps1 : 在python2中有经典类和新式类
新式类:继承了object类的子类,以及子子类的子类
经典类:没有继承object类的子类,以及子类的子类
ps2 : python3中的类默认是新式类,即默认继承object类
1.2为什么要继承以及继承的意义
为什么要用继承
解决类与类之间代码冗余问题
继承的意义
子类会遗传父类的属性,解决类与类之间代码冗余问题
2.继承和抽象
要找出类与类之间的继承关系，需要先抽象，再继承。抽象即总结相似之处，总结对象之间的相似之处得到类，总结类与类之间的相似之处就可以得到父类，如下图所示
基于抽象的结果，我们就找到了继承关系
基于上图我们可以看出类与类之间的继承指的是什么’是’什么的关系（比如人类，猪类，猴类都是动物类）。子类可以继承／遗传父类所有的属性，因而继承可以用来解决类与类之间的代码重用性问题。比如我们按照定义Student类的方式再定义一个Teacher类
class Teacher:
school='清华大学'
def __init__(self,name,sex,age):
self.name=name
self.sex=sex
self.age=age
def teach(self):
print('%s is teaching' %self.name)
类Teacher与Student之间存在重复的代码，老师与学生都是人类，所以我们可以得出如下继承关系，实现代码重用
class People:
school='清华大学'
def __init__(self,name,sex,age):
self.name=name
self.sex=sex
self.age=age
class Student(People):
def choose(self):
print('%s is choosing a course' %self.name)
class Teacher(People):
def teach(self):
print('%s is teaching' %self.name)
Teacher类内并没有定义__init__方法，但是会从父类中找到__init__,因而仍然可以正常实例化，如下
>>> teacher1=Teacher('lili','male',18)
>>> teacher1.school,teacher1.name,teacher1.sex,teacher1.age
('清华大学', 'lili', 'male', 18)
这整个的过程就是我们平常写代码 , 怎么样写出来继承的 , 先分开写类 , 然后有重复的代码 , 归纳到父类中继承
3.属性查找
1.单继承下的属性查找
有了继承关系，对象在查找属性时，先从对象自己的__dict__中找，如果没有则去当前类中找，然后再去父类中找
class Foo:
def f1(self):
print("foo.f1")
def f2(self):
print("foo.f2")
self.f1()
class Bar(Foo):
def f1(self):
print("bar.f1")
b = Bar()
b.f2()
# 只要涉及到继承找属性,一定要先从当前对象查找,没有,再到类中查找,如果在没有再到父类中查找
父类如果不想让子类覆盖自己的方法，可以采用双下划线开头的方式将方法设置为私有的
class Foo: def __f1(self): # 变形为_Foo__fa print('Foo.f1') def f2(self): print('Foo.f2') self.__f1() # 变形为self._Foo__fa,因而只会调用自己所在的类中的方法class Bar(Foo): def __f1(self): # 变形为_Bar__f1 print('Foo.f1') b=Bar()b.f2() #在父类中找到f2方法，进而调用b._Foo__f1()方法，同样是在父类中找到该方法Foo.f2Foo.f1
关于多继承下的属性查找 , 会涉及到菱形问题 , 以及python多继承的优缺点 , 和mixins机制 , 下面单独具体介绍
4.继承实现的原理
1.python多继承的优缺点
优点:子类可以同时遗传多个父类的属性,最大限度的重用代码 缺点:1.违背人的思维习惯:继承表达的是一种什么"是"什么的关系,多继承就会出现一个东西是好几种东西 2.代码可读性比较差 3.不建议使用多继承,有可能产生菱形问题,扩展性变差, 如果一个子类不可避免地要重用多个父类的属性,应该使用Mixins机制
2.菱形问题
大多数面向对象语言都不支持多继承，而在Python中，一个子类是可以同时继承多个父类的，这固然可以带来一个子类可以对多个不同父类加以重用的好处，但也有可能引发著名的 Diamond problem菱形问题(或称钻石问题，有时候也被称为“死亡钻石”)，菱形其实就是对下面这种继承结构的形象比喻
A类在顶部，B类和C类分别位于其下方，D类在底部将两者连接在一起形成菱形。
这种继承结构下导致的问题称之为菱形问题：如果A中有一个方法，B和/或C都重写了该方法，而D没有重写它，那么D继承的是哪个版本的方法：B的还是C的？如下所示
class A(object): def test(self): print('from A')class B(A): def test(self): print('from B')class C(A): def test(self): print('from C')class D(B,C): passobj = D()obj.test() # 结果为：from B
要想搞明白obj.test()是如何找到方法test的，需要了解python的继承实现原理
3.继承的原理
python到底是如何实现继承的呢？ 对于你定义的每一个类，Python都会计算出一个方法解析顺序(MRO)列表，该MRO列表就是一个简单的所有基类的线性顺序列表，如下
print(D.mro()) # 新式类内置了mro方法可以查看线性列表的内容，经典类没有该内置该方法[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
python会在MRO列表上从左到右开始查找基类, 直到找到第一个匹配这个属性的类为止。 而这个MRO列表的构造是通过一个C3线性化算法来实现的
4.深度优先和广度优先
如果继承关系为菱形结构，那么经典类与新式类会有不同MRO，分别对应属性的两种查找方式：深度优先和广度优先
class G: # 在python2中，未继承object的类及其子类，都是经典类 def test(self): print('from G')class E(G): def test(self): print('from E')class F(G): def test(self): print('from F')class B(E): def test(self): print('from B')class C(F): def test(self): print('from C')class D(G): def test(self): print('from D')class A(B,C,D): # def test(self): # print('from A') passobj = A()obj.test() # 如上图，查找顺序为:obj->A->B->E->G->C->F->D->object# 可依次注释上述类中的方法test来进行验证,注意请在python2.x中进行测试
class G(object): def test(self): print('from G')class E(G): def test(self): print('from E')class F(G): def test(self): print('from F')class B(E): def test(self): print('from B')class C(F): def test(self): print('from C')class D(G): def test(self): print('from D')class A(B,C,D): # def test(self): # print('from A') passobj = A()obj.test() # 如上图，查找顺序为:obj->A->B->E->C->F->D->G->object# 可依次注释上述类中的方法test来进行验证
小结
python2中经典类多继承遇到菱形问题是深度优先python3中新式类多继承遇到菱形问题是广度优先
5.Pyton Mixins机制
一个子类可以同时继承多个父类，这样的设计常被人诟病，一来它有可能导致可恶的菱形问题，二来在人的世界观里继承应该是个”is-a”关系。 比如轿车类之所以可以继承交通工具类，是因为基于人的世界观，我们可以说：轿车是一个(“is-a”)交通工具，而在人的世界观里，一个物品不可能是多种不同的东西，因此多重继承在人的世界观里是说不通的，它仅仅只是代码层面的逻辑。不过有没有这种情况，一个类的确是需要继承多个类呢？
答案是有，我们还是拿交通工具来举例子:
民航飞机、直升飞机、轿车都是一个（is-a）交通工具，前两者都有一个功能是飞行fly，但是轿车没有，所以如下所示我们把飞行功能放到交通工具这个父类中是不合理的
class Vehicle: # 交通工具 def fly(self): ''' 飞行功能相应的代码 ''' print("I am flying")class CivilAircraft(Vehicle): # 民航飞机 passclass Helicopter(Vehicle): # 直升飞机 passclass Car(Vehicle): # 汽车并不会飞，但按照上述继承关系，汽车也能飞了 pass
但是如果民航飞机和直升机都各自写自己的飞行fly方法，又违背了代码尽可能重用的原则（如果以后飞行工具越来越多，那会重复代码将会越来越多）。
怎么办？？？为了尽可能地重用代码，那就只好在定义出一个飞行器的类，然后让民航飞机和直升飞机同时继承交通工具以及飞行器两个父类，这样就出现了多重继承。这时又违背了继承必须是”is-a”关系。这个难题该怎么解决？
python提供了Mixins机制，简单来说Mixins机制指的是子类混合(mixin)不同类的功能，而这些类采用统一的命名规范（例如Mixin后缀），以此标识这些类只是用来混合功能的，并不是用来标识子类的从属"is-a"关系的，所以Mixins机制本质仍是多继承，但同样遵守”is-a”关系，如下
class Vehicle: # 交通工具 passclass FlyableMixin: def fly(self): ''' 飞行功能相应的代码 ''' print("I am flying")class CivilAircraft(FlyableMixin, Vehicle): # 民航飞机 passclass Helicopter(FlyableMixin, Vehicle): # 直升飞机 passclass Car(Vehicle): # 汽车 pass# ps: 采用某种规范（如命名规范）来解决具体的问题是python惯用的套路
简单总结 : 多继承中遇到混合继承 , 那么就采用Mixins机制解决 , 注意这不是语法严格要求的 , 这是约定俗成的
使用Mixin类实现多重继承要非常小心
- 首先它必须表示某一种功能，而不是某个物品，python 对于mixin类的命名方式一般以 Mixin, able, ible 为后缀
- 其次它必须责任单一，如果有多个功能，那就写多个Mixin类，一个类可以继承多个Mixin，为了保证遵循继承的“is-a”原则，只能继承一个标识其归属含义的父类
- 然后，它不依赖于子类的实现
- 最后，子类即便没有继承这个Mixin类，也照样可以工作，就是缺少了某个功能。（比如飞机照样可以载客，就是不能飞了）
5.派生与方法重用
子类可以派生出自己新的属性，在进行属性查找时，子类中的属性名会优先于父类被查找 , 那么在子类派生的新方法中如何重用父类的功能???
方式1: 指名道姓调用某一类下的函数=>不依赖继承关系
# 重用父类中的__init__方法class Foo: def __init__(self, name, age, sex): self.name = name self.age = age self.sex = sexclass Teacher(Foo): def __init__(self, name, age, sex, salary, level): Foo.__init__(self, name, age, sex) self.salary = salary self.level = level
方式2: super()调用父类提供给自己的方法=>严格继承关系
class Foo1: def __init__(self, name, age, sex): self.name = name self.age = age self.sex = sexclass Teacher1(Foo1): def __init__(self, name, age, sex, salary, level): # super(Foo1,self).__init__(name, age, sex) super().__init__(name, age, sex) # 调用的是方法,自动传入对象 self.salary = salary self.level = level # 调用 super()会得到一个特殊的对象,该对象会参照发起属性查找的那个类的mro,去当前类的父类中找属性
super方法会在后面我们重写父类方法的时候必须先加上这一行代码 , 为的是不破坏原来父类中该方法的代码 , 我们只是重用并新增一些代码 , 即在原来的基础上追加
6.组合
在一个类中以另外一个类的对象作为数据属性，称为类的组合。就是把对象当成属性
组合与继承都是用来解决代码的重用性问题。不同的是：继承是一种“是”的关系，比如老师是人、学生是人，当类之间有很多相同的之处，应该使用继承；而组合则是一种“有”的关系，比如老师有生日，老师有多门课程，当类之间有显著不同，并且较小的类是较大的类所需要的组件时，应该使用组合，如下示例
class Course: def __init__(self,name,period,price): self.name=name self.period=period self.price=price def tell_info(self): print('<%s %s %s>' %(self.name,self.period,self.price))class Date: def __init__(self,year,mon,day): self.year=year self.mon=mon self.day=day def tell_birth(self): print('<%s-%s-%s>' %(self.year,self.mon,self.day))class People: school='清华大学' def __init__(self,name,sex,age): self.name=name self.sex=sex self.age=age#Teacher类基于继承来重用People的代码，基于组合来重用Date类和Course类的代码class Teacher(People): #老师是人 def __init__(self,name,sex,age,title,year,mon,day): super().__init__(name,age,sex) self.birth=Date(year,mon,day) #老师有生日 self.courses=[] #老师有课程，可以在实例化后，往该列表中添加Course类的对象 def teach(self): print('%s is teaching' %self.name)python=Course('python','3mons',3000.0)linux=Course('linux','5mons',5000.0)teacher1=Teacher('lili','female',28,'博士生导师',1990,3,23)# teacher1有两门课程teacher1.courses.append(python)teacher1.courses.append(linux)# 重用Date类的功能teacher1.birth.tell_birth()# 重用Course类的功能for obj in teacher1.courses: obj.tell_info()
此时对象teacher1集对象独有的属性、Teacher类中的内容、Course类中的内容于一身（都可以访问到），是一个高度整合的产物