day24 03 多继承

day24 03 多继承

正常的代码中  单继承==减少了代码的重复

继承表达的是一种 子类是父类的关系

1、简单的多继承关系

A,B,C,D四个类，其中D类继承A,B,C三个父类，因此也叫多继承，子类方法调用的时候先找自己里面的，没有再根据就近原则逐个找父类里面的，最后没有还是会报错

class A:
    def func(self):
        print('A')
class B:
    def func(self):
        print('B')
class C:
    def func(self):
        print('C')
class D(A,B,C):  # D继承A,B,C三个类，所以叫多继承
    def func(self):
        print('D')
d = D()
d.func()  # 首先找自己里面是否有func方法，有就用自己的，没有才找父类，并且找的时候的顺序：A,B,C---就近原则

由于D类自己里面就有func方法，所以直接用自己的，所以运行结果：

D

这样简单的多继承问题，遵循的原则是：就近原则，按照D>A>B>C的顺序找

2、钻石继承问题

钻石继承关系：有四个类A,B,C,D,其中B,C都继承A,然后D继承B和C

class A:
    def func(self):print('A')  # （4）如果A里面还是找不到func函数，则会报错
class B(A):
    def func(self):print('B')  # （2）如果B里面也没有func函数，才会找到C里面的
class C(A):
    def func(self):print('C')  # （3）如果C里面还是找不到func函数，则最后才会找到A的
class D(B,C):
   def func(self):print('D')  # （1）首先先找自己本身的，如果这里没有func函数，就会根据就近原则找到B的
d = D()
d.func()  # 首先找自己里面是否有func方法，有就用自己的，没有才找父类

砖石继承问题，遵循的一般规则：

自身优先；随后就近原则（广度优先），从左往右；最后到深度，竖直写的

因为本来就知道了B和C都可以最后找到A，所以才会先D>B>C>A，如果是按照D>B>A的顺序，则不会再去找C里面的了，这样如果A里面没有，

但是C里面有需要调用的方法，就会找不到最后报错

3、漏斗形继承问题

漏斗形继承关系：有五个类：A,B,C,D,E，其中D继承B和C，B继承A，C继承E

class A:
    def func(self):print('A')  # （3）如果A里面还是找不到func函数，才会找到C
class E:
    def func(self): print('E')  # (5)如果E里面还是没有，则会报错
class B(A):
    def func(self):print('B')  # （2）如果B里面也没有func函数，就会找到A里面的
class C(E):
    def func(self):print('C')  # （4）如果C里面还是找不到func函数，则最后才会找到E的
class D(B,C):
   def func(self):print('D')  # （1）首先先找自己本身的，如果这里没有func函数，就会根据就近原则找到B的
d = D()
d.func()  # 首先找自己里面是否有func方法，有就用自己的，没有才找父类

漏斗形继承问题，遵循的一般规则：

自身优先；然后就近原则，广度优先，但是由于B和C继承的是不同的父类，所以先按D>B>A的顺序；

如果在A里面还是找不到相关的方法，才会找到C>E,最后E里面没有就会报错

如果在B里面没有找到的时候就去找C里面，则会错过了A，如果最后在E里面没有找到调用的方法，但是在A里面就有，这样就会找不到并且报错了

4、乌龟形继承问题

乌龟形继承关系：有A,B,C,D,E,F六个类，其中D继承B和C，B继承A，A继承F，C继承E，E继承F

class F:
     def func(self):print('F')  # （6）如果F里面还是找不到func函数，才会找到C
class E(F):
     def func(self): print('E')  # (5)如果E里面还是没有，则最后会找到F里面的如果还是找不到则会报错
class A(F):
     def func(self): print('A')  # （3）如果A里面还是找不到func函数，才会找到C
class B(A):
     def func(self):print('B')  # （2）如果B里面也没有func函数，就会找到A里面的
class C(E):
     def func(self):print('C')  # （4）如果C里面还是找不到func函数，则会找到E的
class D(B,C):
    def func(self):print('D')  # （1）首先先找自己本身的，如果这里没有func函数，就会根据就近原则找到B的
d = D()
d.func()  # 首先找自己里面是否有func方法，有就用自己的，没有才找父类

乌龟形继承问题，一般遵循的原则：

自身优先，找不到找父类；根据广度优先即就近原则先找B的，如果B里面没有则会找A的，而不是找C的，这里和前面的漏斗形问题一样的道理；

如果A里面也找不到则会找到C，而不是F里面的，这里和前面的砖石形问题一样的道理，因为A和E都会找到F；

如果在A没有找到的情况下，就会接着按照C>E>F的顺序找

5、mro()函数

执行以下代码，最后print(D.mro())，可以找到继承的顺序

class F:
     def func(self):print('F')  # （6）如果F里面还是找不到func函数，才会找到C
class E(F):
     def func(self): print('E')  # (5)如果E里面还是没有，则最后会找到F里面的如果还是找不到则会报错
class A(F):
     def func(self): print('A')  # （3）如果A里面还是找不到func函数，才会找到C
class B(A):
     def func(self):print('B')  # （2）如果B里面也没有func函数，就会找到A里面的
class C(E):
     def func(self):print('C')  # （4）如果C里面还是找不到func函数，则会找到E的
class D(B,C):
    def func(self):print('D')  # （1）首先先找自己本身的，如果这里没有func函数，就会根据就近原则找到B的
d = D()
d.func()  # 首先找自己里面是否有func方法，有就用自己的，没有才找父类
print(D.mro())

运行结果：

D
[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.A'>, <class '__main__.C'>, <class '__main__.E'>, <class '__main__.F'>, <class 'object'>]

6、总结

新式类（继承object类的才是新式类）继承原则：广度优先（就近原则）

经典类（如果直接创建一个类在2.7中就是经典类）继承原则：深度优先，一条线从下往上找，走到底，然后再换另一条线，走过的路就不会再走

多继承，子类的调用方法，默认就近原则

经典类中，深度优先

新式类中，广度优先

python2.7中新式类和经典类共存，新式类要继承object

python3中只有新式类，默认继承object