多继承、经典类与新式类、新式类的C3算法详解

多继承
Python2版本
class A(object) ---> 新式类
class B ---> 经典类

Python3版本
默认都是新式类

经典类和新式类的不同在于多继承时继承的顺序不同
经典类 ---> 深度优先
新式类 ---> c3算法

class Immortal:

    def __init__(self):
        self.age = "长生不老"

    def fly(self):
        print("神仙都会飞")

    def eat(self):
        print("神仙也要吃东西")

class Monkey:

    def climb(self):
        print("猴子都会爬树")

    def eat(self):
        print("猴子也要进食")

class Monkey_sun(Immortal, Monkey):
    pass

sun = Monkey_sun()
sun.fly()  # 神仙都会飞
sun.climb()  # 猴子都会爬树
sun.eat()  # 神仙也要吃东西
# --->先计算Monkey_sun(Immortal, Monkey)中最左边的父类

# 前提是Python2版本
# 经典类的多继承

class A:
    pass
class B(A):
    pass
class C(A):
    pass
class D(B, C):
    pass
class E:
    pass
class F(D, E):
    pass
class G(F, D):
    pass
class H:
    pass
class Foo(H, G):
    pass

# 深度优先，从左到右，一条路走到底

 继承关系图已经有了. 那如何进⾏查找呢? 记住⼀个原则. 在经典类中采⽤的是深度优先，遍历⽅案. 什么是深度优先. 就是⼀条路走到头. 然后再回来. 继续找下⼀个.

如图看出是按照123456这样的顺序来送. 这就叫深度优先遍历.

所以上面Python2版本中的多继承的顺序为：

类的MRO:  Foo-> H -> G -> F -> E -> D -> B -> A -> C.

# 新式类的多继承
# mro序列
# MRO是一个有序列表L，在类被创建时就计算出来。

# 通用计算公式为：
# mro(Child(Base1，Base2)) = [ Child ] + merge( mro(Base1),
# mro(Base2), [ Base1, Base2] )（其中Child继承自Base1, Base2）

class A:
    pass

class B:
    pass

class C(B, A):
    pass

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

如果继承至一个基类：class B(A)
这时B的mro序列为:

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

如果继承至多个基类：class B(A1, A2, A3 …)
这时B的mro序列

mro(B) = mro( B(A1, A2, A3 …) )
= [B] + merge( mro(A1), mro(A2), mro(A3) ..., [A1, A2, A3] )
= ...

计算结果为列表，列表中至少有一个元素即类自己
如上述示例[A1,A2,A3]。merge操作是C3算法的核心。

表头和表尾
表头：
　　列表的第一个元素

表尾：
　　列表中表头以外的元素集合（可以为空）

示例
　　列表：[A, B, C]
　　表头是A，表尾是B和C

如计算merge( [E,O], [C,E,F,O], [C] )
有三个列表 ：   ①      ②        ③

1 merge不为空，取出第一个列表列表①的表头E，进行判断
各个列表的表尾分别是[O], [E,F,O]，E在这些表尾的集合中，因而跳过当前当前列表
2 取出列表②的表头C，进行判断
  C不在各个列表的集合中，因而将C拿出到merge外，并从所有表头删除
   merge( [E,O], [C,E,F,O], [C]) = [C] + merge( [E,O], [E,F,O] )
3 进行下一次新的merge操作 ......

举例：

# 上面的字母代表类
# 那么，整个多继承关系相当于下面

class O:
    pass

class D(O):
    pass

class E(O):
    pass

class F(O):
    pass

class B(D,E):
    pass

class C(E,F):
    pass

class A(B, C):
    pass

obj = A()
# 这里假设每个类中都有一个 func()，现在要算继承顺序

 下面是详细推导过程

1. 首先列出 mor 等式 (最开始，类A继承了类B和类C)
mro(A(B,C)) = [A] + merge(mro(B),mro(C),[B,C])

2. 写出 mor(B)的结果(看上面的图)
mro(B) = mro(B(D,E))---> 类B继承了类D和类E

3. 写出 mor(B(D,E)) 的等式
mro(B(D,E)) = [B] + merge(mro(D),mro(E),[D,E])

4. 把 mor(D) 和 mor(E) 的结果写出来
因为类D和类E都只继承一个类O，所以一下就能得出结果
mro(B(D,E)) = [B] + merge([D,O],[E,O],[D,E])

5. 现在开始推导 merge([D,O],[E,O],[D,E]) 的结果
首先，有三个列表，把第一个列表的表头即D取出来，
把剩下的两个列表的表头也去掉，还剩 [O] [O] [E],
这三个列表中都没有D，因此把D加到[B]，然后把列表中有D的去掉D
mro(B(D,E)) = [B,D] + merge([O],[E,O],[E])

6. 推导merge([O],[E,O],[E])，把第一个列表的表头O提出来，
三个列表还剩下 [] [O] [], 第二个列表中有O，跳过，
从 ([O],[E,O],[E]) 第二个列表开始推导，把E提出来，
三个列表还剩下 [] [O] [],都没有E，因此把E加到[B,D]
另外，把所有列表中有E的去掉
mro(B(D,E)) = [B,D,E] + merge([O],[O])

7. 剩下[O],[O]结果就直接是O了，因此最后结果如下所示
mro(B(D,E)) = [B,D,E,O]

8. 按照上面方法推导mro(C) = mro(C(E,F))，过程如下：
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]

9. 接下来算总的，方法一样
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] ---> 最终结果

上面结果即是新式类的继承顺序

# 对于继承中的 super来说，也一样
# super 也遵循 mro 顺序

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')

class C(E,F):
    # pass
    def func(self):
        print('in C')

class A(B,C):
    def func(self):
        super().func()
        print('in A')

obj = A()
obj.func()
# in B
# in A

# mro(A(B,C)) = [A,B,D,C,E,F,O]
# 根据上面的结果，如果把类B的 func() 注释掉，即结果变为
# in D
# in A

# 同理，再把类D的 func() 注释，则结果变为
# in C
# in A

# 依次类推，因此，super 也遵循 mro 顺序


# 当然，真正做项目时可以直接调用 __mro__ 方法来查询顺序
print(A.__mro__)
# (<class '__main__.A'>, <class '__main__.B'>,
# <class '__main__.D'>, <class '__main__.C'>,
# <class '__main__.E'>, <class '__main__.F'>,
# <class '__main__.O'>, <class 'object'>)