Python中的（多）继承、__init__ 、__new__、super
参考：
Python构造函数使用
Python中的构造方法(__init__()与__new__())
super()的两个参数
【精】python之理解super
多继承
Python可以继承多个父类。
Python不同于Java（只能继承一个父类）。
一段简单的多继承例子如下：
S
↗ ↑ ↖
A B C
↖ ↑ ↗
D
class S(object):
def __init__(self) -> None:
pass
class A(S):
def __init__(self) -> None:
pass
class B(S):
def __init__(self) -> None:
pass
class C(S):
def __init__(self) -> None:
pass
class D(A,B,C):
def __init__(self) -> None:
pass
__init__与__new__
__new__(cls,*arg,**kwarg) -> Any用于 对象的创建。
参数
cls：指明需要创建的类class。该参数在实例化时，由Python解释器自动提供。
至少需要一个参数，变量名字可以变化。
功能： 在__new__中创建类class，并返回return。
在重写__new__方式时，调用使用super()调用父类的__new__方法即可创建对象。
class D(object):
def __init__(self) -> None:
pass
def __new__(cls) -> Any:
return super().__new__(cls)
__init__(self,*arg,**kwarg) -> None用于 对象的初始化。
参数
self：为__new__()返回的实例。同为Python解释器自动提供。
至少需要一个参数，变量名字可以变化。
功能： 在__init__中完成 类成员的初始化等，无返回值。
super
在Python2.2之后，引入了super来优化调用"父类"函数的逻辑。
但是对于多继承的情况，class D(A,B,C)，调用super()之后，到底是调用哪一个父类呢？
这里，先引入MRO表的概念。
MRO表
简单地来说，MRO(Method Resolution Order)代表了类的继承顺序。
例如，一段多继承关系如下：
S
↗ ↑ ↖
A B C
↖ ↑ ↗
D
print(D.mro()) # 获得MRO表
print(D.__mro__) # 获得MRO表
>>> [<class '__main__.D'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.S'>, <class 'object'>]
简单来说，一个MRO列表就是合并所有父类的列表，并遵循下面几点：
- 子类永远在父类的前面。
- 如果有多个父类，会根据它们在列表中的顺序去检查。
- 如果对下一个类存在两种不同的合法选择，那么选择第一个父类。
super(cls,<first argument>)
cls：类class。指明 （我们调用的是）类cls在mro表中下一个类K（的函数/成员变量）。
<first argument>：对象实例instance。作为传入该类(K)第一个参数，作为调用 函数/成员变量 的实例。一般为该对象实例self。
考虑下面继承关系，
S' S2
↗ ↑ ↖ ↑
A' B' C A2
↖ ↑ ↗
D
其中，A,B,S有`call`方法，而其他的没有。
类D、类A2的MRO表分别为：
>>> D -> A -> B -> C -> S -> object
>>> A2 -> S2 -> object
具体代码如下，
调用类D “父类”的call()方法。
class S(object):
def call(self):
print(f"S: {
self}")
class A(S):
def call(self):
print(f"A: {
self}")
class B(S):
def call(self):
print(f"B: {
self}")
class C(S):
pass
class D(A,B,C):
def __init__(self):
print(f"D: {
self}")
print("#"*20,"super(D,self).call(): ")
super(D,self).call()
print("#"*20,"super(A,self).call(): ")
super(A,self).call()
print("#"*20,"super(B,self).call(): ")
super(B,self).call()
print("#"*20,"super(C,self).call(): ")
super(C,self).call()
print("#"*20,"super(S,self).call(): ")
super(S,self).call()
X = D()
此时，输出为
D: <__main__.D object at 0x00000172F5CF56A0>
#################### super(D,self).call():
A: <__main__.D object at 0x00000172F5CF56A0>
#################### super(A,self).call():
B: <__main__.D object at 0x00000172F5CF56A0>
#################### super(B,self).call():
S: <__main__.D object at 0x00000172F5CF56A0>
#################### super(C,self).call():
S: <__main__.D object at 0x00000172F5CF56A0>
#################### super(S,self).call():
AttributeError: 'super' object has no attribute 'call'
解释：
当调用super(D,self).call()时，
实际上，我们调用了在MRO表中，D的下一个类（A）的call()方法。
当调用super(B,self).call()时，
B的下一个类（C）是没有call方法的，所以Python会继续查找下一个有call()方法的类（S）。
当调用super(S,self).call()时，
S的下一个类object没有call()方法，因为MRO表中，已经到尽头了，所以抛出异常。
注意到，调用
call()的都是D的实例。
考虑，另外一种情况
class S2(object):
def __init__(self) -> None:
print(f"S2: {
self}")
super(S2,self).__init__()
class A2(S2):
def __init__(self) -> None:
print(f"A2: {
self}")
super(A2,self).__init__()
########################################
... A,B,C,S 代码同上
class D(A,B,C):
def __init__(self):
print(f"D: {
self}")
print("#"*20,"a2 = A2():")
a2 = A2()
print("#"*20,"super(A2,a2):")
super(A2,a2).__init__()
print("#"*20)
X = D()
输出为，
D: <__main__.D object at 0x0000027D885C56A0>
#################### a2 = A2():
A2: <__main__.A2 object at 0x0000011227295FA0>
S2: <__main__.A2 object at 0x0000011227295FA0>
#################### super(A2,a2):
S2: <__main__.A2 object at 0x0000011227295FA0>
####################
解释：
在类
D中，也可以调用A2的“父类”（S2）的方法。
在a2 = A2()中，先调用A2的__init__()方法，然后，在调用S2的__init__()方法。
在super(A2,a2).__init__()中，调用的是 在MRO表中，A2的下一个类（S2）的__init__()方法。
注意到，调用
__init__()方法都是A2的实例（即a2）。
总结
在Java中，super足够明确父类。而在Python中，单单super不能明确“父类”，因此还需要引入两个参数。
在Python中，
super与父类没有实质性的关联。super(cls,instance).method()，只不过都是 在查找MRO表中 类cls的的下一个类，然后 使用实例instance调用method()而已。
特别地，
在Python3中，super()等同于super(cls,<first argument>)。
此时，
cls：为调用super()时，所处的类class。
<first argument>：为调用super()时，函数的第一个参数，一般为self。然后，这个参数作为调用方法的第一个参数（即对象实例）传递，在下面的例子中为__init__()。
例子如下：
class D(object):
def __init__(self,a,b,c):
# 下面两种方法等同
super().__init__()
super(D,self).__init__()
# 同样的，也有
class D(object):
def __init__(x,a,b,c):
# 下面两种方法等同
super().__init__()
super(D,x).__init__()
构造方法 、 __init__()、super
在Python中，概念 构造方法 与 __init__()并不相同。
在Java中，
public class B extends A{
B(){
//super()
}
}
super语句，一定在 构造方法第一行执行。
- 如果
构造函数没有定义，Java会提供默认的无参构造函数。 - 如果
super没有显式调用，Java会默认调用父类的无参构造方法super()，并在构造方法的第一行执行。 - 如果
super()没有在第一行执行，则会抛出异常。
在Python中，
class B(A):
def __init__(self):
super(B,self).__init__()
super语句，不会一定执行。
- 如果没有定义
__init__，Python会默认调用“父类”的构造函数，即super(B,self).__init__(*arg,**kwarg)，对B进行初始化。 - 如果
super没有显式调用，Python不会调用super语句，即super(B,self).__init__(*arg,**kwarg)不会执行。