1,鸭子类型和白鹅类型
1.1,白鹅类型
白鹅类型对接口有明确定义,比如不可变序列(Sequence),需要实现__contains__,__iter__,__len__,__getitem__,__reversed__,index,count。
对于其中的抽象方法,子类在继承时必须具体化,其余非抽象方法在继承时可以自动获得,Sequence序列必须具体化的抽象方法是__len__和__getitem__。
from collections import abc
class Foo(abc.Sequence):
def __init__(self, components):
self._components = components
def __getitem__(self, item):
return self._components[item]
def __len__(self):
return len(self._components)
Foo通过继承abc.Sequence,明确了自己的身份,明确了自己需要实现哪些方法,并且会自动获得哪些方法, 这样的正式继承即为白鹅类型。
Foo的实例就是正式的Sequence类了,可以通过isinstance检查,可以使用自己创建的抽象方法,可以使用继承抽象基类获得的方法:
f = Foo(list('abcde'))
print(isinstance(f, abc.Sequence)) # 结果True
print(f[0]) # 'a',__getitem__
print(len(f)) # 5,__len__
print('b' in f) # True,__contains __
for i in f: # __iter__
print(i)
print(list(reversed(f))) # ['e', 'd', 'c', 'b', 'a'], __reversed__
print(f.count('a')) # 1, count
print(f.index('a')) # 0, index
1.2,鸭子类型
鸭子类型没有明确的接口,只是遵循了一定的协议,比如python序列协议只需要实现__len__和__getitem__方法,对于序列,这点鸭子类型和白鹅类型中Sequence抽象基类的要求相同,但白鹅类型Sequence继承后能够自动获得抽象基类的方法,而鸭子类型不会有这些方法:
class Foo:
def __init__(self, components):
self._components = components
def __getitem__(self, item):
return self._components[item]
def __len__(self):
return len(self._components)
Foo自己实现的2个方法可以用:
print(f[0]) # 'a', __getitem__
print(len(f)) # 5, __len__
Foo自己没有实现的3个方法不可用:
print(list(reversed(f))) # error
print(f.count('a')) # error
print(f.index('a')) # error
下面2个自己没实现的方法也可以用,为什么呢?原因是python发现某些特殊方法没有实现时,会自动尝试调用其他特殊方法:
print('b' in f) # 可以用,python的in测试会依次尝试调用__contains__,__iter__,__getitem__
for i in f: # 可以用,python的迭代会依次尝试调用__iter__,__getitem__
print(f)
另外鸭子类型的Foo,无法通过isinstance检查:
print(isinstance(f, abc.Sequence)) # 结果False
2,抽象基类
抽象基类的主要作用:1)作为超类定义接口;2)isinstance检查;3)注册:不子类化就声明实现接口;4)自动识别:不注册/不子类化就让抽象基类能够识别虚拟子类。
猴子补丁:运行时修改类,不改变源码,FrenchDeck.__setitem__ = set_card,例如给FrenchDeck类补上set_card()方法。
2.1,自己定义抽象基类 - abc
自定义抽象基类需要继承abc.ABC(不继承无法约束子类必须实现抽象方法),并且用@abc.abstractmethod装饰抽象方法,抽象基类无法实例化。
子类在基础抽象基类时,必须将抽象方法实现,否则无法实例化。
import abc
class Tombola(abc.ABC): # 继承abc.ABC
@abc.abstractmethod # 声明抽象方法
def load(self):
"""这里是注释"""
def inspect(self): # 非抽象方法
pass
2.2,内置抽象基类 - collections.abc
Iterable:__iter__
Container:__contains__
Sized:__len__
Sequence:不可变序列
Mapping:不可变映射
Set:不可变集合
MappingView
Callable、Hashable
Iterator、Iterable
可以通过对抽象基类实例化,来查看强制要求实现的抽象方法:
>>> import collections
>>> collections.Sequence()
Traceback (most recent call last):
File "", line 1, in
TypeError: Can't instantiate abstract class Sequence with abstract methods __getitem__, __len__
2.3,内置抽象基类 - numbers
Number:数基类
Complex:复数 = 实数 + 虚数
Real:实数 = 有理数 + 无理数
Rational:有理数 = 整数 + 分数
Intergral:整数
例如:判断浮点数可以用isinstance(obj, numbers.Real)
如果obj是bool,int,float,fractions.Fraction,或外部库(例如numpy)提供的非复数类型,都能返回True
用type(obj, float)则比较局限
2.4,内置抽象基类 — io
定义了IO处理相关的抽象基类
2.5,注册 — 让基类拥有虚拟子类
通过注册,可以不用继承,就建立基类和“虚拟子类”之间的关系。有二个关键点:
1)注册后,python会相信我们,直接让“虚拟子类”通过isinstance检查,也不会约束虚拟子类必须实现抽象方法。
2)“虚拟子类”不会从抽象基类获得任何方法和属性。
综上所述:为避免运行时出错,注册后我们应该手动让“虚拟子类”实现“基类”的所有方法。
注册方法一:装饰器(python3.3之后支持)
@Tombola.register # 装饰器注册
class TomboList(list):
def load(self):
pass
注册方法二:标准调用语法
class TomboList(list):
def load(self):
pass
Tombola.register(TomboList) # 标准调用语法注册
注册后,虚拟子类的实例化对象,就能够通过isinstance检查:
t = TomboList()
isintance(t, Tombola) # True
对象注册后,如果缺少某些方法尚未实现,会报错提示
2.6,自动识别
抽象基类有个方法__subclasshook__,通过判断其他类是否具有一些特殊方法(失败返回NotImplement让虚拟子类继续判断),来识别其他类是不是自己的“虚拟子类”,例如:
class Struggle:
def __len__(self):
pass
s = Struggle()
isintance(s, abc.Sized) # True
必须具有__subclasshook__的抽象基类才能提供该功能。
ps:自己建了个类,实现了collections.Sequence所有方法,但是无法通过collections.Sequence检查,collections.Sequence貌似没有实现该方法。