python学习笔记 day24 多继承

1.新式类中多继承----经典的钻石问题

一个类可以继承多个类，一个类也可以被多个类继承，被继承的类又称为父类，基类或超类；继承父类的类叫子类或派生类；

一个类在继承多个类时，默认是就近原则，顺序就是在新式类中是广度优先原则；在经典类中是深度优先原则；

（python3版本中的类都是新式类，python2版本中的类既包括新式类也有经典类，区别是python2版本中的新式类都是继承自Object的）

1. 先看一个多继承的例子：

class A():
    def func(self):
        print("A")
class B(A):
    def func(self):
        print('B')
class C(A):
    def func(self):
        print("C")
class D(B,A):
    def func(self):
        print('D')
d=D()
d.func()

运行结果：

这很明显，虽然D这个类继承了B C但是当实例化D时，对象调用func()方法，但是我自己的类中就有的话当然用自己的~

2. 当D()这个类中没有func()方法呢，会调用谁呢~

class A():
    def func(self):
        print("A")
class B(A):
    def func(self):
        print('B')
class C(A):
    def func(self):
        print("C")
class D(B,C):
    pass
    # def func(self):
    #     print('D')
d=D()
d.func()

运行结果：

因为D()自己的类中没有func()方法，就去父类中找，原则是就近原则，所以会去B这个父类中查找

3.当B()类中也没有func()方法呢，又会先调用谁呢~

class A():
    def func(self):
        print("A")
class B(A):
    pass
    # def func(self):
    #     print('B')
class C(A):
    def func(self):
        print("C")
class D(B,C):
    pass
    # def func(self):
    #     print('D')
d=D()
d.func()

运行结果：

由于D()这个类继承自B C 自己的类中没有func()方法，就去父类B中找，但是B中也没有func()方法，虽然B继承自A 但是此时并没有一直沿着B去找A 这个爷爷类，而是去找了D的另一个父类C ，然后调用C类中的func()方法（这里之所以不去找A是因为广度优先遍历，知道A这个节点 后续也会由C到达A 所以走到B之后直接走的C）（其实最后当C中也找不到相应的方法时就去A中查找；）

4. 当C()这个类中也没有func()方法时，就去调用A中的方法：

class A():
    def func(self):
        print("A")
class B(A):
    pass
    # def func(self):
    #     print('B')
class C(A):
    pass
    # def func(self):
    #     print("C")
class D(B,C):
    pass
    # def func(self):
    #     print('D')
d=D()
d.func()

运行结果：

上面就是经典的多继承中的钻石问题（是这样叫吧）画一下图，表示继承顺序：

为啥走到B之后不先走A 而是先走C呢 就是因为它知道A这个节点，后续通过C也能到达

其实我们可以根据子类名.mro()方法查看该子类调用父类时的继承顺序：

print(D.mro())

2.新式类中多继承----小乌龟

class F():
    def func(self):
        print("F")
class A(F):
    def func(self):
        print("A")
class E(F):
    def func(self):
        print("E")
class B(A):
    def func(self):
        print('B')
class C(E):
    pass
    def func(self):
        print("C")
class D(B,C):
    pass
    def func(self):
        print('D')
d=D()
d.func()

我们按照上面的方法依次注释掉类中相应的方法，然后观察继承顺序：
发现是  D----> B----->A--->C-----E----->F

画一下流程图：

首先当D中有相应的方法时，我们肯定优先调用D类中的方法，如果D中没有相应的方法我们才去D的父类中去查找相应的方法，B C 都是父类，但是按照广度优先，应该先走B 然后当B中没有相应的方法时，应该是走B的父类A 还是走D的父类C呢，其实是应该走A的，因为A如果这个时刻不走的话，走其他节点是无论如何都到不了A的，所以先走A ，然后接下来是走A的父类F还是走D的父类C呢，其实应该走C 因为你发现这个时候不走F 后面仍然有其他途径可以到达F呀，所以此时先走C 然后走E 最后走F

以上就是新式类中的多继承的继承顺序，就是默认就近原则，顺序是广度优先；而python3中的类都是新式类；python2中既有新式类（继承自Object）也有经典类；

 那对于经典类的多继承继承顺序应该是深度优先！！

3.经典类中钻石问题：

经典类中多继承是深度优先，就是在找父类的过程中是沿着一条路走到黑，深度优先

 

4.经典类中小乌龟问题：

 

5.多继承中的super()：

 子类名.mro()方法可以查看子类继承父类的继承顺序，只可以在新式类中使用；super()方法只可以在python3中的新式类中使用！！

单继承时，我们提到过在子类中的初始化方法__init__(self,子类中的对象属性)中如果还想使用父类中的相关属性，有两种方法：

1. 父类名.__init__(self,父类中相应的对象属性) 这里的self对象就是代表子类实例化的对象，是必须要传的参数；

2.super().__init__(父类中的对象属性)，这时候super().__init__()这个方法中是不需要传入self参数的（因为super()__init__(父类中的对象属性)中的super()其实就是super(子类名，self)）

单继承时如果自己实现了一个与父类重名的方法，我们如果想在子类的该重名方法中使用父类的该重名方法 也有两种方法：

1. 父类名.方法(self,方法中的其他参数)，这里的self参数也是必须要传的；

2.super().方法名(方法中的其他参数)  这时候是不需要传self参数------》这里是在子类的重名方法内这样写（子类方法中的super()是没有参数的 ，其实是super(子类名,self)省略了而已），当然也可以在类外部写：super(子类名，子类实例化对象).方法名(方法的其他参数)

现在要讲一种在多继承中使用super() 代表的其实不是父类了，在多继承中，super()的本质已经不是直接找父类，而是根据调用者的节点位置的广度优先顺序查找的，谁在下一个顺序，谁就是super()

class A():
    def func(self):
        print("A")
class B(A):
    def func(self):
        super().func()
        print("B")
class C(A):
    def func(self):
        super().func()
        print("C")
class D(B,C):
    def func(self):
        super().func()
        print("D")
d=D()
d.func()

运行结果：

原因就是，super()的本质不是直接找父类，而是根据调用者（这里是d=D() 是D类的实例化对象）节点位置的广度优先顺序（上面已经分析了 在新式类（因为super()只用在新式类）中多继承的继承顺序是广度优先，应该是D,B,C,A）所以首先d.func()执行的D类中定义的func()函数，先执行里面的super().func()，super()指的是B 也就是去执行B.func() 发现B.func()中 也有super().func() 这里的super()指的不是父类，而是调用者节点位置的广度优先顺序，B之后应该是C节点，所以B.func()这里的super().func()就是去执行C.func() ，C.func()函数中的super().func()指的就是A.func() 所以先输出A，，然后C 然后B 最后D；