Python中的协议、鸭子类型、抽象基类、混入类

超、凢脫俗 2022-05-24 10:05 205阅读 0赞

篇文章探讨一下python中的几个概念：协议 、鸭子类型 、 抽象基类 、混入类。

一、协议

在python中，协议是一个或一组方法。例如，Python 的序列协议包含 len 和 getitem 两个方法， 上下文管理器协议包含 enter 和 exit 两个方法（前者参见文章 《一文读懂python可迭代对象、迭代器和生成器》，后者参见文章《python中的上下文管理器和你所不了解的with》）,此处不再赘述。

二、鸭子类型（duck typing）

多态的一种形式，在这种形式中，对象的类型无关紧要，只要实现了特定的协议即可。

举一个之前文章中的例子：

示例1

1.  `class Eg1:`
2.  `   def __init__(self, text):`
3.  `       self.text = text`
4.  `       self.sub_text = text.split(' ')`
5.  ``
6.  `   def __getitem__(self, index):`
7.  `       return self.sub_text[index]`
8.  ``
9.  `   def __len__(self):`
10. `       return len(self.sub_text)`
11. ``
12. `o1 = Eg1('Hello, the wonderful new world!')`
13. `print('长度：', len(o1))`
14. `for i in o1:`
15. `   print(i)`

输出：

1.  `长度： 5`
2.  `Hello,`
3.  `the`
4.  `wonderful`
5.  `new`
6.  `world!`

示例1 中Eg1类 实现了 len 和 getitem两个方法，也就是实现了序列协议，那么它的表现就和序列类似。通过输出结果就能看出，Eg1的对象可以计算长度，也可以循环处理，这和正常的序列没什么不同。因此我们可以把Eg1称为一个鸭子类型，即 只关注它是否实现了相应的协议，不关注它的类型。

三、抽象基类

抽象基类就是定义各种方法而不做具体实现的类，任何继承自抽象基类的类必须实现这些方法，否则无法实例化。

那么抽象基类这样实现的目的是什么呢？ 假设我们在写一个关于动物的代码。涉及到的动物有鸟，狗，牛。首先鸟，狗，牛都是属于动物的。既然是动物那么肯定需要吃饭，发出声音。但是具体到鸟，狗，牛来说吃饭和声音肯定是不同的。需要具体去实现鸟，狗，牛吃饭和声音的代码。概括一下抽象基类的作用：定义一些共同事物的规则和行为。

示例2

1.  `import abc`
2.  `class Animal(abc.ABC):`
3.  ``
4.  `   @abc.abstractmethod`
5.  `   def eat(self):`
6.  `"""吃的动作"""`
7.  ``
8.  `   @abc.abstractmethod`
9.  `   def voice(self):`
10. `"""叫的动作"""`
11. ``
12. `class Dog(Animal):`
13. ``
14. `   def eat(self):`
15. `       print('Dog eating....')`
16. `   def voice(self):`
17. `       print('wow....')`
18. ``
19. ``
20. `class Bird(Animal):`
21. ``
22. `   def eat(self):`
23. `       print('Bird eating....')`
24. `   def voice(self):`
25. `       print('jiji....')`
26. ``
27. ``
28. `d = Dog()`
29. `d.eat()`
30. `d.voice()`
31. `b = Bird()`
32. `b.eat()`
33. `b.voice()`

输出：

1.  `Dog eating....`
2.  `wow....`
3.  `Bird eating....`
4.  `jiji....`

示例2中定义了一个抽象基类 Animal，它包含两个抽象方法eat和voice，Dog和Bird都继承了Animal，并各自实现了具体的eat和voice方法。Dog和Bird在实例化之后调用相同的方法，但是却有不同的输出，这就是最简单的抽象基类的用法。

注意，自己定义的抽象基类要继承 abc.ABC（abc.ABC 是 Python 3.4 新增的类，python2的语法不是这样的）。抽象方法使用 @abstractmethod 装饰器标记，而且定义体中通常只有文档字符串。

除了继承，还有一种方法可以将类和抽象基类关联起来： 示例3，在示例2后面添加代码：

1.  `@Animal.register`
2.  `class Cat(Animal):`
3.  ``
4.  `   def eat(self):`
5.  `       print('Cat eating....')`
6.  `   def voice(self):`
7.  `       print('miao....')`
8.  ``
9.  `print(issubclass(Cat, Animal))`

输出：

1.  `True`

这种通过注册和抽象基类关联起来的类叫做虚拟子类，虚拟子类不会继承注册的抽象基类，而且任何时候都不会检查它是否符合抽象基类的接口，即便在实例化时也不会检查。为了避免运行时错误，虚拟子类要实现所需的全部方法。

抽象基类并不常用，但是在阅读源码的时候可能会遇到，因此还是要了解一下。

四、混入类（mixin class）

混入类是为代码重用而生的。从概念上讲，混入不定义新类型，只是打包方法，便于重用。混入类应该提供某方面的特定行为，只实现少量关系非常紧密的方法并且混入类绝对不能实例化。

在 Python 中没有把类声明为混入的正规方式，所以强烈推荐在名称中加入 ...Mixin 后缀。Django在这方面做的很好，举一个例子， ListView主要用于从数据库中获取多条记录，它的继承关系如下：

整个体系非常清晰，各个类的职责也非常明确，且类的职责从命名就可以读出。例如 ContextMixin 及其子类负责获取渲染模板所需的模板变量；MultipleObjectMixin 负责从数据库获取模型对应的多条数据；View 负责处理 HTTP 请求（如 get 请求，post 请求）；TemplateResponseMixin 及其子类负责渲染模板。各个类组合在一起就构成了功能完整的 ListView。由此看出Django设计者充分采纳了一个类只负责一件事的设计理念（即单一责任原则），而且命名也是遵循一套统一的规范（...Mixin 后缀）。

好了，了解了这些概念对于python的使用和源码的阅读是非常有用的。希望能对你有帮助！