python——super().__init__()

简介

简单的说super().init()，就是继承父类的init方法，同样可以使用super()去继承其他方法。

super不是关键字，而是一个类， 调用super()会创建一个super对象：

实例

单继承

class Father:
    def __init__(self,name='Tom'):
        self.name=name

class Son1(Father):
    pass

class Son2(Father):
    def __init__(self,age):
        self.age=age

class Son3(Father):
    def __init__(self,name,age):
        self.age=age
        super().__init__(name)

s1=Son1()
S2=Son2(8)
s3=Son3('John',10)

print(s1.name) #Tom
#结论：可以直接调用父类的name
print(s2.name) #报错
#结论：父类init被覆盖了，子类只添加了age，没有name
print(s3.name) #John
#结论：父类init被覆盖了，但又通过super().__init__()继承回来了

子类名称	继承内容
Son1	继承所有
Son2	继承，但覆盖了init方法
Son3	继承，但覆盖了init方法，并在init里面添加了super().init()

多继承及继承顺序

class A:
    def __init__(self):
        self.n = 2

    def add(self, m):
        # 第四步
        # 来自 D.add 中的 super
        # self == d, self.n == d.n == 5
        print('self is {0} @A.add'.format(self))
        self.n += m
        # d.n == 7


class B(A):
    def __init__(self):
        self.n = 3

    def add(self, m):
        # 第二步
        # 来自 D.add 中的 super
        # self == d, self.n == d.n == 5
        print('self is {0} @B.add'.format(self))
        # 等价于 suepr(B, self).add(m)
        # self 的 MRO 是 [D, B, C, A, object]
        # 从 B 之后的 [C, A, object] 中查找 add 方法
        super().add(m)

        # 第六步
        # d.n = 11
        self.n += 3
        # d.n = 14

class C(A):
    def __init__(self):
        self.n = 4

    def add(self, m):
        # 第三步
        # 来自 B.add 中的 super
        # self == d, self.n == d.n == 5
        print('self is {0} @C.add'.format(self))
        # 等价于 suepr(C, self).add(m)
        # self 的 MRO 是 [D, B, C, A, object]
        # 从 C 之后的 [A, object] 中查找 add 方法
        super().add(m)

        # 第五步
        # d.n = 7
        self.n += 4
        # d.n = 11


class D(B, C):
    def __init__(self):
        self.n = 5

    def add(self, m):
        # 第一步
        print('self is {0} @D.add'.format(self))
        # 等价于 super(D, self).add(m)
        # self 的 MRO 是 [D, B, C, A, object]
        # 从 D 之后的 [B, C, A, object] 中查找 add 方法
        super().add(m)

        # 第七步
        # d.n = 14
        self.n += 5
        # self.n = 19

d = D()
d.add(2)
print(d.n)

self is <main.D object at 0x10ce10e48> @D.add
self is <main.D object at 0x10ce10e48> @B.add
self is <main.D object at 0x10ce10e48> @C.add
self is <main.D object at 0x10ce10e48> @A.add
19

我们发现D继承自B, C是并列的，初始化的时候不会先把B初始化完毕才初始化C。

调用过程如下：

D.mro() == [D, B, C, A, object]
d = D()
d.n == 5
d.add(2)

class D(B, C):          class B(A):            class C(A):             class A:
    def add(self, m):       def add(self, m):      def add(self, m):       def add(self, m):
        super().add(m)  1.--->  super().add(m) 2.--->  super().add(m)  3.--->  self.n += m
        self.n += 5   <------6. self.n += 3    <----5. self.n += 4     <----4. <--|
        (14+5=19)               (11+3=14)              (7+4=11)                (5+2=7)