Python：多态、鸭子模型和抽象基类

1. 多态

• 什么是多态
  -- 多态，指的是一种事务具有多种形态；
  -- python是一种动态语言，默认支持多态，同一个方法 调用 不同的类对象 ，执行的 结果各不相同；

• 多态实现
  -- 继承：不同子类 继承 同一父类；
  -- 重写：子类重写 同一个方法，保证执行结果各不相同；

• 示例
  -- 有如下代码：

>>> class Animals():
...     def talk(self):
...         print("Animal talk")
...
>>>
>>> class People(Animals):   # 继承 Animals 类
...     def talk(self):
...         print('People speak language')
...
>>>
>>> class Cat(Animals):      # 继承 Animals 类
...     def talk(self):
...         print('Cat say miaomiao')
...
>>>
>>> cat = Cat()
>>> peo = People()
>>>
>>> cat.talk()  # 调用 talk 方法
Cat say miaomiao
>>> peo.talk()  # 调用 talk 方法
People speak language

• 如上所示：
  -- cat 和 peo 两个对象调用同一个 talk() 方法；
  -- 最后得到两种不同的结果；
• 多态的优点：
  -- 多态可以增加代码的灵活度；
  -- 是调用方法的技巧，不会影响到类的内部设计；
  -- 多态可以看做 接口函数的重用，同一种接口方法 通过 接收不同的类 对象，从而实现不同的功能；
• 多态使用场景：
  -- 方法参数接收同一父类的不同子类对象。

2. 鸭子模型

• 什么是鸭子模型
  -- 当看到一只鸟走起来像鸭子，游泳起来也像鸭子，叫起来也像鸭子，那么这只鸟就可以被称为鸭子；
  -- 鸭子模型和多态一样，都是接受不同的类对象，并调用相同的方法（即：鸭子的 游泳 和 叫 方法）；
  -- 对于一个鸭子模型来说，我们并 不关心接收的类对象是否真的是鸭子类，只关心这个类是如何被使用的；
  -- 注意：如果这些需要被调用的方法不存在，那么将引发一个运行时错误。

• 示例
  -- 有如下代码：

>>> class Duck:
...     def quack(self):
...         print("duck quack")
...
>>>
>>> class Bird:    # Bird 类与 Duck 类无继承关系
...     def quack(self):
...         print("bird quack")
...
>>>
>>> class Dog:     # Dog类与 Duck 类无继承关系
...     def quack(self):
...         print("dog quack")
...
>>>
>>> def animal_quack(animal):    # animal_quack 方法可以调用任何对象的 quack() 方法，不关心对象是谁
...     animal.quack()
...
>>>
>>> duck = Duck()
>>> bird = Bird()     # bird 实例与 duck 实例无任何关系
>>> dog = Dog()       # dog 实例与 duck 实例无任何关系
>>>
>>> for animal in [duck, bird, dog]:
...     animal_quack(animal)
...
duck quack
bird quack
dog quack

-- 如上所示：
-- duck、bird、dog 分别来自三个不同的类，而且类之间是 没有继承关系 的；
-- duck、bird、dog 调用 animal_quack 方法，得到三种不同的结果，符合多态的特征；

• 鸭子模型的优点：
  -- 鸭子模型不关关心类对象是什么，不需要类之间具有继承关系；
  -- 鸭子模型让代码比多态更加灵活度；
• 多态使用场景：
  -- 鸭子模型中，接收不同的类将会产生不同的行为，而无须明确知道这个类实际上是什么，这是多态的重要应用场景；
  -- 实际生产环境中，主要用于 接口开发，即用同一个函数接收不同的类对象，从而实现不同的功能，而且无需关注对象之间的继承关系；

3. 抽象基类

• 什么是抽象基类
  -- 抽象基类，这个词可能听着比较"深奥"，其实 抽象 就是 假 的意思，基类 就是 父类，抽象基类 就是 假父类；
  -- 具体来说，由 abc.ABCMeta 这个元类实现的类，就是抽象基类；
• 示例：
  -- 如下代码中的 AbstractClass 类继承自 abc.ABCMeta，AbstractClass 就是抽象基类；

class AbstractClass(metaclass=abc.ABCMeta):
    pass

• 抽象基类的作用
  -- 判断是否为某个对象的实例

>>> class MyList(object):
...     def __init__(self, my_list):
...         self.my_list= my_list
...     def __len__(self):
...         return len(self.my_list)
...
>>>
>>> class NewList(MyList):    # NewList 继承自 MyList
...     pass
...
>>> ml = MyList(["a", "b", "c"])
>>>
>>> from collections.abc import Sized, Iterable
>>>
>>> print(isinstance(ml, Sized))  
True             # 返回 True，因为这里会检查实例对象中有没有__len__方法，有即输出True
>>> nl = NewList([1, 2, 3])
>>> print(isinstance(nl, MyList))
True             # 返回 True，因为 nl 实例化的类 NewList 同时也是 MyList 的子类

-- 强制要求父类被子类继承，并在子类实现某个方法，否则子类初始化时就会报错；

>>> from abc import ABCMeta,abstractmethod
>>>
>>>
>>> class Source(metaclass=ABCMeta):              # 创建抽象基类 Source
...     @abstractmethod                           # 表示装饰的方法必须被子类所实现，否则会报错 
...     def get(self,key):
...         pass
...
>>>
>>> class Mysource(Source):                       # 子类 Mysource 继承自 抽象基类 Source
...     def get(self,key):                        # 实现 get 方法，这个方法是 抽象基类 Source 强制要求实现的
...         pass
...
>>>
>>> class Mysource1(Source):                      # 子类 Mysource1 没有实现 抽象基类 Source 强制要求实现的 get 方法
...     pass
...
>>> test = Source()         # test 直接实例化 Source 父类                 
Traceback (most recent call last):                          # 此处报错，因为抽象类无法实现实例化
  File "", line 1, in 
TypeError: Can't instantiate abstract class Source with abstract methods get
>>> 
>>> test = Mysource()                                       # 此处实例化 Mysource，未报错
>>> 
>>> test = Mysource1()                         
Traceback (most recent call last):                          # 报错，继承类必须实现抽象类的方法
  File "", line 1, in 
TypeError: Can't instantiate abstract class Mysource1 with abstract methods get

• 抽象基类使用场景
  -- 接口强制规定，主要是 强制子类实现某个方法，否则就提示报错；
• 抽象基类的有点：
  -- 处理继承问题方面更加规范、系统；
  -- 明确调用之间的相互关系，使得继承层次更加清晰；
• 抽象基类的缺点：
  -- 抽象基类在 python 并非在于用来继承，主要用来理解 python继承 的定义，应该 尽量使用鸭子模型；
  -- 如果一定要继承接口的话，比较 推荐多继承，抽象基类容易 设计过度；