主要整理自:
https://www.runoob.com/python/python-func-super.html
https://blog.csdn.net/come_from_pluto
https://blog.csdn.net/yangjiajia123456?type=blog
1 super()函数 描述
-
super() 函数是用于调用父类(超类)的一个方法。
-
super() 是用来解决多重继承问题的,直接用类名调用父类方法在使用单继承的时候没问题,但是如果使用多继承,会涉及到查找顺序(MRO)、重复调用(钻石继承)等种种问题。
1.1 MRO
1.1.1 MRO 概念
- MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。
1.1.2 人工计算MRO
下面,以如下代码为例,人工计算MRO(并不是C3算法的逻辑,只是为了算出MRO):
class F:
pass
class E:
pass
class D:
pass
class B(D,E):
pass
class C(D,F):
pass
class A(B,C):
pass
-
画继承顺序图
原则:遇到多继承则按代码中继承列表的顺序从左往右写。如果有多个子类继承了同一个父类,那么这个父类则放在它能够出现的所有位置中最左的位置(注意:如下图中那样,D既可以放在B的左上方,又可以放在C的左上方,这种情况下,我们选择放在B的左上方,因为这样D在其所在层更加靠左),然后让这些子类指向它,就像下图中类D那样。
P.S.
A先继承B,后继承C。所以B在C的左边。
B继承了D和E,C继承了D和F。B和C都继承了D,D写在哪里呢?
答案是:D要写在B的左上角。P.P.S.
在python中,任何类默认都是继承自object类的,所以让最上层的D、E、F指向object。当然,你也可以选择在画图的时候将A,B,C等等所有类都画一个指向object的箭头,但随着以下方法的进行,其实这两种画法结果是一样的。 -
计算MRO表
需遵循图里面的广度优先原则进行遍历(广度优先原则:优先遍历左边的):
首先寻找整个图中入度为0的,也就是A,那么A也就成为MRO中的第一个。
然后我们去掉图中的A节点以及与A相关的连线,再寻找入度为0的点,这时有B和C两个节点,我们选择最左边的点即B。选完左边的B点后,再选右边的C点,这样B和C也就跟着进入了MRO序列,现在MRO序列为{A,B,C}。(注意每次层次遍历一定要把那一层选完才能选下一层,不能在没有选C之前跳到选E)
然后去掉B和C以及与它们相关的连线,这时候入度为0的也就是D、E、F了,依次选择,使D、E、F进入MRO序列。
最后也就使得object进入MRO序列。
以上的MRO序列也就是{A,B,C,D,E,F,object}
P.S. 什么是出度与入度?
在有向图中,箭头是具有方向的,从一个顶点指向另一个顶点,这样一来,每个顶点被指向的箭头个数,就是它的入度。从这个顶点指出去的箭头个数,就是它的出度
1.1.3 怎么查阅某个类的MRO表
使用 类名.mro()可以查阅其MRO表:
1.2 重复调用(钻石继承)
如果子类继承自两个单独的超类,而那两个超类又继承自同一个公共基类,那么就构成了钻石继承体系。这种继承体系很像竖立的菱形,也称作菱形继承。
经典的菱形继承案例,B、C继承A,然后D继承B、C:
2 super()函数 语法
super(type[, object-or-type])
参数:
- type – 类。
- object-or-type – 类,一般是 self
Python 3 可以直接使用 super().xxx 代替 super(Class, self).xxx:
# python 2.x
class A(object): # Python2.x 记得继承 object
def add(self, x):
y = x+1
print(y)
class B(A):
def add(self, x):
super(B, self).add(x)
b = B()
b.add(2) # 3
# python 3.x
class A:
def add(self, x):
y = x+1
print(y)
class B(A):
def add(self, x):
super().add(x)
b = B()
b.add(2) # 3
3 super()函数 实例
例1
class A:
def __init__(self):
print("Enter A")
print(self) # this will print <__main__.D object at 0x...>
print("Leave A")
class B(A):
def __init__(self):
print("Enter B")
print(self) # this will print <__main__.D object at 0x...>
super(B, self).__init__()
print("Leave B")
class C(A):
def __init__(self):
print("Enter C")
print(self) # this will print <__main__.D object at 0x...>
super(C, self).__init__()
print("Leave C")
class D(B, C):
def __init__(self):
print("Enter D")
print(self) # this will print <__main__.D object at 0x...>
super(D, self).__init__()
print("Leave D")
d = D()
运行结果:
Enter D
<__main__.D object at 0x7fdb02618490>
Enter B
<__main__.D object at 0x7fdb02618490>
Enter C
<__main__.D object at 0x7fdb02618490>
Enter A
<__main__.D object at 0x7fdb02618490>
Leave A
Leave C
Leave B
Leave D
1.创建 D 类的对象 d 时,自动调用 D 类的初始化方法 init(),此时的 self 指向 D 类创建的实例对象 d;
2.MRO:D->B->C->A
D.mro()
# [__main__.D, __main__.B, __main__.C, __main__.A, object]
3.在调用到 B 时,首先输出 “Enter B”,但是运行到父类 A 的初始化方法时不立即调用,反而时转向广度优先级高的 C 类,因为 A 类对于 B 类来说是深度遍历。
P.S.
super(). _init_()这个功能,应该是去调用父类的构造方法。
到了super(D, self)._init_()语句,D的父类是B和C,先调用B类的构造方法。先打印一个"Enter B",然后打印self。
到了super(B, self)._init_(),为了避免重复引用,先不执行,按照MRO的顺序去继续找—>找到C类。
同样,打印一个"Enter C",然后打印self。
到了super(C, self)._init_(),也还是先不执行,跑去A类。
A没有调用其他的构造方法,打印"Enter A",打印self,然后打印"Leave A"。
回到C类,打印"Leave C"。
回到B类,打印"Leave B"。
回到D类,打印"Leave D"。
P.P.S
可以理解为:在多继承里面,查找顺序是MRO,但是真正完成各个构造方法(_init_)的顺序却是MRO的相反顺序。如这个例子里面,MRO是D、B、C、A,但完成顺序是"Leave A"、“Leave C”、“Leave B”、“Leave D”。
下面的例子可以更具体地感受一下这个逻辑:
例2
class Base:
def __init__(self, value):
self.value = value
class One(Base):
def __init__(self, value):
Base.__init__(self, value)
self.value *= 2
class Two(Base):
def __init__(self, value):
Base.__init__(self, value)
self.value += 3
class Ways(One, Two):
def __init__(self, value):
One.__init__(self, value)
Two.__init__(self, value)
foo = Ways(5)
print(foo.value)
8
我们认为它会输出13,但结果却是8,因为在调用第二个超类时,即Two.init,它会再次调用Base.init,从而导致self.value重新变成5。
解决这个问题的方式是使用super方法,根据方法解析顺序(MRO)以标准化的流程来安排超类之间的初始化顺序,它也能够保证钻石顶部的公共基类的__init__方法只运行一次。
于是加入super(),修改为:
class Base:
def __init__(self, value):
self.value = value
class One(Base):
def __init__(self, value):
super(One, self).__init__(value)
self.value *= 2
class Two(Base):
def __init__(self, value):
super(Two, self).__init__(value)
self.value += 3
class Ways(One, Two):
def __init__(self, value):
super(Ways, self).__init__(value)
foo = Ways(5)
print(foo.value)
16
这是怎么回事?为何和我们设想的刚好相反。应该先运行One.init,然后运行Two.init。但实际却不一样,程序的运行会与Ways的MRO顺序保持一致。调用Ways(5)时,它会调用One.init,One.__init__又调用Two.init,Two.__init__在调用Base.init。到达了钻石继承的顶端,所有的初始化方法会按照与刚才那些__init__相反的顺序完成。
再次进行修改:
class Base:
def __init__(self, value):
self.value = value
class One(Base):
def __init__(self, value):
super(One, self).__init__(value * 2)
class Two(Base):
def __init__(self, value):
super(Two, self).__init__(value + 3)
class Ways(One, Two):
def __init__(self, value):
super(Ways, self).__init__(value)
foo = Ways(5)
print(foo.value)
13
这样做问题就解决了。
例3
再感受一下:
class A():
def __init__(self):
print('enter A')
print('leave A')
class B(A):
def __init__(self):
print('enter B')
super().__init__()
print('leave B')
class C(A):
def __init__(self):
print('enter C')
super().__init__()
print('leave C')
class D(B, C):
def __init__(self):
print('enter D')
super().__init__()
print('leave D')
d = D()
执行结果是:
enter D
enter B
enter C
enter A
leave A
leave C
leave B
leave D
例4
class FooParent(object):
def __init__(self):
self.parent = 'I\'m the parent.'
print ('Parent')
def bar(self,message):
print ("%s from Parent" % message)
class FooChild(FooParent):
def __init__(self):
# super(FooChild,self) 首先找到 FooChild 的父类(就是类 FooParent),然后把类 FooChild 的对象转换为类 FooParent 的对象
super(FooChild,self).__init__()
print ('Child')
def bar(self,message):
super(FooChild, self).bar(message)
print ('Child bar fuction')
print (self.parent)
if __name__ == '__main__':
fooChild = FooChild()
fooChild.bar('HelloWorld')
执行结果:
Parent
Child
HelloWorld from Parent
Child bar fuction
I'm the parent.
例5
没有继承父类的构造方法,没有继承父类的实例属性:
class Bird:
def __init__(self):
self.hungry = True
def eat(self):
if self.hungry:
print ('Ahahahah')
else:
print ('No thanks!')
class SongBird(Bird):
def __init__(self):
self.sound = 'Squawk'
def sing(self):
print (self.sound)
sb = SongBird()
sb.sing() # 能正常输出
sb.eat() # 报错,因为 songgird 中没有 hungry 特性
解决这个问题的办法有两种:
1、调用未绑定的超类构造方法(多用于旧版 python 阵营)
class Bird:
def __init__(self):
self.hungry = True
def eat(self):
if self.hungry:
print ('Ahahahah')
else:
print ('No thanks!')
class SongBird(Bird):
def __init__(self):
Bird.__init__(self)
self.sound = 'Squawk'
def sing(self):
print (self.sound)
sb = SongBird()
sb.sing()
sb.eat()
原理:在调用了一个实例的方法时,该方法的self参数会自动绑定到实例上(称为绑定方法);如果直接调用类的方法(比如Bird.init),那么就没有实例会被绑定,可以自由提供需要的self参数(未绑定方法)。
2、使用super函数(只在新式类中有用)
class Bird:
def __init__(self):
self.hungry = True
def eat(self):
if self.hungry:
print ('Ahahahah')
else:
print ('No thanks!')
class SongBird(Bird):
def __init__(self):
super(SongBird,self).__init__()
self.sound = 'Squawk'
def sing(self):
print(self.sound)
sb = SongBird()
sb.sing()
sb.eat()
原理:它会查找所有的超类,以及超类的超类,直到找到所需的特性为止。