在子类中调用父类的方法,可以下面的A.spam(self)的方法。
class A(object):
def spam(self):
print 'A.spam'
class B(A):
def spam(self):
print 'B.spam'
A.spam(self)
if __name__=='__main__':
b=B()
b.spam()
但是上面的代码有一个问题，如果B的父类变更了，而且有很多子类的父类都不是A了，从A变成C。那么一个个的代码工作量太大了。因此从Python2.2之后采用了super的方法。
class B(C): #相比之前的代码，只需要改动这一行代码就可以了
def spam(self):
print 'B.spam'
super(B, self).spam()
针对前面的A.spam()用法.我们再来看一个例子
class A(Base):
def __init__(self):
Base.__init__(self)
print 'A.__init__'
class B(Base):
def __init__(self):
Base.__init__(self)
print 'B.__init__'
class C(A,B):
def __init__(self):
A.__init__(self)
B.__init__(self)
print 'C.__init__' if __name__=='__main__':
c=C()
E:\python2.7.11\python.exe E:/py_prj/python_cookbook/chapter8.py
Base.__init__
A.__init__
Base.__init__
B.__init__
C.__init__
可以看到Base.__init__被调用了两次。我们将代码改写下
class Base(object):
def __init__(self):
print 'Base.__init__'
class A(Base):
def __init__(self):
super(A, self).__init__()
print 'A.__init__'
class B(Base):
def __init__(self):
super(B, self).__init__()
print 'B.__init__'
class C(A,B):
def __init__(self):
super(C, self).__init__()
print 'C.__init__'
E:\python2.7.11\python.exe E:/py_prj/python_cookbook/chapter8.py
Base.__init__
B.__init__
A.__init__
C.__init__
改成super之后，Base.__init__只被调用了一次。原因是在调用super()的时候会根据MRO列表来进行调用。Python会在MRO列表上从左到右开始查找基类。直到找到第一个匹配这个属性的类为止。通过查看__mro__可以得到MRO列表
print C.__mro__
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.Base'>, <type 'object'>)
那么什么是MRO表以及MRO表的工作原理是什么呢
MRO:Method Resolution Order. 作用在于对当前类和基类进行搜索并且确定顺序。在python中有两种类：经典类和新式类。不同之处在于新式类继承于object
先来看下经典类：
class Father():
def show_infor(self):
print 'Father.show_infor' class Child1(Father):
pass class Child2(Father):
def show_infor(self):
print 'Child2.show_infor' class GrandChildren(Child1,Child2):
pass if __name__=='__main__':
g=GrandChildren()
g.show_infor()
运行结果如下：
E:\python2.7.11\python.exe E:/py_prj/python_cookbook/chapter8.py
Father.show_infor
GrandChildren继承于Child1和Child2，Child1和Child2继承于Father。Child2以及Father都有实现show_infor的函数。但是最终只有Father的函数运行了。而Child2的并没有运行。
来看下MRO的顺序呢：
print inspect.getmro(GrandChildren)
(<class __main__.GrandChildren at 0x0166F228>, <class __main__.Child1 at 0x0164EEA0>, <class __main__.Father at 0x0164EC70>, <class __main__.Child2 at 0x0166FD88>)
顺序为GrandChildren->Child1->Father->Child2.
这个类的继承关系以及调用关系参考下图。其实真实的继承关系是GrandChildren->Child1->Father->Child2->Father.只保留重复类的第一个结果就是GrandChildren->Child1->Father->Child2. 但是这种继承关系。导致子类的Child2中的show_infor无法调用。因此这是经典类带来的问题
为了解决经典类的这个问题，就引入了新式类。还是之前的代码。唯一需要改动的是class Father(object) 在这里Father继承于object。运行结果是什么样子的呢？
E:\python2.7.11\python.exe E:/py_prj/python_cookbook/chapter8.py
Child2.show_infor
(<class '__main__.GrandChildren'>, <class '__main__.Child1'>, <class '__main__.Child2'>, <class '__main__.Father'>, <type 'object'>)
可以看到结果调用的是Child2的show_infor。最终的调用顺序为GrandChildren->Child1->Child2->Father->object.
在新式类中的调用顺序如下图。但是新式类和经典类不同的是，重复类只保留最后一个。也就是初始的调用顺序为
GrandChildren->Child1->Father->object->Child2->Father->object
由于只保留最后一个重复类，因此最终调用顺序是GrandChildren->Child1->Child2->Father->object.
新式类的调用可以使得Child2的函数得到调用。
那么新式类有问题么，也是有的。我们来看个例子：
Class x(object):pass
Class y(object):pass
Class a(x,y):pass
Class b(y,x):pass
Class c(a,b):pass
这个例子的访问顺序是c->a->x->object->y->object->b->y->object->x->object
只保留重复元素的最后一个结果为c->a->b->y->x->object.这是C的顺序
我们来看下C父类a,b的顺序：
A:a->x->y->object
B:b->y->x->object
可以看到c和a的x,y继承关系是反的，也就是说C作为子类改变了父类a的顺序。在python中子类不能改变基类的方式。如果执行如上的代码，也会报错误。
为此python2.3后采用了C3的方法。
由于C3涉及图论的方法，这里只做简要的介绍：
首先来看个列表L[C]=[c1,c2,c3..cn].其中C1为头，后面的c2,c3,cn都是尾部。C3的搜索顺序遵循如下原则：
1 检查第一个列表的头元素（如 L[B1] 的头），记作 H。
2 若 H 未出现在其它列表的尾部，则将其输出，并将其从所有列表中删除，然后回到步骤1；否则，取出下一个列表的头部记作 H，继续该步骤。
3重复上述步骤，直至列表为空或者不能再找出可以输出的元素。如果是前一种情况，则算法结束；如果是后一种情况，说明无法构建继承关系，Python 会抛出异常。
比如A的计算方式如下：
L[A] = [A] + merge(L[X], L[Y], [X], [Y]) 第一步
= [A] + merge([X, object], [Y, object], [X], [Y]) 第二步
= [A, X] + merge([object], [Y, object], [Y]) 第三步
= [A, X, Y] + merge([object], [object]) 第四步
= [A, X, Y, object]
在第三步中，由于object在[Y,object]的尾部，因此跳过此列表得到Y，并将Y从其他列表中删除。最后的结果为A,X,Y,object。对于B也是同样的过程
再来看下C的
L[C] = [C] + merge(L[A], L[B], [A], [B])
= [C] + merge([A, X, Y, object], [B, Y, X, object], [A], [B]) 1
= [C, A] + merge([X, Y, object], [B, Y, X, object], [B]) 2
= [C, A, B] + merge([X, Y, object], [Y, X, object]) 3
在第二步中，由于X存在于[B, Y, X, object]的尾部，而Y存在于merge([X, Y, object]的尾部，因此无法构建一个没有二义性的继承关系。系统报错