python中的单继承，多继承和mro顺序

python作为一门动态语言，是和c++一样支持面向对象编程的。相对对象编程有三大特性，分别是继承，封装和多态。今天我们重点讲解的是，python语言中的单继承和多继承。

继承概念：

如果一个类继承了另外一个类时，它将自动获得另一个类的所有属性和方法，那么原有的类称为父类，而新类称为子类。子类继承了其父类的所有属性和方法。同时还可以定义自己的属性和方法。
单继承就是一个子类只能继承一个父类。

格式： class 子类（父类）
举例： class A(B)
A类拥有了B类的所有的特征，A类继承了B类
B类父类，基类
A类子类派生类后代类

继承的作用：功能的升级和扩展
功能的升级就是对原有的功能进行完善重新，功能的扩展就是对原本没有的功能进行添加。减少代码的冗余。

下面我们举一个单继承的例子：

class Dog():    #父类def __init__(self):  #父类的属性初始化self.name='狗'self.leg=4def __str__(self):return "名字:%s %d 条腿"%(self.name,self.leg)class Taidi(Dog):  #定义一个Taidi 泰迪 类继承自Dog类 -->单继承passtaidi=Taidi()
print(taidi)    输出结果-->  名字:狗 4 条腿

多继承:

多继承就是一个子类同时继承自多个父类，又称菱形继承、钻石继承。

首先，我们先讲多继承中一个常见方法，单独调用父类的方法。在子类初始化的时候需要手动调用父类的初始化方法进行父类的属性的构造，不然就不能使用提供的属性。

在子类中调用父类的初始化方法格式就是：父类名._init_(self)

下面举一个单独调用父类方法的例子：

print("******多继承使用类名.__init__ 发生的状态******")
class Parent(object):   #父类def __init__(self, name):print('parent的init开始被调用')self.name = name    #属性的初始化print('parent的init结束被调用')class Son1(Parent):   #单继承 Son1子类继承父类def __init__(self, name, age):print('Son1的init开始被调用')self.age = ageParent.__init__(self, name)        #单独调用父类的属性print('Son1的init结束被调用')class Son2(Parent):  #也是单继承 Son2继承父类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', 18, '男')        #实例化对象
print('姓名：', gs.name)
print('年龄：', gs.age)
print('性别：', gs.gender)print("******多继承使用类名.__init__ 发生的状态******\n\n")

下面让我们看看运行的结果：

******多继承使用类名.__init__ 发生的状态******
Grandson的init开始被调用
Son1的init开始被调用
parent的init开始被调用
parent的init结束被调用
Son1的init结束被调用
Son2的init开始被调用
parent的init开始被调用
parent的init结束被调用
Son2的init结束被调用
Grandson的init结束被调用
姓名： grandson
年龄： 18
性别： 男
******多继承使用类名.__init__ 发生的状态******

mro顺序

查看上面的运行结果，我们发现由于多继承情况，parent类被的属性被构造了两次，如果在更加复杂的结构下可能更加严重。
为了解决这个问题，Python官方采用了一个算法将复杂结构上所有的类全部都映射到一个线性顺序上，而根据这个顺序就能够保证所有的类都会被构造一次。这个顺序就是MRO顺序。
格式：
类名._mro_()
类名.mro()

多继承中super调用有所父类的被重写的方法
super本质上就是使用MRO这个顺序去调用当前类在MRO顺序中下一个类。 super().init()则调用了下一个类的初始化方法进行构造。

print("******多继承使用super().__init__ 发生的状态******")
class Parent(object):def __init__(self, name, *args, **kwargs):  # 为避免多继承报错，使用不定长参数，接受参数print('parent的init开始被调用')self.name = nameprint('parent的init结束被调用')class Son1(Parent):def __init__(self, name, age, *args, **kwargs):  # 为避免多继承报错，使用不定长参数，接受参数print('Son1的init开始被调用')self.age = agesuper().__init__(name, *args, **kwargs)  # 为避免多继承报错，使用不定长参数，接受参数print('Son1的init结束被调用')class Son2(Parent):def __init__(self, name, gender, *args, **kwargs):  # 为避免多继承报错，使用不定长参数，接受参数print('Son2的init开始被调用')self.gender = gendersuper().__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', 18, '男')
print('姓名：', gs.name)
print('年龄：', gs.age)
print('性别：', gs.gender)
print("******多继承使用super().__init__ 发生的状态******\n\n")

查看下运行结果：

******多继承使用super().__init__ 发生的状态******
(<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
年龄： 18
性别： 男
******多继承使用super().__init__ 发生的状态******

单继承中super

print("******单继承使用super().__init__ 发生的状态******")
class Parent(object):def __init__(self, name):print('parent的init开始被调用')self.name = nameprint('parent的init结束被调用')class Son1(Parent):def __init__(self, name, age):print('Son1的init开始被调用')self.age = agesuper().__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")

运行结果：

******单继承使用super().__init__ 发生的状态******
Grandson的init开始被调用
Son1的init开始被调用
parent的init开始被调用
parent的init结束被调用
Son1的init结束被调用
Grandson的init结束被调用
姓名： grandson
年龄： 12
******单继承使用super().__init__ 发生的状态******

下面让我们总结下：

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

下面是一个简答的面试题：

class Parent(object):x = 1class Child1(Parent):passclass Child2(Parent):passprint(Parent.x, Child1.x, Child2.x)
Child1.x = 2
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