多继承以及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() 调用父类时,并不是按照继承顺序或数量来调用对应的父类,
此时,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")
总结
- super().__init__相对于类名.__init__,在单继承上用法基本无差
- 但在多继承上有区别,super方法能保证每个父类的方法只会执行一次,而使用类名的方法会导致方法被执行多次,具体看前面的输出结果
- 多继承时,使用super方法,对父类的传参数,应该是由于python中super的算法导致的原因,必须把参数全部传递,否则会报错
- 单继承时,使用super方法,则不能全部传递,只能传父类方法所需的参数,否则会报错
- 多继承时,相对于使用类名.__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。