Day21--Python--C3算法和super()

一. python的继承. 多继承
    子类继承父类.
    为什么要继承???? 为了节省开发时间. 调高开发效率. 代码得到了重用
    在python中存在多继承

    MRO(method resolution Order) 方法路径顺序.
        python2
            1. 使用经典类(写继承关系的时候. 基类不继承object)
            2. 新式类(继承关系的根. 是object)
        python3
            只有新式类

二. 经典类的MRO
    经典类的MRO使用的是深度优先遍历

三. 新式类的MRO, C3(重点, 难点)
    新式类中摒弃了(部分)旧的深度优先算法. 使用C3算法
    如果你的继承关系中没有菱形继承( 深度优先就够了)
    如果有菱形: 使用C3算法来计算MRO
    假设C3算法. L(x) 表示 x的继承关系
    先拆分。 拆到你能看出结果为止. 反着进行merge()运算
        合并 - 归并
        merge(元组， 元组， 元组，。。。。。。。)

        摘头。
        第一个元组的头(即第一个)和第后面的元组的尾（除了第一个）在比对,如果下一个尾没有这个头, 头摘出来,然后把所有元
        组中和这个一样的类剔除如果头在后面的尾出现. 跳过该元组. 继续下一个元组的头和尾比对,直到比对完最后一个元组的
        尾, 然后返回第一个元组继续比对头,循环直到最后一个元组. 根自己匹配

class A:
    pass
class B(A):
    pass
class C(A):
    pass
class D(B, C):
    pass
class E(C, A):
    pass
class F(D, E):
    pass
class G(E):
    pass
class H(G, F):
    pass
print(H.__mro__)
# H的MRO: ??
# 拆
# L(H)= H + L(G) + L(F) -> H + (GECA) + (FDBECA) -> HGFDBECA (MRO)

# L(G) = G + L(E) -> G +(ECA) -> GECA
# L(F) = F + L(D) + L(E) -> F +(DBCA) + (ECA) -> FDBECA

# L(E) = E +  L(C) + L(A) -> E + (CA) + A -> ECA
# L(D) = D + L(B)+ L(C)  -> D + (BA) + (CA) -> DBCA

# L(c) = C + A  CA
# L(B) = B + A  BA

# L(A) = A

# 合
# + merge((B,), (A, ), 元组......)

class A:
    pass
class B(A):
    pass
class C(A):
    pass
class D(B, C):
    pass
class E(C, A):
    pass
class F(D, E):
    pass
class N:
    pass
class O:
    pass
class M(N, O):
    pass
class G(E, M):
    pass
class H(G, F):
    pass

class K(H, G, F):
    pass

print(K.__mro__)

L(K) = K + L(H) + L(G) + L(F) => K + (HGFDBMNOECA) + (GECAMNO) + (FDBECA) => KHGFDBECAMNO
L(H) = H + L(G) + L(F)      => H + (GECAMNO) + (FDBECA) => HGFDBMNOECA
L(G) = G + L(E) + L(M)      => G + (ECA) + (MNO) => GECAMNO
L(M) = M + L(N) + L(O)      => M + N + O => MNO
L(O) = O
L(N) = N
L(F) = F + L(D) + L(E)  => F + DBCA + ECA => FDBECA
L(E) = E + L(C) + L(A) => E + CA + A  => ECA
L(D) = D + L(B) + L(C)  => D + BA + CA => DBCA
L(C) = C + L(A)     => CA
L(B) = B + L(A)   => BA
L(A) = A

(HGFDBMNOECA), (GECAMNO), (FDBECA) => 边摘出来边删除元组内容

四. super是神马玩意
    super可以访问MRO列表中的下一个类中的内容. (找父类)

class Animal():
    def chi(self):
        print("吃。。。。。。。")

class Cat(Animal): # Cat Animal Base
    def chi(self): # 覆盖， 重写
        super().chi() #  可以把父类中被重写了的内容 引入进来.
        super(Cat, self).chi() # py2的
        print("吃鱼")

c = Cat()
c.chi()

用super(),将父类中的实例变量增加到子类中
class Foo:
    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c

class Bar(Foo):
    def __init__(self, a, b, c, d):
        super(Bar, self).__init__(a, b, c)
        self.d = d

b = Bar(1,2,3,4)
print(b.__dict__)

五. 一道面试题

# MRO + super ⾯试题
class Init(object):
    def __init__(self, v):
        print("init")
        self.val = v
class Add2(Init):
    def __init__(self, val):
        print("Add2")
        super(Add2, self).__init__(val)
        print(self.val)  # 5
        self.val += 2 # 7
class Mult(Init):
    def __init__(self, val):
        print("Mult")
        super(Mult, self).__init__(val)
        self.val *= 5
class HaHa(Init):
    def __init__(self, val):
        print("哈哈")
        super(HaHa, self).__init__(val)
        self.val /= 5
class Pro(Add2,Mult,HaHa): #
    pass
class Incr(Pro):
    def __init__(self, val):
        super(Incr, self).__init__(val)
        self.val += 1

print(Incr.__mro__)

# p = Incr(5)  # MRO: Incr Pro Add2 Mult HaHa Init
# # 一个对象. p :  val: 8
# print(p.val)
c = Add2(2) # MRO: ADD2 INIT
print(c.val)