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