Python学习之路31-继承的利弊

《流畅的Python》笔记

本篇是“面向对象惯用方法”的第五篇,我们将继续讨论继承,重点说明两个方面:继承内置类型时的问题以及多重继承。概念比较多,较为枯燥。

1. 继承内置类型

内置类型(C语言编写)的方法通常会忽略用户重写的方法,这种行为体现在两方面:

  • 内置类型A的子类ChildA即使重写了A中的方法,当ChildA调用这些方法时,也不一定调用的就是重写的版本,而依然可能调用A中的版本;
  • 内置类型B调用ChildA的方法时,调用的也不一定是被ChildA重写的方法,可能依然会调用A的版本。

dict__getitem__方法为例,即使这个方法被子类重写了,内置类型的get()方法也不一定调用重写的版本:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 代码1.1
>>> class MyDict(dict):
... def __getitem__(self, key):
... return "Test" # 不管要获取谁,都返回"Test"
...
>>> child = MyDict({"one":1, "two":2})
>>> child
{'one': 1, 'two': 2} # 正常
>>> child["one"]
'Test' # 此时也是正常的
>>> child.get("one")
1 # 这里就不正常了,按理说应该返回"Test"
>>> b = {}
>>> b.update(child)
>>> b # 并没有调用child的__getitem__方法
{'one': 1, 'two': 2}

这是在CPython中的情况,这些行为其实违背了面向对象编程的一个基本原则,即应该始终从实例所属的类开始搜索方法,即使在超类实现的类中调用也应该如此。但实际是可能直接调用基类的方法,而不先搜索子类。这种设定并不能说是错误的,这只是一种取舍,毕竟这也是CPython中的内置类型运行得快的原因之一,但这种方式就给我们出了难题。这种问题的解决方法有两个:

  • 重写从内置类型继承来的所有方法(要真这样,那我还继承干啥?),或者查看源码,把相关的方法都给重写了(谁的记性能这么好?);
  • 第二种方法才是推荐的方法:如果要继承内置类型,请从collections模块中继承,比如继承自UserListUserDictUserString。这些类不是用C语言写的,而是用纯Python写的,并且严格遵循了上述面向对象的原则。如果上述代码中的MyDict继承自UserDict,行为则会合乎预期。

强调:本节所述问题只发生在C语言实现的内置类型内部的方法委托上,而且只影响直接继承内置类型的自定义类。如果子类继承自纯Python编写的类,则不会有此问题。

2.多重继承

任何实现多重继承的语言都要处理潜在的命名冲突,这种冲突由不相关的超类实现同名方法引起。这种冲突称为”菱形冲突“。

2.1 多重继承的示例

下面是我们要实现的类的UML图:

红线表示超类的调用顺序,以下是它的实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
# 代码2.1
class A:
def ping(self):
print("ping in A:", self)

class B(A):
def pong(self):
print("pong in B:", self)

class C(A):
def pong(self):
print("PONG in C:", self)

class D(B, C):
def ping(self):
super().ping()
print("ping in D:", self)

def pingpong(self):
self.ping()
super().ping()
self.pong()
super().pong()
C.pong(self) # 在定义时调用特定父类的写法,显示传入self参数

# 下面是它在控制台中的调用情况
>>> from diamond import *
>>> d = D()
>>> d.pong()
pong in B: <mytest.D object at 0x0000013E66313048>
>>> d.pingpong()
ping in A: <mytest.D object at 0x0000013E66313048> # self.ping()
ping in D: <mytest.D object at 0x0000013E66313048>
ping in A: <mytest.D object at 0x0000013E66313048> # super().ping()
pong in B: <mytest.D object at 0x0000013E66313048> # self.pong()
pong in B: <mytest.D object at 0x0000013E66313048> # super().pong()
PONG in C: <mytest.D object at 0x0000013E66313048> # C.pong(self)
>>> C.pong(d) # 在运行时调用特定父类的写法,显示传入实例参数
PONG in C: <mytest.D object at 0x0000013E66313048>
>>> D.__mro__ # Method Resolutino Order,方法解析顺序,上一篇文章中有所提及
(<class 'mytest.D'>, <class 'mytest.B'>, <class 'mytest.C'>,
<class 'mytest.A'>, <class 'object'>)

类都有一个名为__mro__ 的属性,它的值是一个元组,按一定顺序列举超类,这个顺序由C3算法计算。

方法解析顺序不仅考虑继承图,还考虑子类声明中列出超类的顺序。例如,如果D类的声明改为class D(C, B),那么D则会先搜索C,再搜索B

若想把方法调用委托给超类,推荐的做法是使用内置的super()函数;同时,还请注意上述调用特定超类的语法。然而,使用super()是最安全的,也不易过时。调用框架或不受自己控制的类层次结构中的方法时,尤其应该使用super()

2.2 处理多重继承的建议

继承有很多用途,而多重继承增加了可选方案和复杂度。使用多重继承容易得出令人费解和脆弱的设计。以下是8条避免产生混乱类图的建议:

  1. 把接口继承和实现继承区分开

    在使用多重继承时,一定要明白自己为什么要创建子类:

    • 继承接口,创建子类,实现“是什么(”is-a”)”关系;
    • 继承实现,通过重用避免代码重复

    其实这俩经常同时出现,不过只要有可能,一定要明确这么做的意图。通过继承重用代码是实现细节,通常可以换成用组合和委托的模式,而接口继承则是框架的支柱。

  2. 使用抽象基类显示表示接口

    如果类的作用是定义接口,应该将其明确定义为抽象基类。

  3. 通过“混入类”实现代码重用

    如果一个类的作用是为多个不相关的子类提供方法实现,从而实现重用,但不体现“is-a”关系,则应该把那个类明确定义为混入类(mixin class)。从概念上讲,混入不定义新类型,只是打包方法,便于重用。混入类绝对不能实例化,而且具体类不能只继承混入类。混入类应该提供某方面的特定行为,只实现少量关系非常紧密的方法。

  4. 在名称中明确指明混入

    由于Python没有把类明确声明为混入的正式方式,实际的做法是在类名后面加入Mixin后缀。Python的GUI库Tkinter没有采用这种方法,这也是它的类图十分混乱的原因之一,而Django则采用了这种方式。

  5. 抽象基类可以作为混入类,但混入类不能作为抽象基类

    抽象基类可以实现具体方法,因此可以作为混入类使用。但抽象基类能定义数据类型,混入类则做不到。此外,抽象基类可以作为其他类的唯一基类,混入类则决不能作为唯一的基类,除非这个混入类继承了另一个更具体的混入(这种做法非常少见)。

    但值得注意的是,抽象基类中的具体方法只是一种便利措施,因为它只能调用抽象基类及其超类中定义了的方法,那么用户自行调用这些方法也可以实现同样的功能,所以,抽象基类也并不常作为混入类。

  6. 不要从多个具体类继承

    应该尽量保证具体类没有或者最多只有一个具体超类。也就是说,具体类的超类中除了这一个具体超类外,其余的都应该是抽象基类或混入类。

  7. 为用户提供聚合类

    如果抽象基类或混入类的组合对客户代码非常有用,那就提供一个类,使用易于理解的方式把它们结合起来,这种类被称为聚合类。比如tkinter.Widget类,它的定义如下:

    1
    2
    3
    # 代码2.2
    class Widget(BaseWidget, Pack, Place, Grid): # 省略掉了文档注释
    pass

    它的定义体是空的,但通过这一个类,提供了四个超类的全部方法。

  8. 优先使用对象组合,而不是类继承

    优先使用组合能让设计更灵活。即便是单继承,这个原则也能提升灵活性,因为继承是一种紧耦合,而且较高的继承树容易倒。组合和委托还可以代替混入类,把行为提供给不同的类,但它不能取代接口继承,因为接口继承定义的是类层次结构。

VPointer wechat
欢迎大家关注我的微信公众号"代码港"~~
您的慷慨将鼓励我继续创作~~