python3中的新式类mro查看和C3算法原理

两个公式
   L(object) = [object]
   L(子类(父类1, 父类2)) = [子类] + merge(L(父类1), L(父类2) , [父类1, 父类2])
注意
   + 代表合并列表
   merge算法
      1. 第一个列表的第一个元素
         是后续列表的第一个元素
         或者
         后续列表中没有再次出现
         则将这个元素合并到最终的解析列表中
并从当前操作的所有列表中删除
      2. 如果不符合，则跳过此元素，查找下一个列表的第一个元素，重复1的判断规则
      3. 如果最终无法把所有元素归并到解析列表, 则报错

# 菱形继承

class D(object):

    pass

# L(D(objecj)) = [D] + mearge(L(object), [object])

#              = [D] + mearge([object], [object])

#              = [D] + mearge([], [])

#              = [D, object]

class B(D):

    pass

# L(B(D)) = [B] + mearge(L(D), [D])

#         = [B] + mearge([D, object], [D])

#         = [B, D] + mearge([object], [])

#         = [B, D, object] + mearge([], [])

#         = [B, D, object]

class C(D):

    pass

# L(C(D)) = [C] + mearge(L(D), [D])

#         = [C] + mearge([D, object], [D])

#         = [C, D] + mearge([object], [])

#         = [C, D, object] + mearge([], [])

#         = [C, D, object]

class A(B, C):

    pass

# L(A) = [A] + mearge(L(B), L(C), [B, C])

#      = [A] + mearge([B, D, object],[C, D, object], [B, C])

#      = [A, B] + mearge([D, object],[C, D, object], [C])

#      = [A, B, C] + mearge([D, object],[D, object])

#      = [A, B, C, D] + mearge([object],[object])

#      = [A, B, C, D, object] + mearge([],[])

#      = [A, B, C, D, object]

print(A.mro())

print(A.__mro__)

import inspect

print(inspect.getmro(A))

表头 表尾
表头 列表的第一个元素
表尾 列表中表头以外的元素集合（可以为空）
[A,B,D,C] A表头 BDC 表尾
merge( [E,O], [C,E,F,O], [C] )
取出第一个列表的表头 E 所有列表的表尾  O   E F O  ''
如果E 在所有的表尾中，那么就跳过这个列表
merge( [E,O], [C,E,F,O], [C] )
第二个列表表头： C   O EFO ''  将C 单独提出
[c] + merge([E,O], [E,F,O])
mro(C) = mro(C(B,A)) = [C] + merge(mro(B),mro(A),[B,A])
mro(A) = mro(A(B,C))

# 新式类:

# class A:

#     pass

#

# class B:

#     pass

#

# class C(B,A):

#     pass

# #mro(Child(Base1，Base2)) = [ Child ] + merge( mro(Base1), mro(Base2), [ Base1, Base2] )

# # mro(C) = mro(C(B,A)) = [C] + merge(mro(B),mro(A),[B,A])

#

class O:

    def func(self):

        print('in O')

class D(O):

    pass

    # def func(self):

    #     print('in D')

class E(O):

    pass

    # def func(self):

    #     print('in E')

class F(O):

    def func(self):

        print('in F')

class B(D, E):

    pass

    # def func(self):

    #     print('in B')

# mro(B) = mro(B(D,E))

# mro(B(D,E)) = [B] + merge(mro(D),mro(E),[D,E])

# mro(B(D,E)) = [B] + merge([D,O],[E,O],[D,E])

# mro(B(D,E)) = [B,D] + merge([O],[E,O],[E])

# mro(B(D,E)) = [B,D,E] + merge([O],[O])

# mro(B(D,E)) = [B,D,E,O]

class C(E, F):

    pass

    # def func(self):

    #     print('in C')

# mro(C) = mro(C(E,F))

# mro(C(E,F)) = [C] + merge([E,O],[F,O],[E,F])

# mro(C(E,F)) = [C,E] + merge([O],[F,O],[F])

# mro(C(E,F)) = [C,E,F] + merge([O],[O])

# mro(C(E,F)) = [C,E,F,O]

class A(B, C):

    def func(self):

        super().func()

        print('in A')

# mro(A(B,C)) = [A] + merge(mro(B),mro(C),[B,C])

# mro(A(B,C)) = [A] + merge([B,D,E,O],[C,E,F,O],[B,C])

# mro(A(B,C)) = [A,B] + merge([D,E,O],[C,E,F,O],[C])

# mro(A(B,C)) = [A,B,D] + merge([E,O],[C,E,F,O],[C])

# mro(A(B,C)) = [A,B,D,C] + merge([E,O],[E,F,O])

# mro(A(B,C)) = [A,B,D,C,E] + merge([O],[F,O])

# mro(A(B,C)) = [A,B,D,C,E,F] + merge([O],[O])

# mro(A(B,C)) = [A,B,D,C,E,F,O]

obj = A()

obj.func()

# mro(A(B,C)) = [A,B,D,C,E,F,O]

print(A.__mro__)

# super 遵循mro 顺序

练习

class A:

    pass

class B(A):

    pass

class C(A):

    pass

class D(A):

    pass

class E(B,C):

    pass

class F(C,D):

    pass

class G(D):

    pass

class H(E,F):

    pass

class I(F,G):

    pass

class K(H,I):

    pass

# print(K.mro())

# print(E.mro())

# print(F.mro())

# print(G.mro())

# print(I.mro())

# print(H.mro())

'''

mro(K(H, I)) = [K] + merge(mro(H), mro(I), [H, I])

mro(K(H, I)) = [K] + merge(mro[H, E, B, F, C, D, A], [I, F, C, G, D, A], [H, I])

mro(K(H, I)) = [K, H] + merge(mro[E, B, F, C, D, A], [I, F, C, G, D, A], [I])

mro(K(H, I)) = [K, H, E, B, I] + merge(mro[F, C, D, A], [F, C, G, D, A])

mro(K(H, I)) = [K, H, E, B, I, F, ] + merge(mro[C, D, A], [C, G, D, A])

mro(K(H, I)) = [K, H, E, B, I, F, C, ] + merge(mro[D, A], [G, D, A])

mro(K(H, I)) = [K, H, E, B, I, F, C, G] + merge(mro[D, A], [D, A])

mro(K(H, I)) = [K, H, E, B, I, F, C, G, D, A]

mro(H)

mro(H(E, F)) = [H] + merge(mro(E), mro(F), [E, F])

mro(H(E, F)) = [H] + merge([E, B, C, A], [F, C, D, A], [E, F])

mro(H(E, F)) = [H, E] + merge([B, C, A], [F, C, D, A], [F])

mro(H(E, F)) = [H, E, B] + merge([C, A], [F, C, D, A], [F])

mro(H(E, F)) = [H, E, B, F] + merge([C, A], [C, D, A])

mro(H(E, F)) = [H, E, B, F, C] + merge([A], [D, A])

mro(H(E, F)) = [H, E, B, F, C, D, A]

mro(I)

mro(I(F, G)) = [I] + merge(mro(F), mro(G), [F, G])

mro(I(F, G)) = [I] + merge([F, C, D, A], [G, D, A], [F, G])

mro(I(F, G)) = [I, F] + merge([C, D, A], [G, D, A], [G])

mro(I(F, G)) = [I, F, C] + merge([D, A], [G, D, A], [G])

mro(I(F, G)) = [I, F, C] + merge([D, A], [D, A])

mro(I(F, G)) = [I, F, C, G, D] + merge([A], [A])

mro(I(F, G)) = [I, F, C, G, D, A]

mro(E)

mro(E(B, C)) = [E] + merge(mro(B), mro(C), [B, C])

mro(E(B, C)) = [E] + merge([B, A], [C, A], [B, C])

mro(E(B, C)) = [E, B] + merge([A], [C, A], [C])

mro(E(B, C)) = [E, B, C] + merge([A], [A])

mro(E(B, C)) = [E, B, C, A]

mro(F)

mro(F(C, D)) = [F] + merge(mro(C), mro(D), [C, D])

mro(F(C, D)) = [F] + merge([C, A], [D, A], [C, D])

mro(F(C, D)) = [F, C] + merge([A], [D, A], [D])

mro(F(C, D)) = [F, C, D] + merge([A], [A])

mro(F(C, D)) = [F, C, D, A]

mro(G)

mro(G(D)) = [G, D, A]

'''

巴特西

python3中的新式类mro查看和C3算法原理

最新文章

热门文章