多继承以及MRO顺序

 class A:
     def test(self):
         print("A --- test方法")

     def demo(self):
         print("A --- demo方法")

 class B:
     def test(self):
         print("B --- test方法")

     def demo(self):
         print("B --- demo方法")

 class C(A,B):
     pass

 c = C()
 print(dir(c)) #dir()显示该类中所有的方法和属性
 c.test()
 c.demo()
 print(C.__mro__)  #向上查询顺序

['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'demo', 'test']
A --- test方法
A --- demo方法
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

　　

单个调用父类的方法：

 # 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")

结果：

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

　　

父类会被多次调用，浪费大量的资源

MRO和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根据C3算法，每个类只调用一遍
         # super(Grandson, self).__init__(name, age, gender) Grandson可以换成Son1或者其他，即 可以跳到指定的位置向上查询
         super().__init__(name, age, gender)  # 默认从Grandson开始查找MRO向上顺序
         print('Grandson的init结束被调用')

 print(Grandson.__mro__)

 gs = Grandson('grandson', 12, '男')
 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
年龄： 12
性别： 男
******多继承使用super().__init__ 发生的状态******

　　

super总结：

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