21--面向对象03：继承、多继承属性查找、mixins机制

1 继承

1.1 什么是继承

# 1.继承是一种创建新类的方式
  新建的类可称为子类或派生类，父类又可称为基类或超类,子类会遗传父类的属性
    
# 2.python支持多继承 
  即在Python中，新建的类可以继承一个或多个父类
  通过类的内置属性__bases__可以查看类继承的所有父类

# 3.python的多继承
    优点：子类可以同时遗传多个父类的属性，最大限度地重用代码
    缺点：
        1.违背人的思维习惯：继承表达的是一种什么"是"什么的关系
        2.代码可读性会变差
        3.不建议使用多继承，有可能会引发可恶的菱形问题，扩展性变差，
        如果真的涉及到一个子类不可避免地要重用多个父类的属性，应该使用Mixins 机制

class Parent1(object):
    x=1111

class Parent2(object):
    pass

class Sub1(Parent1): # 单继承
    pass

class Sub2(Parent1,Parent2): # 多继承
    pass

print(Sub1.__bases__)
print(Sub2.__bases__)

print(Sub1.x)

# ps1: 在python2中有经典类与新式类之分
  新式类：继承了object类的子类，以及该子类的子类子子类
  经典类：没有继承object类的子类，以及该子类的子类子子类

# ps2: 在python3中没有继承任何类，那么会默认继承object类，所以python3中所有的类都是新式类
print(Parent1.__bases__)
print(Parent2.__bases__)

1.2 为何要用继承

继承解决类与类之间代码冗余
类解决对象和对象之间代码冗余问题

1.3 如何实现继承

# 示范：
  前提：类与类之间存在代码冗余问题
    
class Student:
    school='OLDBOY'

    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    def choose_course(self):
        print('学生%s 正在选课' %self.name)


class Teacher:
    school='OLDBOY'

    def __init__(self,name,age,sex,salary,level):
        self.name=name
        self.age=age
        self.sex=sex
        self.salary=salary
        self.level=level

    def score(self):
        print('老师 %s 正在给学生打分' %self.name)


# 解决：基于继承解决类与类之间的冗余问题 
  	原理：将冗余部分提炼，建议共有父类
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)
        
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.salary = salary
        self.level = level

    def score(self):
        print('老师 %s 正在给学生打分' % self.name)
        

# 使用        
stu_obj = Student('lili', 18, 'female')
print(stu_obj.__dict__)
print(stu_obj.school)
stu_obj.choose_course()

tea_obj=Teacher('egon',18,'male',3000,10)
print(tea_obj.__dict__)
print(tea_obj.school)
tea_obj.score()

1.4 子类如何使用父类的属性

# 继承使用父类的方法：

# 方式一：通过 调用父类的函数的方式来
  故必须遵循函数调用的形式，第一个参数 self 必须填写 
    
  OldboyPeople.__init__(self,name,age,sex)

# 方式二：利用super函数()
  super().init(name,age,sex)

2 属性查找

2.1 属性查找原理

# 原理
  对于你定义的每一个类，Python都会计算出一个方法解析顺序(MRO)列表
  该MRO列表就是一个简单的所有基类的线性顺序列表
  python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止


# MRO列表：
    # MRO列表的构造是通过一个C3线性化算法来实现的
    1.子类会先于父类被检查
    2.多个父类会根据它们在列表中的顺序被检查
    3.如果对下一个类存在两个合法的选择,选择第一个父类 (左继承)
    
    
class A(object):
    # def test(self):
    #     print('from A')
    pass

class B(A):
    def test(self):
        print('from B')

class C(A):
    # def test(self):
    #     print('from C')
    pass

class D(B,C):
    # def test(self):
    #     print('from D')
    pass

print(D.mro())  # 类D以及类D的对象访问属性都是参照该类的mro列表
obj = D()
obj.test()
print(D.test)

# eg:
D.mro()  # 新式类内置了mro方法可以查看线性列表的内容，经典类没有该内置该方法
  [<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>,
   <class '__main__.A'>, <class 'object'>]
    

print(C.mro())  # 类C以及类C的对象访问属性都是参照该类的mro列表
c=C()
c.test()

# 总结：
  1.由对象发起的属性查找：会从对象自身的属性里检索，没有则会按照对象的类.mro()规定的顺序依次找下去
  2.由类发起的属性查找：会按照当前类.mro()规定的顺序依次找下去，

2.2 单继承的属性查找

# 查找原则：
    1.从对象 的属性或方法 查找；
    2.从对象 的类中 查找；
    3.从对象的类 的父类一层层 查找

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


# 若想直接调用 当前类(父类)的数据或方法时：

# 方式一：调用父类的函数 ，必须全部传参，self不能省略！
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

2.3 多继承的属性查找

2.3.1 菱形问题

# 菱形
  A类（非object类）在顶部，B类和C类分别位于其下方
  D类在底部将两者连接在一起形成菱形

# 菱形问题 (或称钻石问题 或死亡钻石)
  如果A中有一个方法，B和C都重写了该方法，而D没有重写它
  那么D继承的是哪个版本的方法：B的还是C的？

2.3.2 非菱形多继承

# 如果多继承是非菱形继承，经典类与新式类的属性查找顺序一样：
 	都是一个分支一个分支地找下去，然后最后找object
    
class E:
    # def test(self):
    #     print('from E')
    pass

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')
    pass

class D:
    def test(self):
        print('from D')


class A(B, C, D):
    # def test(self):
    #     print('from A')
    pass

# 经典类与新式类：
print(A.mro()) # A->B->E->C->F->D->object

obj = A()
obj.test() # 结果为：from F

2.3.3 菱形多继承

如果继承关系为菱形结构，那么经典类与新式类会有不同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')
    pass

obj = 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')
    pass

obj = A()
obj.test() # 如上图，查找顺序为:obj->A->B->E->C->F->D->G->object
# 可依次注释上述类中的方法test来进行验证

3 mixins机制

3.1 mixins机制介绍

# 多继承的正确打开方式：mixins机制
  mixins机制核心：就是在多继承背景下尽可能地提升多继承的可读性
# ps：让多继承满足人的思维习惯=》什么"是"什么

# 简单来说Mixins机制指的是
  子类混合(mixin)不同类的功能，而这些类采用统一的命名规范（例如Mixin后缀） 
  以此标识这些类只是用来混合功能的
  并不是用来标识子类的从属"is-a"关系的
  所以Mixins机制本质仍是多继承，但同样遵守”is-a”关系

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

class Vehicle:  # 交通工具
    pass

class FlyableMixin:
    def fly(self):
        pass

class CivilAircraft(FlyableMixin,Vehicle):  # 民航飞机
    pass

class Helicopter(FlyableMixin,Vehicle):  # 直升飞机
    pass

# 若是直接将飞行功能写在Vehicle类中
  原本汽车并不会飞，但按照上述继承关系，汽车也能飞了
class Car(Vehicle):  
    pass


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

3.2 注意事项

# 使用Mixin类实现多重继承要非常小心:
    1.它必须表示某一种功能，而不是某个物品
      python 对于mixin类的命名方式一般以 Mixin, able, ible 为后缀
        
    2.它必须责任单一，如果有多个功能，那就写多个Mixin类，
      一个类可以继承多个Mixin，为了保证遵循继承的“is-a”原则
      只能继承一个标识其归属含义的父类
    
    3.它不依赖于子类的实现
    
    4.子类即便没有继承这个Mixin类，也照样可以工作
      就是缺少了某个功能。（比如飞机照样可以载客，就是不能飞了）
        
    # 补充：通常Mixin结果的类放在左边，最前   

总结

# 多继承到底要不用？？？
    要用，但是规避几点问题
    
1.继承结构尽量不要过于复杂
2.推荐使用mixins机制：在多继承的背景下满足继承的什么"是"什么的关系