Python中多继承super()函数的执行顺序MRO

多继承的写法有以下三种方式：

• 方式1：父类名.方法名(父类方法中的所有参数），比如：Parent.init(self, name)
• 方式2：使用super()继承，super().方法名，比如：super().init(name, *args, **kwargs)
  • 为避免多继承报错，使用不定长参数，接受参数
• 方式3：使用super(父类名, self)，比如：super(Son1, self).init(name, age, *args, **kwargs)

多继承的函数的调用顺序

• 使用方式1：直接寻找父类名里面的方法，是那个父类就调用那个父类
  • 查看001案例,使用该方法，会导致父类被多次继承，就会被执行多次
  • 下面为方式1的案例：
    • 输出结果可以发现，该爷爷类有两个子类，孙子类（继承了两个子类）执行的时候
    • 爷爷类Parent的初始化方法会被调用两次，如果有多个子类，爷爷类会调用很多次
    • 这样会占用大量的资源，此外python默认只打开1024个文件
    • 大型程序中，这种继承方法，会占用大量资源，打开大量相同的文件
    • 我们希望的结果是只调用一次即可

案例001：

class Parent(object):
    def __init__(self, name):
        print('parent的init开始被调用')
        self.name = name
        print('parent的init结束被调用')

# 新建属性age,继承属性name
class Son1(Parent):
    def __init__(self, name, age):
        print('Son1的init开始被调用')
        self.age = age
        # 继承父类中的__init__初始化方法
        Parent.__init__(self, name)
        print('Son1的init结束被调用')

# 新建属性gender,继承属性name
class Son2(Parent):
    def __init__(self, name, gender):
        print('Son2的init开始被调用')
        self.gender = gender
        # 继承父类中的__init__初始化方法
        Parent.__init__(self, name)
        print('Son2的init结束被调用')

# 继承属性name，age，gender
class Grandson(Son1, Son2):
    def __init__(self, name, age, gender):
        print('Grandson的init开始被调用')
        # 继承父类的初始化方法
        Son1.__init__(self, name, age)
        Son2.__init__(self, name, gender)
        print('Grandson的init结束被调用')

# 创建一个实例对象，初始化方法__init__会自动调用
print("方式1多继承执行顺序：由最底层向上层依次执行所有的继承")
gs = Grandson('grandson', 12, '男')

print('姓名：', gs.name)
print('年龄：', gs.age)
print('性别：', gs.gender)

print("******多继承使用类名.__init__ 发生的状态******\n\n")
           

输出结果：

方式1多继承执行顺序：由最底层向上层依次执行所有的继承
Grandson的init开始被调用
Son1的init开始被调用
parent的init开始被调用
parent的init结束被调用
Son1的init结束被调用
Son2的init开始被调用
parent的init开始被调用
parent的init结束被调用
Son2的init结束被调用
Grandson的init结束被调用
姓名： grandson
年龄： 12
性别： 男
******多继承使用类名.__init__ 发生的状态******
           

• 使用方式2：多继承使用super()，往往调用不了父类，因为python3默认里面有一个C3算法，
• C3算法用来处理多继承的调用顺序（MRO），用来保证每个类只被调用一次的算法
• 可以使用父类名.__mro__显示出该类中的super()的调用顺序，结果是一个元组，
• 里面的元素都是很多类的名称，从左到右就是调用顺序
  • 例如002案例中的：print(Grandson.mro)
  • (<class ‘main.Grandson’>, <class ‘main.Son1’>, <class ‘main.Son2’>, <class ‘main.Parent’>, <class ‘object’>)
  • 执行到super()处的时候的调用顺序：先找该类Grandson的下一个，执行Son1，然后Son1执行到里面的super()，找Son1后面的。。。。。
  • 该方法与案例001相比，每个父类都只会被调用一次

案例002

# 下面为方式2的案例：使用super()写法

class Parent(object):
    def __init__(self, name, *args, **kwargs):  # 为避免多继承报错，使用不定长参数，接受参数
        print('parent的init开始被调用')
        self.name = name
        print('parent的init结束被调用')

class Son1(Parent):
    def __init__(self, name, age, *args, **kwargs):  # 为避免多继承报错，使用不定长参数，接受参数
        print('Son1的init开始被调用')
        self.age = age
        super().__init__(name, *args, **kwargs)  # 为避免多继承报错，使用不定长参数，接受参数
        print('Son1的init结束被调用')

class Son2(Parent):
    def __init__(self, name, gender, *args, **kwargs):  # 为避免多继承报错，使用不定长参数，接受参数
        print('Son2的init开始被调用')
        self.gender = gender
        super().__init__(name, *args, **kwargs)  # 为避免多继承报错，使用不定长参数，接受参数
        print('Son2的init结束被调用')

class Grandson(Son1, Son2):
    def __init__(self, name, age, gender):
        print('Grandson的init开始被调用')
        # 多继承时，相对于使用类名.__init__方法，要把每个父类全部写一遍
        # 而super只用一句话，执行了全部父类的方法，这也是为何多继承需要全部传参的一个原因
        # super(Grandson, self).__init__(name, age, gender)
        super().__init__(name, age, gender)
        print('Grandson的init结束被调用')

print(Grandson.__mro__)

gs = Grandson('grandson', 12, '男')
print('姓名：', gs.name)
print('年龄：', gs.age)
print('性别：', gs.gender)
print("******多继承使用super().__init__ 发生的状态******\n\n")
           

输出结果：

(<class '__main__.Grandson'>, <class '__main__.Son1'>, <class '__main__.Son2'>, <class '__main__.Parent'>, <class 'object'>)
Grandson的init开始被调用
Son1的init开始被调用
Son2的init开始被调用
parent的init开始被调用
parent的init结束被调用
Son2的init结束被调用
Son1的init结束被调用
Grandson的init结束被调用
姓名： grandson
年龄： 12
性别： 男
******多继承使用super().__init__ 发生的状态******
           

• 使用方式3：类似于方式2，不过super(父类名)中已经指定了起始查找的父类名，

  • 写成super(Grandson, self).init(name, age, gender)，则找Grandson下一个开始执行，与案例002结果一样

    执行结果：

    Grandson的init开始被调用

    Son1的init开始被调用

    Son2的init开始被调用

    parent的init开始被调用

    parent的init结束被调用

    Son2的init结束被调用

    Son1的init结束被调用

    Grandson的init结束被调用

  • 写成super(Son1, self).init(name, age, *args, **kwargs), 则找Son1下一个，从Son2开始执行

    执行结果：

    Grandson的init开始被调用

    Son2的init开始被调用

    parent的init开始被调用

    parent的init结束被调用

    Son2的init结束被调用

    Grandson的init结束被调用

案例003

# 下面为方式3的案例：使用super(父类名, self)写法

class Parent(object):
    def __init__(self, name, *args, **kwargs):  # 为避免多继承报错，使用不定长参数，接受参数
        print('parent的init开始被调用')
        self.name = name
        print('parent的init结束被调用')

class Son1(Parent):
    def __init__(self, name, age, *args, **kwargs):  # 为避免多继承报错，使用不定长参数，接受参数
        print('Son1的init开始被调用')
        self.age = age
        super().__init__(name, *args, **kwargs)  # 为避免多继承报错，使用不定长参数，接受参数
        print('Son1的init结束被调用')

class Son2(Parent):
    def __init__(self, name, gender, *args, **kwargs):  # 为避免多继承报错，使用不定长参数，接受参数
        print('Son2的init开始被调用')
        self.gender = gender
        super().__init__(name, *args, **kwargs)  # 为避免多继承报错，使用不定长参数，接受参数
        print('Son2的init结束被调用')

class Grandson(Son1, Son2):
    def __init__(self, name, age, *args, **kwargs):
        print('Grandson的init开始被调用')
        # 多继承时，相对于使用类名.__init__方法，要把每个父类全部写一遍
        # 而super只用一句话，执行了全部父类的方法，这也是为何多继承需要全部传参的一个原因
        super(Son1, self).__init__(name, age, *args, **kwargs)
        print('Grandson的init结束被调用')

print(Grandson.__mro__)

gs = Grandson('grandson', 12, '男')
print('姓名：', gs.name)
print('性别：', gs.gender)
print("******多继承使用super().__init__ 发生的状态******\n\n")
           

输出结果：

(<class '__main__.Grandson'>, <class '__main__.Son1'>, <class '__main__.Son2'>, <class '__main__.Parent'>, <class 'object'>)
Grandson的init开始被调用
Son2的init开始被调用
parent的init开始被调用
parent的init结束被调用
Son2的init结束被调用
Grandson的init结束被调用
姓名： grandson
性别： 12
******多继承使用super().__init__ 发生的状态******
           

总结：

• super().__init__相对于类名.init，在单继承上用法基本无差
• 但在多继承上有区别，super方法能保证每个父类的方法只会执行一次，而使用类名的方法会导致方法被执行多次，具体看前面的输出结果
• 多继承时，使用super方法，对父类的传参数，应该是由于python中super的算法导致的原因，必须把参数全部传递，否则会报错
• 单继承时，使用super方法，则不能全部传递，只能传父类方法所需的参数，否则会报错
• 多继承时，相对于使用类名.__init__方法，要把每个父类全部写一遍, 而使用super方法，只需写一句话便执行了全部父类的方法，这也是为何多继承需要全部传参的一个原因