<流畅的Python> 接口:从协议到抽象基类

抽象类表示接口。
——Bjarne Stroustrup, C++ 之父

本章讨论的话题是接口:

鸭子类型的代表特征动态协议,到使接口更明确、能验证实现是否符合规定的抽象基类(Abstract Base Class, ABC)。

接口的定义:对象公开方法的子集,让对象在系统中扮演特定的角色。
协议是接口,但不是正式的(只由文档和约定定义),因此协议不能像正式接口那样施加限制。
允许一个类上只实现部分接口。

接口与协议

  • 什么是接口

    对象公开方法的子集,让对象在系统中扮演特定的角色。

  • 鸭子类型与动态协议

  • 受保护的类型与私有类型不能在接口中

  • 可以把公开的数据属性放在接口中

案例:通过实现 getitem 方法支持序列操作

1
2
3
4
5
6
7
8
9
class Foo:
def __getitem__(self, pos):
return range(0, 30, 10)[pos]

f = Foo()
print(f[1])

for i in f:
print(i)

Foo 实现了序列协议的 __getitem__ 方法。因此可支持下标操作。

Foo 实例是可迭代的对象,因此可以使用 in 操作符

案例:在运行时实现协议——猴子补丁

FrenchDeck 类见前面章节。

FrenchDeck 实例的行为像序列,那么其实可以用 random 的 shuffle 方法来代替在类中实现的方法。

1
2
3
4
5
6
from random import shuffle
from frenchdeck import FrenchDeck

deck = FrenchDeck()
shuffle(deck)
# TypeError: 'FrenchDeck' object does not support item assigment

FrenchDeck 对象不支持元素赋值。这是因为它只实现了不可变的序列协议,可变的序列还必须提供 __setitem__ 方法。

1
2
3
4
5
6
7
def set_card(deck, pos, card):
deck._cards[pos] = card

FrenchDeck.__setitem__ = set_card
shuffle(deck)
print(deck[:5])
print(deck[:5])

这种技术叫做猴子补丁:在运行是修改类或程序,而不改动源码。缺陷是补丁代码与要打补丁的程序耦合紧密。

抽象基类(abc)

抽象基类是一个非常实用的功能,可以使用抽象基类来检测某个类是否实现了某种协议,而这个类并不需要继承自这个抽象类。
collections.abcnumbers 模块中提供了许多常用的抽象基类以用于这种检测。

有了这个功能,我们在自己实现函数时,就不需要非常关心外面传进来的参数的具体类型isinstance(param, list)),只需要关注这个参数是否支持我们需要的协议isinstance(param, abc.Sequence)以保障正常使用就可以了。

但是注意:从 Python 简洁性考虑,最好不要自己创建新的抽象基类,而应尽量考虑使用现有的抽象基类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 抽象基类
from collections import abc


class A:
pass

class B:
def __len__(self):
return 0

assert not isinstance(A(), abc.Sized)
assert isinstance(B(), abc.Sized)
assert abc.Sequence not in list.__bases__ # list 并不是 Sequence 的子类
assert isinstance([], abc.Sequence) # 但是 list 实例支持序列协议
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 在抽象基类上进行自己的实现
from collections import abc

class FailedSized(abc.Sized):
pass


class NormalSized(abc.Sized):
def __len__(self):
return 0


n = NormalSized()
print(len(n))
f = FailedSized() # 基类的抽象协议未实现,Python 会阻止对象实例化

有一点需要注意:抽象基类上的方法并不都是抽象方法。
换句话说,想继承自抽象基类,只需要实现它上面所有的抽象方法即可,有些方法的实现是可选的。
比如 Sequence.__contains__,Python 对此有自己的实现(使用 __iter__ 遍历自身,查找是否有相等的元素)。但如果你在 Sequence 之上实现的序列是有序的,则可以使用二分查找来覆盖 __contains__ 方法,从而提高查找效率。

我们可以使用 __abstractmethods__ 属性来查看某个抽象基类上的抽象方法。这个抽象基类的子类必须实现这些方法,才可以被正常实例化。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 自己定义一个抽象基类
import abc

# 使用元类的定义方式是 class SomeABC(metaclass=abc.ABCMeta)
class SomeABC(abc.ABC):
@abc.abstractmethod
def some_method(self):
raise NotImplementedError


class IllegalClass(SomeABC):
pass

class LegalClass(SomeABC):
def some_method(self):
print('Legal class OK')


l = LegalClass()
l.some_method()
il = IllegalClass() # Raises

虚拟子类

使用 register 接口可以将某个类注册为某个 ABC 的“虚拟子类”。支持 register 直接调用注册,以及使用 @register 装饰器方式注册(其实这俩是一回事)。
注册后,使用 isinstance 以及实例化时,解释器将不会对虚拟子类做任何方法检查。
注意:虚拟子类不是子类,所以虚拟子类不会继承抽象基类的任何方法。

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
# 虚拟子类
import abc
import traceback

class SomeABC(abc.ABC):
@abc.abstractmethod
def some_method(self):
raise NotImplementedError

def another_method(self):
print('Another')

@classmethod
def __subclasshook__(cls, subcls):
"""
在 register 或者进行 isinstance 判断时进行子类检测
https://docs.python.org/3/library/abc.html#abc.ABCMeta.__subclasshook__
"""
print('Subclass:', subcls)
return True


class IllegalClass:
pass

SomeABC.register(IllegalClass) # 注册
il = IllegalClass()
assert isinstance(il, IllegalClass)
assert SomeABC not in IllegalClass.__mro__ # isinstance 会返回 True,但 IllegalClass 并不是 SomeABC 的子类
try:
il.some_method() # 虚拟子类不是子类,不会从抽象基类上继承任何方法
except Exception as e:
traceback.print_exc()

try:
il.another_method()
except Exception as e:
traceback.print_exc()