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继承 的定义，应该 尽量使用鸭子模型；
-- 如果一定要继承接口的话，比较 推荐多继承，抽象基类容易 设计过度；
