Python 子类调用父类的方法

本文讲述了Python实现 子类调用父类的方法。python每个类可以拥有一个或者多个父类，它们从父类那里继承了属性和方法。
如果一个方法在子类的实例中被调用，或者一个属性在子类的实例中被访问，但是该方法或属性在子类中并不存在，那么就会自动的去其父类中进行查找。
继承父类后，就能调用父类方法和访问父类属性，而要完成整个集成过程，子类需要 显式调用父类的构造函数。
如果父类构造方法初始化了一些属性，子类没有显式调用父类的构造方法，而就会出现问题。如果子类和父类都有构造函数，子类其实是重写了父类的构造函数，如果不显式调用父类构造函数，父类的构造函数就不会被执行，导致子类的实例在访问 父类构造方法中初始化的变量 时就会出现问题。

先来看看如下示例：

class A:
    def __init__(self):
        self.namea="aaa"
    def funca(self):
        print "function a : %s"%self.namea
class B(A):
    def __init__(self):
        self.nameb="bbb"
    def funcb(self):
        print "function b : %s"%self.nameb
b=B()
print b.nameb
b.funcb()
b.funca() #报错 AttributeError: B instance has no attribute 'namea'

在子类中，构造函数被重写，但新的构造方法没有任何关于初始化父类的namea属性的代码，为了达到预期的效果，
子类的构造方法必须调用其父类的构造方法来进行基本的初始化。
有两种方法能达到这个目的：调用超类构造方法的未绑定版本，或者使用super函数。
方法一：调用未绑定的超类构造方法
修改代码，多增一行：

class A:
    def __init__(self):
        self.namea="aaa"
    def funca(self):
        print "function a : %s"%self.namea
class B(A):
    def __init__(self):
        #这一行解决了问题
        A.__init__(self) #直接使用父类名称调用其构造函数
        self.nameb="bbb"
    def funcb(self):
        print "function b : %s"%self.nameb
b=B()
print b.namea,b.nameb
b.funcb()
b.funca()

运行结果：
aaa bbb
function b : bbb
function a : aaa
上边有注释的一行解决了该问题，直接使用父类名称调用其构造函数即可。这种方法叫做调用父类的未绑定的构造方法。
在调用一个实例的方法时，该方法的self参数会被自动绑定到实例上（称为绑定方法）。
但如果直接调用类的方法（比如A.__init__），那么就没有实例会被绑定。这样就可以自由的提供需要的self参数，这种方法称为未绑定unbound方法。
用当前的实例作为self参数调用未绑定方法，B类就能使用其父类构造方法的所有实现，从而namea变量被设置。
方法二：使用super函数
修改代码，这次需要增加在原来代码上修改2个地方：

class A(object):#第一处修改：父类需要继承object对象
    def __init__(self):
        self.namea="aaa"
    def funca(self):
        print "function a : %s"%self.namea
class B(A):
    def __init__(self):
        #这一行解决问题
        super(B,self).__init__()#第二处修改：通过super函数调用父类的构造方法
        self.nameb="bbb"
    def funcb(self):
        print "function b : %s"%self.nameb
b=B()
print b.namea,b.nameb
b.funcb()
b.funca()

运行结果：
aaa bbb
function b : bbb
function a : aaa
第一处修改让类A继承自object类，这样才能使用super函数，这是python的“新式类”支持的特性。
当前的类和实例可以作为super函数的参数使用，调用 super函数返回的对象 的任何方法都是调用超类的方法，
而不是当前类的方法。
super函数会返回一个super对象，这个对象负责进行方法解析，解析过程其会 自动查找所有的父类以及父类的父类。
方法一更直观，方法二可以一次初始化所有超类。
super函数最大的优点是如果子类继承了多个父类，它只需要使用一次super函数就可以。

然而如果没有这个需求，直接使用A.__init__(self)更直观一些。

方法一 VS 方法二
方法一：

class A():
    def __init__(self):
        self.a='aaa'
class B(A):
    def __init__(self):
        A.__init__(self)
        self.b='bbb'
class C(A):
    def __init__(self):
        A.__init__(self)
        self.c='ccc'
class D(A):
    def __init__(self):
        A.__init__(self)
        self.d='ddd'
class E(B,C,D):#类E继承了B，C，D 3个类，需要分别调用这3个父类的构造方法。
    def __init__(self):
        B.__init__(self)
        C.__init__(self)
        D.__init__(self)
        self.e='eee'
e=E()
print e.a,e.b,e.c,e.d,e.e

方法二：

class A(object):
    def __init__(self):
        self.a='aaa'
class B(A):
    def __init__(self):
        super(B,self).__init__()
        self.b='bbb'
class C(A):
    def __init__(self):
        super(C,self).__init__()
        self.c='ccc'
class D(A):
    def __init__(self):
        super(D,self).__init__()
        self.d='ddd'
class E(B,C,D):
    def __init__(self):
        super(E,self).__init__()#自动查找所有的父类以及父类的父类，调用一次super函数，就可以初始化所有超类。
        self.e='eee'
e=E()
print e.a,e.b,e.c,e.d,e.e

原文链接：http://www.jb51.net/article/57289.htm