day24 03 多继承

2023-01-31 00:01:36 继承 day24

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 

相关文章