Python 方法解析顺序表MRO（多继承）

多继承以及MRO顺序

下例中，Son1类和Son2类继承Partent类，Grandson类同时继承Son1类和Son2类，均重写了init方法（Python中重载并不多）

在子类中，调用父类init方法，使用 父类名+方法名 调用（此时，需要将self当成第一个实参传递，注意参数的不同）

1. 单独调用父类的方法

# coding=utf-8

print("******多继承使用类名.__init__ 发生的状态******")
class Parent(object):
    def __init__(self, name):
        print('parent的init开始被调用')
        self.name = name
        print('parent的init结束被调用')

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

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

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结束被调用')

gs = Grandson('grandson', 12, '男')
print('姓名：', gs.name)
print('年龄：', gs.age)
print('性别：', gs.gender)

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

运行结果：

可以看到，多继承中使用指定 父类名+方法 在子类调用父类，Parent类在Son1类和Son2类中一共被调用了两次，

显然，这样虽然简洁明了，但是导致Parent类被多次调用，导致资源浪费，权衡之下，所以在多继承中不推荐这种写法

2. 多继承中super调用有所父类的被重写的方法

下例中，在子类中，调用父类init方法，使用 Super() 调用 （此时，Super()并不是简单的调用父类）

print("******多继承使用super().__init__ 发生的状态******")
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")

运行结果：

如图，Grandson类同时继承Son1类和Son2类，使用 Super() 调用父类时，并不是按照继承顺序或数量来调用对应的父类，

扫描二维码关注公众号，回复： 10162866 查看本文章

此时，Super() 会使用Python解释器中的 C3算法 （使得一个类只会被调用一次）来计算出需要调用的类，可以通过 对应类加__mro__属性 打印输出一个元组，元组中，调用Super()类的下一个元素 就是被调用的类 即，Grandson类调用了Son1类，而在Son1类中，调用了Son2类，以此类推

我们还可以使用 Super(类名, self)+方法 调用父类，和 Super()+方法 不同的是，可以指定调用的类，

如，Super(Son2, self).__init__(...)  此时通过 mro属性 可知，会调用Parent类

综上，在多继承中更推荐使用Super来调用父类

我们可以通过三种方法，在子类中调用父类方法，上例中，当我们使用Super时，由于参数的不确定性，

使用 *args 和 **kwargs  ，不定长参数

 *args 是以元组的方式保存多余参数， **kwargs 是字典的方式保存参数，接收命名参数，

   结果：   

在 test1() 中调用 test2()

  结果：  

调用test2时，传入 args 和 kwargs ，此时元组和字典都传递到 args中（此时字典，并不是命名参数） 

   结果：

当需要传什么给什么时，使用，*args  和 **kwargs，此时test2中的*args  和 **kwargs 表示 拆包（*args  和 **kwargs为实参）

3. 单继承中super

在单继承中，Supe() 和 类名+方法 效果相同

print("******单继承使用super().__init__ 发生的状态******")
class Parent(object):
    def __init__(self, name):
        print('parent的init开始被调用')
        self.name = name
        print('parent的init结束被调用')

class Son1(Parent):
    def __init__(self, name, age):
        print('Son1的init开始被调用')
        self.age = age
        super().__init__(name)  # 单继承不能提供全部参数
        print('Son1的init结束被调用')

class Grandson(Son1):
    def __init__(self, name, age, gender):
        print('Grandson的init开始被调用')
        super().__init__(name, age)  # 单继承不能提供全部参数
        print('Grandson的init结束被调用')

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

总结

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

以下的代码的输出将是什么? 

class Parent(object):
    x = 1   # 类变量

class Child1(Parent):
    pass

class Child2(Parent):
    pass

print(Parent.x, Child1.x, Child2.x)
Child1.x = 2  # 在 Child1类中 中定义了 x 变量 （重写）
print(Parent.x, Child1.x, Child2.x)
Parent.x = 3
print(Parent.x, Child1.x, Child2.x)

答案, 以上代码的输出是：

1 1 1
1 2 1
3 2 3

使你困惑或是惊奇的是关于最后一行的输出是 3 2 3 而不是 3 2 1。为什么改变了 Parent.x 的值还会改变 Child2.x 的值，但是同时 Child1.x 值却没有改变？

这个答案的关键是，继承不是复制，在 Python 中，类变量在内部是作为字典处理的。如果一个变量的名字没有在当前类的字典中发现，将搜索祖先类（比如父类）直到被引用的变量名被找到（如果这个被 引用的变量名既没有在自己所在的类又没有在祖先类中找到，会引发一个 AttributeError 异常 ）。

因此，在父类中设置 x = 1 会使得类变量 x 在引用该类和其任何子类中的值为 1。这就是因为第一个 print 语句的输出是 1 1 1。

随后，如果任何它的子类重写了该值（例如，我们执行语句 Child1.x = 2），然后，该值仅仅在子类中被改变。这就是为什么第二个 print 语句的输出是 1 2 1。

最后，如果该值在父类中被改变（例如，我们执行语句 Parent.x = 3），这个改变会影响到任何未重写该值的子类当中的值（在这个示例中被影响的子类是 Child2）。这就是为什么第三个 print 输出是 3 2 3。