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 "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class Source with abstract methods get
>>> 
>>> test = Mysource()                                       # 此处实例化 Mysource，未报错
>>> 
>>> test = Mysource1()                         
Traceback (most recent call last):                          # 报错，继承类必须实现抽象类的方法
  File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class Mysource1 with abstract methods get

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