python中的继承

参考：Python类中的继承——super（包含super(子类, self).__init__()以及其他父类的方法）_不开组会的天才研究生的博客-CSDN博客_super(self).__init__()        尽量少的重复代码。继承：创建一个层次的类，子类和父类表示从属关系。共享的属性和方法可以放入一个类中。继承一个类，当子类没有自己的构造函数就会调用父类的构造函数，让实例具备父类的属性（__init__中的属性）。当调用方法时，如果子类没有自己的方法，就会调用父类的方法，当父类有自己的方法，会调用自己的方法。优先看所属的类有没有该方法，没有的情况下，往上找父类的同名方法用。当我们给子类写__init__方法，会优先调用子类的构造函数，所以在子类中用super方法，super会返回当前类的父类，写super().__init__()就会调用父类的构造函数，子类也会具有父类的属性。

 继承：

         Python中对象方法第一个参数一般都命名为self（相当于其它语言的this），用于传递对象本身，而在调用的时候则不必显式传递，系统会自动传递。super()在类的继承里面super()非常常用，它解决了子类调用父类方法的一些问题， 父类多次被调用时只执行一次， 优化了执行逻辑。

①在子类中调用父类的方法：

        存在继承关系的时候，需要在子类中调用父类的方法，最简单的方法是把对象调用转换为类调用，此时self参数需要显式传递。

语法：class 子类(父类):
                    def 子类的方法(self, 参数):
                     父类.父类的方法(self, 参数)

class A:
    def method_parent(self, msg):
        print(msg)
        return msg
 
class B(A):
    def method_child(self, msg):
        # 父类.父类的方法(self, 参数)
        A.method_parent(self, msg=msg)  # self必须写
 
 
b = B()
b.method_child(msg="Hello, class!")
 
 
"""
    Hello, class!
"""

        缺点：如果修改了父类名称，那么在子类中会涉及多处修改，另外，Python是允许多继承的语言，如上所示的方法在多继承时就需要重复写多次，显得累赘。 

为了解决以上问题，所以引入super()机制。

语法：

class 子类(父类):
        def 子类的方法(self, 参数):

                # super中的self也必须写，但父类方法中不能写self
                super(子类，self).父类的方法(self, 参数)  

class A:
    def method_parent(self, msg):
        print(msg)
        return msg
 
class B(A):
    def method_child(self, msg):
        # super(自己这个类（子类）, self).父类的方法(参数)
        super(B, self).method_parent(msg=msg)  # super中的self也必须写，但父类方法中不能写self
 
 
b = B()
b.method_child(msg="Hello, class!")

②两种方法的区别：

表面上看 super(子类, self).父类方法(参数)和父类.父类方法(self, 参数)的结果是一致的，实际上两种方法的内部处理机制不同，当涉及多继承情况时，就会表现出明显的差异来，直接给例子：

方法一：

class A:
    def __init__(self):
        print("[开始] 访问A")
        print("[结束] 访问A")
 
class B(A):
    def __init__(self):
        print("[开始] 访问B")
        A.__init__(self)
        print("[结束] 访问B")
 
class C(A):
    def __init__(self):
        print("[开始] 访问C")
        A.__init__(self)
        print("[结束] 访问C")
 
class D(A):
    def __init__(self):
        print("[开始] 访问D")
        A.__init__(self)
        print("[结束] 访问D")
 
class E(B, C, D):  # 多继承
    def __init__(self):
        print("[开始] 访问E")
        B.__init__(self)
        C.__init__(self)
        D.__init__(self)
        print("[结束] 访问E")
 
 
# 实例化类E
e = E()
 
 
"""
    [开始] 访问E
    [开始] 访问B
    [开始] 访问A
    [结束] 访问A
    [结束] 访问B
    [开始] 访问C
    [开始] 访问A
    [结束] 访问A
    [结束] 访问C
    [开始] 访问D
    [开始] 访问A
    [结束] 访问A
    [结束] 访问D
    [结束] 访问E
"""

公共父类A被执行了多次（6次）。

方法二：

class A:
    def __init__(self):
        print("[开始] 访问A")
        print("[结束] 访问A")
 
class B(A):
    def __init__(self):
        print("[开始] 访问B")
        super(B, self).__init__()
        print("[结束] 访问B")
 
class C(A):
    def __init__(self):
        print("[开始] 访问C")
        super(C, self).__init__()
        print("[结束] 访问C")
 
class D(A):
    def __init__(self):
        print("[开始] 访问D")
        super(D, self).__init__()
        print("[结束] 访问D")
 
class E(B, C, D):  # 多继承
    def __init__(self):
        print("[开始] 访问E")
        super(E, self).__init__()
        print("[结束] 访问E")
 
 
# 实例化类E
e = E()
 
 
"""
    [开始] 访问E
    [开始] 访问B
    [开始] 访问C
    [开始] 访问D
    [开始] 访问A
    [结束] 访问A
    [结束] 访问D
    [结束] 访问C
    [结束] 访问B
    [结束] 访问E
"""

        在super机制里可以保证公共父类仅被执行一次，至于执行的顺序，是按照MRO（Method Resolution Order）：方法解析顺序进行的。