引言

前面我们花了不少的篇幅把Python中面向对象的封装与继承简单介绍了一遍。今天来聊一下Python面向对象的第三个特性：多态。

其实，在《Python之面向对象：一切皆对象，可你真的需要面向对象吗》这篇文章中，对比面向过程与面向对象的设计思想时，已经使用了多态，并体会到了多态的好处。没有读过这篇文章的同学，可以直接跳转查看。

今天的文章中，我们来对多态做一个稍微完整一些的介绍。

开闭原则（OCP）

在介绍介绍多态之前，我们首先来先看下面线对象设计（OOD）需要遵循的基本原则，之所以要先介绍这些原则，前面已经提到过，从软件工程的角度来看，相较于面向对象编程（OOP），其实更加核心关键在于其前置的两项工作，即面向对象分析（OOA）与面向对象设计（OOD），OOP本身其实可以看作是对OOA和OOD输出结果的翻译工作。

OOD有五个需要遵循的基本原则，也称之为SOLID原则（是将每个原则的首字母拼接在一起），分别是：

1、单一职能原则（Single Responsibility Principle, SRP）

2、开放封闭原则（Open/Closed Principle, OCP）

3、里氏替换原则（Liskov Substitution Principle, LSP）

4、接口隔离原则（Interface Segregation Principle, ISP）

5、依赖倒置原则（Dependency Inversion Principle, DIP）

简单来说，就是：

1、每个类应该只有一个职责。

2、对扩展开放，对修改封闭。

3、子类可以替代父类，程序行为不变。

4、客户端不应该被迫依赖它们不需要的接口。

5、高层模块不应该依赖低层模块，两者都应该依赖于抽象。

在OOD中通过践行这些原则，可以帮助我们设计、开发出更加灵活、易维护、可扩展的系统。

OOD原则就介绍到这里，感兴趣的可以找本《设计模式》的书来看看。在笔者看来，大道至简，相较于机械记忆几十种设计模式，不如更好地消化理解这几条设计原则。

之所以要提OOD的设计原则，是因为其中的OCP与面向对象的多态具有很大的关联性，在一定程度上可以理解为，要践行OCP，就需要使用面向对象的多态。

来看一下这段代码：

class ProductManager:
    def __init__(self, tool):
        self.tool = tool


class Programmer:
    def __init__(self, language):
        self.language = language


# 违反了OCP原则
def work(dgr):
    if isinstance(dgr, Programmer):
        print(f"程序员使用【{dgr.language}】进行编程")
    elif isinstance(dgr, ProductManager):
        print(f"产品经理使用【{dgr.tool}】设计原型")


if __name__ == '__main__':
    # 实例化一个产品狗
    dog = ProductManager('墨刀')
    work(dog)
    # 实例化一个程序猿
    monkey = Programmer('Python')
    work(monkey)

执行结果：

经过这么多篇面向对象的文章的介绍，已经对面向对象编程有感觉的同学，一定会觉得上面的代码写得很别扭，上面的代码就是典型的违反了OCP原则的设计。

因为，当我们每次扩展一种新的打工人类型时，都要修改work()函数的内部代码，添加新的实例类型的判断分支。改进的方法就是我们今天要介绍的“多态”。

多态

首先看通过多态，对上面违反OCP原则的代码的改进方案：

class DaGongRen:
    def work(self):
        pass


class ProductManager(DaGongRen):
    def __init__(self, tool):
        self.tool = tool

    def work(self):
        print(f"产品经理使用【{self.tool}】设计原型")


class Programmer(DaGongRen):
    def __init__(self, language):
        self.language = language

    def work(self):
        print(f"程序员使用【{self.language}】进行编程")


# 符合OCP原则
def work(dgr):
    dgr.work()


if __name__ == '__main__':
    # 实例化一个产品狗
    dog = ProductManager('墨刀')
    work(dog)
    # 实例化一个程序猿
    monkey = Programmer('Python')
    work(monkey)

通过多态的方式，当扩展打工人类型时，work()函数是不需要修改的。

需要注意的是，这个案例中，对修改是否关闭，看的是这里：

修改前，每次扩充都要修改work()函数的定义。而修改后，每次扩充，work()函数都不需要修改的。

回看前面的文章，其实会发现，我们已经在不知不觉地使用“多态”的特性了。

虽然已经会用了，我们还是在废话几句介绍下“多态”吧。

1、所谓多态（Polymorphism）是面向对象中的一个核心概念、核心特性，它允许我们通过相同的接口（比如前面的work()函数）调用不同的对象，从而实现代码的灵活性和可扩展性。

2、多态有两种主要的实现方式，分别是方法重写（子类重写父类的方法，提供不同的实现），以及接口多态（在Python中是继承同一个抽象基类）。

3、从上面的实现方式可以看出，继承是实现多态的基础。

总结

其实，从更广泛的意义上，有个“动态绑定”的概念，指的是在运行时才确定方法调用的目标，而非在编译时确定。在面向对象的语境下，动态绑定可以粗略的理解为就等同于多态。而在非面向对象的语境时，还有一种机制叫做“鸭子类型”。

鸭子类型和多态，都是践行开闭原则的方法，两者都是基于“动态绑定”的特性来实现。

关于“鸭子类型”的内容，我们在后面的文章中会进行介绍。

关于“多态”的内容就介绍到这里了，感谢您的拨冗阅读！