继承和多态

继承

在面向对象编程中，当我们已经创建了一个类，而又想再创建一个与之相似的类，比如添加几个方法，或者修改原来的方法，这时我们不必从头开始，可以从原来的类派生出一个新的类，我们把原来的类称为父类或基类，而派生出的类称为子类，子类继承了父类的所有数据和方法。让我们看一个简单的例子，首先我们定义一个Animal类：

class Animal(object):
    def __init__(self, name):
        self.name = name
    def greet(self):
        print 'Hello, I am %s.' % self.name

现在，我们想创建一个Dog类，比如：

class Dog(object):
    def __init__(self, name):
        self.name = name
    def greet(self):
        print 'WangWang.., I am %s. ' % self.name

可以看到，Dog类和Animal类几乎是一样的，只是 greet 方法不一样，我们完全没必要创建一个新的类，而是从Animal类派生出一个新的类：

class Dog(Animal):
    def greet(self):
        print 'WangWang.., I am %s. ' % self.name

Dog类是从Animal类继承而来的，Dog类自动获得了Animal类的所有数据和方法，而且还可以对父类的方法进行修改，我们看看使用：

>>> animal = Animal('animal')  # 创建 animal 实例
>>> animal.greet()
Hello, I am animal.
>>>
>>> dog = Dog('dog')        # 创建 dog 实例
>>> dog.greet()
WangWang.., I am dog.

我们还可以对Dog类添加新的方法：

class Dog(Animal):
    def greet(self):
        print 'WangWang.., I am %s. ' % self.name
    def run(self):
        print 'I am running.I am running'

使用：

>>> dog = Dog('dog')
>>> dog.greet()
WangWang.., I am dog.
>>> dog.run()
I am running

多态

多态的概念其实不难理解，它是指对不同类型的变量进行相同的操作，它会根据对象（或类）类型的不同而表现出不同的行为。

class Animal(object):
def **init**(self, name):
self.name = name
def greet(self):
print 'Hello, I am %s.' % self.name

class Dog(Animal):
def greet(self):
print 'WangWang.., I am %s.' % self.name

class Cat(Animal):
def greet(self):
print 'MiaoMiao.., I am %s' % self.name

def hello(animal):
animal.greet()

看看多态的使用：

>>> dog = Dog('dog')
>>> hello(dog)
WangWang.., I am dog.
>>>
>>> cat = Cat('cat')
>>> hello(cat)
MiaoMiao.., I am cat

可以看到，cat 和 dog 是两个不同的对象，对它们调用 greet 方法，它们会自动调用实际类型的 greet 方法，作出不同的响应。这就是多态的魅力。

super

在类的继承中，如果重定义某个方法，该方法会覆盖父类的同名方法，但有时，我们希望能同时实现父类的功能，这时，我们就需要调用父类的方法了，可通过使用super来实现，比如：

class Animal(object):
    def __init__(self, name):
        self.name = name
    def greet(self):
        print 'Hello, I am %s.' % self.name

class Dog(Animal):
    def greet(self):
        super(Dog, self).greet()   # Python3 可使用 super().greet()
        print 'WangWang...'

在上面，Animal是父类，Dog是子类，我们在Dog类重定义了 greet 方法，为了能同时实现父类的功能，我们又调用了父类的方法，看下面的使用：

>>> dog = Dog('dog')
>>> dog.greet()
Hello, I am dog.
WangWang..

super 的一个最常见用法可以说是在子类中调用父类的初始化方法了，比如：

class Base(object):
    def __init__(self, a, b):
        self.a = a
        self.b = b

class A(Base):
    def __init__(self, a, b, c):
        super(A, self).__init__(a, b)  # Python3 可使用 super().__init__(a, b)
        self.c = c

MRO列表

事实上，对于你定义的每一个类，Python会计算出一个方法解析顺序（Method Resolution Order, MRO）列表，它代表了类继承的顺序，我们可以使用下面的方式获得某个类的MRO列表：

>>> C.mro()   # or C.__mro__ or C().__class__.mro()
[__main__.C, __main__.A, __main__.B, __main__.Base, object]

那这个MRO列表的顺序是怎么定的呢，它是通过一个 C3线性化算法来实现的，这里我们就不去深究这个算法了，感兴趣的读者可以自己去了解一下，总的来说，一个类的MRO列表就是合并所有父类的MRO列表，并遵循以下三条原则：

子类永远在父类前面
如果有多个父类，会根据它们在列表中的顺序被检查
如果对下一个类存在两个合法的选择，选择第一个父类

让我们看一个稍微复杂的例子，涉及到多重继承，代码如下：

class Base(object):
    def __init__(self):
        print "enter Base"
        print "leave Base"

class A(Base):
    def __init__(self):
        print "enter A"
        super(A, self).__init__()
        print "leave A"

class B(Base):
    def __init__(self):
        print "enter B"
        super(B, self).__init__()
        print "leave B"

class C(A, B):
    def __init__(self):
        print "enter C"
        super(C, self).__init__()
        print "leave C"

其中，Base是父类，A, B继承自Base, C继承自A, B，它们的继承关系是一个典型的『菱形继承』，如下：

现在，让我们看一下使用：

>>> c = C()
enter C
enter A
enter B
enter Base
leave Base
leave B
leave A
leave C

如果你认为 super 代表『调用父类的方法』，那你很可能会疑惑为什么enter A的下一句不是enter Base而是enter B。原因是，super 和父类没有实质性的关联。super 的工作原理如下：

def super(cls, inst):
    mro = inst.__class__.mro()
    return mro[mro.index(cls) + 1]

其中，cls代表类，inst代表实例，上面的代码做了两件事：

获取inst的MRO列表
查找cls在当前MRO列表中的index,并返回它的下一个类，即mro[index + 1]

当你使用 super(cls, inst) 时，Python会在inst的MRO列表上搜索cls的下一个类。首先看类C的 __init__ 方法：

super(C, self).__init__()

这里的self是当前C的实例，self.class.mro()结果是：

[__main__.C, __main__.A, __main__.B, __main__.Base, object]

可以看到，C的下一个类是A，于是，跳到了A的 __init__，这时会打印出enter A，并执行下面一行代码：

super(A, self).__init__()

注意，这里的self也是当前C的实例，MRO列表跟上面是一样的，搜索A在MRO中的下一个类，发现是B，于是，跳到了B的 __init__，这时会打印出enter B，而不是enter Base。

最近更新于0001-01-01