Python的程序结构[2] -> 类/Class[1] -> 基类与继承

基类与继承 / Base Class and Inheritance Class

---

面向对象的特性使得 Python 中不可避免地需要使用到类和类的继承，类的继承可以使得代码很好的被重用。下面以一些代码示例说明类的继承如何使用。

继承一个基类

---

首先，定义一个基类 Animal，在初始化中设定一个基本属性以及物种信息，并设置其具有 eat 的能力（self.eat 为 True）。此处还重载了魔术方法 __getattr__，当搜索的属性不存在时返回 False（即不具备该能力），最后定义一个 show 函数来显示当前 species 信息。

# ------- Basic inheritance --------
class Animal:
    def __init__(self):
        self.base = "Creature"
        self.species = "Animal"
        self.eat = True

    def __getattr__(self, item):
        return False

    def show(self):
        print("This is %s." % self.species)

接着定义一个 Bird 类，继承自 Animal ，在 Bird 的初始化函数中，首先对基类进行初始化，然后设置 species 属性，以及 fly 为True（代表具有 fly 的能力），并对 Bird 定义了 show 函数。同样定义 Fish 类，设置 species 信息以及 swim 为 True，且不定义 show 函数。

# Note: Do not mix super and Object.__init__
class Bird(Animal):
    def __init__(self):
        Animal.__init__(self)
        self.species = "Bird"
        self.fly = True

    def show(self):
        print("This is %s from %s." % (self.species, self.base))

class Fish(Animal):
    def __init__(self):
        Animal.__init__(self)
        self.species = "Fish"
        self.swim = True

最后，对两个类分别进行实例化，并调用各自的 show 函数，

b = Bird()
f = Fish()
b.show()
f.show()

输出的结果如下，

This is Bird from Creature.
This is Fish.

从最终的输出结果可以看到，

对于 Bird 类，并没有对 base 属性进行定义，但却拥有 base 属性，即这一属性从基类 Animal 中继承得到，

而对于 Fish 类，并未定义 show 方法，但是却在实例中可以使用 show 方法。同样这一方法也是继承自基类 Animal。

这两个简单的示例中通过继承从而避免了重复的代码和定义。

多继承

---

前面的例子中使用的基类是唯一的，当需要从多个基类中继承时，则会涉及到多继承问题。下面的代码给出一个多继承问题的示例。

首先导入之前定义的两个类 Bird 和 Fish 作为基类，然后基于这两个类派生出子类 Duck 和 Goose，其中 Goose 中重载了初始化函数，利用 super 初始化 Goose 的基类。此时，我们希望 Duck 和 Goose 能够继承 Bird 和 Fish 的两个特性，fly 和 swim。

Note: 此处为示例代码，切勿混用 super 和类的初始化函数。

from inheritance_base import Bird, Fish
# ------- Multi inheritance --------
class Duck(Bird, Fish): pass

class Goose(Bird, Fish):
    def __init__(self):
        super(Goose, self).__init__()

d = Duck()
g = Goose()
print("I am %s, I can fly: %s" % (d.species, d.fly))
print("I am %s, I can swim: %s" % (d.species, d.swim))
print("I am %s, I can fly: %s" % (g.species, g.fly))
print("I am %s, I can swim: %s" % (g.species, g.swim))

最终的运行结果如下，

I am Bird, I can fly: True
I am Bird, I can swim: False
I am Bird, I can fly: True
I am Bird, I can swim: False

从运行的结果中看到，最后的输出却不是我们所期望的，无论是 Duck 的实例还是 Goose 的实例都不具备 swim 的属性，也就是说，Fish 的初始化并未被执行。

其原因在于，Duck 中并未定义初始化函数，因此会在父类中搜索，从而调用到 Bird 的初始化函数，所以最终显示 species 属性为 Bird，而 swim 为 False。而在 Goose 中，使用 super 也未能成功继承所有属性，这是由于 super 会依照 MRO 顺序进行搜索，使用搜索到的第一个类的对应方法。

为实现所需要的功能，在这里重新定义一个 Duck 类，重载初始化函数，在初始化函数中分别调用两个基类的初始化函数。

class Duck(Bird, Fish):
    def __init__(self):
        Bird.__init__(self)
        Fish.__init__(self)

d = Duck()
print("I am %s, I can fly: %s" % (d.species, d.fly))
print("I am %s, I can swim: %s" % (d.species, d.swim))

最终输出结果可以看到，species 属性被覆盖了最终显示为 Fish，而 Goose 也具备了 fly 和 swim 两个属性。

I am Fish, I can fly: True
I am Fish, I can swim: True

但这种继承依旧会引起一些问题。

菱形 / 钻石继承

---

前面的多继承使用直接调用父类初始化函数进行，表面上能够满足多继承的需求，但是仍然存在一些问题，下面以一个菱形/钻石继承来说明这一问题是如何存在的。

首先是定义 A、B、C、D 四个类，这四个类大致为菱形继承的形式。

"""
    A
    /
   /  
  /    
 B      C
      /
     /
    /
    D
"""

然后以 no-super 和 super 两种方式来实现这一继承，
在 no super 中不使用 super，直接使用调用父类初始化函数的方法来完成初始化工作，具体方式如下，

# ------- no super ----------
class A(object):
    def __init__(self):
        object.__init__(self)
        print("This is A init.")

class B(A):
    def __init__(self):
        A.__init__(self)
        print("This is B init.")

class C(A):
    def __init__(self):
        A.__init__(self)
        print("This is C init.")
        
class D(B, C):
    def __init__(self):
        B.__init__(self)
        C.__init__(self)
        print("This is D init.")

d = D()

输出结果如下，从输出中可以看出，这种方式存在一个问题，那就是对 B 和 C 的基类 A 进行了多次的初始化。这可能会造成一些不期望的结果。

This is A init.
This is B init.
This is A init.
This is C init.
This is D init.

为了避免这种现象，可以使用 super 来完成继承初始化。

# ------- super ------------
class A(object):
    def __init__(self):
        super(A, self).__init__()
        print("This is A init.")

class B(A):
    def __init__(self):
        super(B, self).__init__()
        print("This is B init.")

class C(A):
    def __init__(self):
        super(C, self).__init__()
        print("This is C init.")
        
class D(B, C):
    def __init__(self):
        super(D, self).__init__()
        print("This is D init.")

d = D()

使用super的初始化结果显示如下，可以看到，此时能够实现对 A 的初始化只进行一次。这是由于 super 中实现了 MRO 的搜索算法。

This is A init.
This is C init.
This is B init.
This is D init.

相关阅读

---

1. 魔术方法 __getattr__

2. super

3. MRO 顺序