Python继承特性

Python支持多重继承，多重继承会出现一个问题：钻石型继承场景下的基类调用顺序和方法重载解析，多重继承可以解决接口实现机制。下面将详细介绍这种方式。

Python是一门支持多继承的动态语言，这样在继承链的解析顺序时，需将多继承形成的图进行线性化，最后通过该线性化的顺序来决定调用的方法名称。

Python语言关于继承的算法如下：

L(C(X1,…,Xn)):类C的继承序列

L(C(X1,…,Xn)) = C ∪ Merge(L(X1),L(X2),…，L(Xn),X1,…,Xn)

Merge函数定义如下：

Merge(L(X1),L(X2),…，L(Xn),X1,…,Xn):选择一个Xi满足以下条件：

i必须为继承链中的头元素且未出现在其他L(Xi)的尾部；

 如满足条件1，输出Xi，并删除该元素继续执行条件1；否则抛出异常

不同的是类A，B继承顺序不一样，实现代码如下：

class X(object):
    def show(self):
        print("X::show()")

class Y(object):
    def show(self):
        print("Y::show()")

class A(X,Y):
    def show(self):
        print("A::show()")

class B(Y,X):
    def show(self):
        print("B::show()")

class C(A,B):
    pass


if __name__ == "__main__":
    c = C()
    c.show()
print(c.__mro__)

 计算继承链如下：

L(X) = {object}
L(Y) = {object}
L(A(X,Y)) = A ∪ Merge(L(X),L(Y),X,Y)
  = {A} ∪ Merge(X,Y,{object},{object}})
  = {A,X,Y,object}
L(B(Y,X)) = B ∪ Merge(L(Y),L(X),Y,X)
   = {B} ∪ Merge(Y,X,{object},{ object})
   = {B,Y,X,object}
L(C(A,B)) = C ∪ Merge(L(A),L(B),A,B)
   = {C} ∪ Merge({A,X,Y,object},{B,Y,X,object},A,B)
   = {C,A,B} ∪ Merge({X,Y,object},{Y,X,object})

 多重继承情况下，在构造函数初始化时，采用super()方式来进行构造，如采用类名调用将导致同一构造函数多次继承多次被调用，且调用顺序取决于显示调用顺序。

class X(object):
    def __init__(self):
        super().__init__()
        print("X::init")
        self.value = 1

class Y(object):
    def __init__(self):
        super().__init__()
        print("Y::init")
        self.value = 2


class A(X,Y):
def __init__(self):
  //不建议采用X.__init__(self)、Y.__init__(self)
        super().__init__()
        print("A::init")
        self.value = 3

class B(Y,X):
    def __init__(self):
        super().__init__()
        print("B::init")
        self.value = 4


class C(B):
    def __init__(self):
        super().__init__()
        print("C::init")
        self.value = 5