一文讲解python中的继承冲突及继承顺序

class Animal(object):
    def __init__(self, age: int = None, gender: int = None) -> None:
        print("Call the constructor of Animal.")
        self.m_age = age
        self.m_gender = gender
        self.m_name = "Animal"
        print("Ends the call to Animal's constructer.")
        pass

    def eat(self):
        print("Animal is eating")

    def sleep(self):
        print("Animal is sleeping")


class Tiger(Animal):
    def __init__(self, age: int = None, gender: int = None) -> None:
        print("Call the constructor of Tiger.")
        self.m_name = "Tiger"
        super().__init__(age, gender)
        print("Ends the call to Tiger's constructer.")

    def eat(self):
        print("Tiger is eating")

    pass


class Lion(Animal):
    def __init__(self, age: int = None, gender: int = None) -> None:
        print("Call the constructor of Lion.")
        self.m_name = "Lion"
        super().__init__(age, gender)
        print("Ends the call to Lion's constructer.")

    def eat(self):
        print("Lion is eating")

    def sleep(self):
        print("Lion is sleeping")
    pass


class Liger(Tiger, Lion):
    def __init__(self, age: int = None, gender: int = None) -> None:
        super().__init__(age, gender)
    pass


if __name__ == '__main__':
    liger = Liger(8, 1) #实例化一个`Liger`
    print(Liger.__mro__)
    print(liger.m_name)
    liger.eat()
    liger.sleep()

class X(object):
    pass

class Y(object):
    pass


class Z(object):
    pass


class A(X, Y):
    pass


class B(Y, Z):
    pass


class M(A, B, Z):
    pass

print(M.mro())

L[A] = A+merge(L[X],L[Y],XY)
     = A + merge(XO,YO,XY) 
	 = AX + merge(O,YO,Y)
	 = AXY + merge(O,O)
	 = AXYO

L[B] = B + merge(L[Y],L[Z],YZ)
     = B + merge(YO,ZO,YZ)
     = BY + merge(O,ZO,Z)
     = BYZ + merge(O,O)
     = BYZO

L[M] = M + merge(L[A],L[B],L[Z],ABZ)
     = M + merge(AXYO,BYZO,ZO,ABZ)
     = MA + merge(XYO,BYZO,ZO,BZ)
     = MAX + merge(YO,BYZO,ZO,BZ) #第一个参数中Y被第二个参数中的Z继承，所以检查第二个参数的第一个元素即 B
     = MAXB + merge(YO,YZO,ZO,Z)
     = MAXBY + merge(O,ZO,ZO,Z) #同样，O被Z继承
     = MAXBYZ + merge(O,O,O)
     = MAXBYZO

def c3MRO(cls):
    if cls is object:
        # 讨论假设顶层基类为object，递归终止
        return [object]

    # 构造C3-MRO算法的总式，递归开始
    mergeList = [c3MRO(baseCls) for baseCls in cls.__bases__]
    mergeList.append(list(cls.__bases__))
    mro = [cls] + merge(mergeList)
    return mro


def merge(inLists):
    if not inLists:
        # 若合并的内容为空，返回空list
        # 配合下文的排除空list操作，递归终止
        return []

    # 遍历要合并的mro
    for mroList in inLists:
        # 取head
        head = mroList[0]
        # 遍历要合并的mro（与外一层相同），检查尾中是否有head
        ### 此处也遍历了被取head的mro，严格地来说不符合标准算法实现
        ### 但按照多继承中地基础规则（一个类只能被继承一次），
        ### head不可能在自己地尾中，无影响，若标准实现，反而增加开销
        for cmpList in inLists[inLists.index(mroList) + 1:]:
            if head in cmpList[1:]:
                break
        else:
            # 筛选出好head
            nextList = []
            for mergeItem in inLists:
                if head in mergeItem:
                    mergeItem.remove(head)
                if mergeItem:
                    # 排除空list
                    nextList.append(mergeItem)
            # 递归开始
            return [head] + merge(nextList)
    else:
        # 无好head，引发类型错误
        raise TypeError

class A(object):pass
class B(object):pass
class C(object):pass
class E(A,B):pass
class F(B,C):pass
class G(E,F):pass

print([i.__name__ for i in c3MRO(G)])