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

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

1. 多态

CATALOG

FEATURED TAGS

FRIENDS