一 继承的概念
1、什么是继承
继承是一种创建新类的的方式，新建的类可以称为子类或派生类，被继承的类称为父类，父类又可称为基类或超类，子类会遗传父类的属性
类与类之间的继承指的是什么’是’什么的关系（比如人类，猪类，猴类都是动物类）
要找出类与类之间的继承关系，需要先抽象，再继承。抽象即总结相似之处，总结对象之间的相似之处得到类，总结类与类之间的相似之处就可以得到父类
class Parent1(object):
x=1111
class Sub1(Parent1): # 单继承
pass
print(Sub1.x) #111
1.1 经典类与新式类
在 python2 中，有经典类与新式类之分：
新式类：继承了object 类的子类， 以及该子类的子子类被称为新式类
经典类：没有继承 object 类的子类，以及该子类的子子类被称为经典类
在 python3 中，没有继承任何类的话，默认继承 object 类，所以 python3 中所有类都是新式类
1.2 查看子类继承的所有父类
通过类的内置属性__ bases__可以查看类继承的所有父类
>> SubClass2.__bases__
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)
2、为何要用继承
优点：用来解决类与类之间代码冗余问题
缺点：将类耦合到了一起
2.1 python 的多继承
python 支持多继承，即在 python 中，新建的类可以继承一个或者多个父类。
class Parent1(object):
x=1111
class Parent2(object):
pass
class Sub1(Parent1): # 单继承
pass
class Sub2(Parent1,Parent2): # 多继承
pass
#查看类的基类(父类）
print(Sub1.__bases__) #(<class '__main__.Parent1'>,)
print(Sub2.__bases__) #(<class '__main__.Parent1'>, <class '__main__.Parent2'>)
print(Sub1.x) #111
优点：子类可以同时遗传多个父类的属性，最大程度地重用父类的属性
缺点：
1、违背了人的思维习惯：继承表达的是一种什么'是'什么的关系
2、代码可读性会变差
3、不建议使用多继承，有可能会引可恶的菱形问题，扩展性变差
如果真的涉及到一个子类不可避免地要重用多个父类属性，应该使用 Mixins
3 如何实现继承
示例：基于继承解决类与类之间的冗余问题
class OldboyPeople:
school = 'OLDBOY'
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
class Student(OldboyPeople):
def choose_course(self):
print('学生%s 正在选课' % self.name)
# stu_obj = Student('lili', 18, 'female')
# print(stu_obj.__dict__)
# print(stu_obj.school)
# stu_obj.choose_course()
class Teacher(OldboyPeople):
# 老师的空对象，'egon',18,'male',3000,10
def __init__(self, name, age, sex, salary, level):
# 指名道姓地跟父类OldboyPeople去要__init__
OldboyPeople.__init__(self,name,age, sex) ##调用的是函数,因而需要传入self
self.salary = salary
self.level = level
def score(self):
print('老师 %s 正在给学生打分' % self.name)
tea_obj=Teacher('egon',18,'male',3000,10)
print(tea_obj.__dict__) #{'name': 'egon', 'age': 18, 'sex': 'male', 'salary': 3000, 'level': 10}
print(tea_obj.school) #OLDBOY
tea_obj.score() #老师 egon 正在给学生打分
3.1 派生与继承
子类继承父类，派生出自己的属性与方法，并且重用父类的属性与方法。
解决问题：子类重用父类的属性，并派生出新的属性
两种方式：
1.直接引用父类的__ init__为其传参，并添加子类的属性，它是指名道姓调用某一个类下的函数，不依赖与继承关系
2.通过super来指向父类的属性，super()调用父类提供自己的方法，严格依赖继承关系
ps：super是一个特殊的类，super()得到一个对象，该对象指向父类的名称空间
注意：使用哪一种都可以，但不能两种方式混合使用
class People:
school = '上交大'
def __init__(self, name, sex, age):
self.name = name
self.sex = sex
self.age = age
#方式一：'指名道姓'地调用某一个类的函数
class Teacher(People):
def __init__(self, name, sex, age, title):
People.__init__(self, name, age, sex) #'指名道姓'地调用某一个类的函数
self.title = title
def teach(self):
print('%s is teaching' %self.name)
# obj = Teacher('lili','female', 28, '高级教师') #只会找自己类中的__init__
#
# print(obj.teach()) #lili is teaching
#方法二:super()
'''
调用super()会得到一个特殊的对象，该对象专门用来引用父类的属性，且严格按照MRO规定的顺序向后查找
'''
class Teacher(People):
def __init__(self, name, sex, age, title):
super().__init__(name, age, sex) #调用的对象的是绑定方法，自动传入self #按照Teacher.MRO列表的从 当前类(调用 super 的类)后面的父类 往后查找
self.title = title
def teach(self):
print('%s is teaching' %self.name)
obj = Teacher('lili','female', 28, '高级教师') #只会找自己类中的__init__
print(obj.teach()) #lili is teaching
注意：在python2中super 的使用需要完整地写成super（自己的类名,self）,而在python3中可以简写为super（）。
这两种方法的区别是：方式一是跟继承没有关系的，它是通过类调用函数方法，而方式二的 super()是依赖继承的，并且没有直接继承关系，super()仍然会按照 MRO 继续往后查找
关于在子类中重用父类功能的这两种方式，使用任何一种都可以，但是在最新的代码中还是推荐使用super()
案例一：
调用super()会得到一个特殊的对象，该对象会参照发起属性查找的那个类的mro,从当前类的父类中向后查找
class A:
print('from A')
super().test() #按照D.MRO列表，从当前类A往后查找（不包含类A）
class B:
def test(self):
print('from B')
class C(A,B):
def test(self):
print('from C')
obj=C()
print(C.mro())#[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
obj.test()
#结果展示
'''
from A
from B
'''
案例二：
class A:
def test(self):
print('from A')
super().test1()
def test1(self):
print('from AAA')
class B:
def test(self):
print('from B')
class C(A,B):
def test1(self):
print('from C')
obj=C() #from C
print(C.mro())#[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
obj.test()
#结果展示
'''
from A
报错：'super' object has no attribute 'test1'
'''
print(C.mro())#[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
obj.test()
#结果展示
'''
from A
报错：'super' object has no attribute 'test1'
'''
#[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
'''
报错的原因的是调用super()，它是按照调用者的.MRO列表中当前类（A）往后查A(不包含 A类)，即从 B类往后找所以找不到
'''
案例三：
class D:
def test1(self):
print('from D')
class A:
def test(self):
print('from A')
super().test1()
def test1(self):
print('from AAA')
class B:
def test(self):
print('from B')
class C(A,B,D):
def test1(self):
print('from C')
obj=C()
print(C.mro())
obj.test()
#结果展示
'''
[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.D'>, <class 'object'>]
from A
from D
'''
3.2 属性查找问题
单继承背景下的属性查找
示范一：
class Foo:
def f1(self):
print('Foo.f1')
def f2(self):
print('Foo.f2')
self.f1() # obj.f1()
class Bar(Foo):
def f1(self):
print('Bar.f1')
obj=Bar()
obj.f2()
#结果展示
'''
Foo.f2
Bar.f1
'''
示范二：想要调用的当前类的属性
class Foo:
def f1(self):
print('Foo.f1')
def f2(self):
print('Foo.f2')
Foo.f1(self) # 调用当前类中的f1
class Bar(Foo):
def f1(self):
print('Bar.f1')
obj=Bar()
obj.f2()
#结果展示
'''
Foo.f2
Foo.f1
'''
父类如果不想让子类覆盖自己的方法，可以采用双下划线开头的方法将方法设置为私有的
示范三：
class Foo:
def __f1(self): # _Foo__f1
print('Foo.f1')
def f2(self):
print('Foo.f2')
self.__f1() # self._Foo__f1,# 调用当前类中的f1
class Bar(Foo):
def __f1(self): # _Bar__f1
print('Bar.f1')
obj=Bar()
obj.f2()
#结果展示
'''
Foo.f2
Foo.f1
'''
4、多继承的菱形问题与属性查找
4.1 菱形问题介绍
大多数面向对象 1 都不支持多继承，在 python 中，一个子类时可以同时继承多个父类的，这固然可以带来一个子类可以对多个不同父类加以重用的好处，但也有可能引发菱形问题(或称钻石问题)，菱形结构如下：
#A类在顶部，B类和C类分别位于其下方，D类在底部将两者连接在一起形成菱形。
#注菱形继承（最终继承的汇集点不是 object）
#非菱形继承（最终继承的汇集点是 object）
示例一：这不是菱形继承
class A(object):
pass
class B(object):
pass
class C(A, B):
pass
#这不菱形继承，最终汇集点为 object
示例二：菱形继承
class D(object):
pass
class A(D):
pass
class B(D):
pass
class C(A, B):
pass
#这是菱形继承，最终汇集点为 类D
4.2 继承原理
对于定义的每一个类，python 都会计算出一个方法解析顺序（MRO）列表，该 MRO 列表就是一个简单的所有基类的线性顺序列表，如下：
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):
pass
obj = D()
obj.test() # 结果为：from B
print(D.mro()) # [<class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。
由类发起的属性查找准则：
1.子类会先于父类被检查
2.多个父类会根据它们在列表中的顺序被检查
由对象发起的属性查找准则：
1.由对象发起的属性查找，会从对象自身的属性里检索，没有则会按照对象的类.mro()规定的顺序依次找下去，
2.由类发起的属性查找，会按照当前类.mro()规定的顺序依次找下去，
4.3 深度优先和广度优先
1 非菱形继承下的属性查找
如果多继承是非菱形继承，经典类与新式的属性查找顺序一样：
都是按照 MRO列表中顺序来查找
class E:
def test(self):
print('from E')
class F:
def test(self):
print('from F')
class B(E):
def test(self):
#print('from B')
pass
class C(F):
def test(self):
print('from C')
class D:
def test(self):
print('from D')
class A(B, C, D):
# def test(self):
# print('from A')
pass
print(A.mro())
'''
[<class '__main__.A'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.F'>, <class '__main__.D'>, <class 'object'>]
'''
obj = A()
obj.test() # 结果为：from E
# 可依次注释上述类中的方法test来进行验证
2 菱形继承下的属性查找
经典类：深度优先，会在检索第一条分支的时候就直接一条道走到黑，即会检索大脑袋（共同的父类），此时无 object 类
注：在 python2 中，未继承 object 的类及子类，都是经典类
属性查找顺序如图所示：
当类是经典类时，多继承情况下，在要查找属性不存在时 ，会按照深度优先的凡是查找下去
示例一：经典类
class G: # 在python2中，未继承object的类及其子类，都是经典类
pass
class E(G):
pass
class F(G):
def test(self):
print('from F')
class B(E):
pass
class C(F):
def test(self):
print('from C')
class D(G):
def test(self):
print('from D')
class A(B,C,D):
pass
# 经典类：A->B->E->G->C->F->D
obj = A()
obj.test() # from C
新式类：广度优先，会在检索最后一条分支的时候检索大脑袋
属性查找顺序如下图：
当类是新式类，多继承情况下，在要查找属性不存在时，会按照广度优先的方式下查找下去
示例二：新式类
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')
pass
obj = A()
obj.test() # 如上图，查找顺序为:obj->A->B->E->C->F->D->G->object
# 可依次注释上述类中的方法test来进行验证
总结
多继承要用时，需要规避以下几个问题
1、继承结构尽量不要过于繁杂
2、推荐使用 mixins 机制：在多继承的背景下满足继承的什么'是'什么关系
二 mixins 机制
mixins机制核心：就是在多继承背景下尽可能地提升多继承的可读性
ps：让多继承满足人的思维习惯==》什么'是'什么关系
举例说明：
python 提供了 MIxins 机制，简单来说， MIxins机制指的是子类混合(mixin)不同类的功能,这些类 1 采用统一的命名规范(例如 MIxin后缀)，以此表示这些类只是用来混合功能的，并不是用来标识子类的从属"is-a"关系的（该类不是作为父类，只是提供了一种功能方法）
class Vehicle: # 交通工具 #父类
pass
class FlyableMixin: #定义功能类
def fly(self):
'''
飞行功能相应的代码
'''
print("I am flying")
class CivilAircraft(FlyableMixin, Vehicle): # 民航飞机
pass
class Helicopter(FlyableMixin, Vehicle): # 直升飞机
pass
class Car(Vehicle): # 汽车
pass
# ps: 采用某种规范（如命名规范）来解决具体的问题是python惯用的套路
可以看到，上面的CivilAircraft、Helicopter类实现了多继承，不过它继承的第一个类我们起名为FlyableMixin，它是为了会告诉后来读代码的人，这个类是一个Mixin类，表示混入(mix-in)，这种命名方式就是用来明确地告诉别人（python语言惯用的手法），这个类是作为功能添加到子类中，而不是作为父类，它的作用同Java中的接口。所以从含义上理解，CivilAircraft、Helicopter类都只是一个Vehicle(交通工具)，而不是一个飞行器。
使用 MIxin 类实现多继承注意事项：
1、首先它必须表示一个功能而非某个物品，python 对于 mixin类的命名方式一般以 Mixin，able，ible 为后缀
2、它的功能或者职责必须单一，如果需要多个功能，那就多定义些 Mixin 类，一个类可以继承多个 Mixin，为了保证遵循继承的'is-a'原则，只能继承一个标识其归属含义的父类
3、它不依赖于子类的实现
4、子类即便没有继承这个 Mixin 类，也可以正常工作，只是缺少了该部分功能
Ps:Mixins是从多个类中重用代码的好方法，但是需要付出相应的代价，我们定义的Minx类越多，子类的代码可读性就会越差。