提到多态，不少学过Java或C++的人第一反应是方法重写、虚函数、向上转型这一套机制。但转到Python之后，很多人会发现这里既没有virtual关键字，也没有编译期的类型检查，那Python到底有没有多态？答案是有的，而且Python的多态更彻底、更灵活，它是语言动态特性带来的天然结果。理解这一点，是写好Python面向对象代码的关键一步。
先弄清楚：多态的本质是什么
多态的字面意思是“多种形态”，即同一个接口，在不同对象上有不同的行为。举个例子，调用speak()方法，传进来的是狗就汪汪叫，是猫就喵喵叫，调用方不需要关心对象具体是什么类型，只管调用统一的方法名即可。
在Java这类静态语言中，多态需要一套完整的机制来支撑：编译期检查类型是否兼容，运行期通过虚方法表决定实际调用哪个实现。这套机制的前提是“类型必须明确声明”，也就是所谓的人型多态（基于类型的隐式多态）。
而Python是动态类型语言，变量只是对象的引用，没有固定的类型。调用方法时，解释器只关心一件事：这个对象身上有没有这个方法？有就调用，没有就抛出AttributeError。这种机制被形象地称为“鸭子类型”——走起来像鸭子、叫起来像鸭子，那它就是鸭子，管它基因上是不是鸭子。
Python中实现多态的几种方式
1. 通过继承和方法重写
最经典的方式还是继承体系下的方法重写。子类重写父类方法，调用方面向父类编程，运行时执行子类的实现：
class Animal:
def speak(self):
raise NotImplementedError("子类必须实现speak方法")
class Dog(Animal):
def speak(self):
return "汪汪"
class Cat(Animal):
def speak(self):
return "喵喵"
def make_sound(animal):
# 不关心具体类型，只管调用
print(animal.speak())
make_sound(Dog()) # 输出：汪汪
make_sound(Cat()) # 输出：喵喵
注意make_sound函数没有任何类型声明，它对参数的唯一要求就是“必须有speak方法”。这和Java里写Animal animal参数截然不同——Python根本不检查传入对象是否是Animal的实例。
2. 鸭子类型：不继承也能多态
这是Python最有特色的地方。两个完全没有任何继承关系的类，只要有同名方法，就可以互换使用：
class Duck:
def speak(self):
return "嘎嘎"
class Robot:
def speak(self):
return "哔哔哔"
def make_sound(obj):
print(obj.speak())
make_sound(Duck()) # 输出：嘎嘎
make_sound(Robot()) # 输出：哔哔哔
Robot和Duck没有共同的父类，但它们在make_sound眼里是等价的。这种设计让代码耦合度极低，你不需要为了复用某个方法而去强行继承一个基类。Python内置的很多协议就是这么工作的，比如实现了__len__的对象都能被len()函数处理，实现了__iter__的对象都能被for循环遍历，不管它是列表、字典还是你自己写的类。
3. 抽象基类：给多态加上约束
鸭子类型虽然灵活，但也有风险：如果对象忘了实现某个方法，错误要到运行时才会暴露。Python标准库提供了abc模块来解决这个问题：
from abc import ABC, abstractmethod
class Shape(ABC):
@abstractmethod
def area(self):
pass
class Circle(Shape):
def __init__(self, r):
self.r = r
def area(self):
return 3.14159 * self.r ** 2
class Rect(Shape):
def __init__(self, w, h):
self.w = w
self.h = h
def area(self):
return self.w * self.h
# shape = Shape() # 直接实例化抽象类会报错TypeError
for s in (Circle(2), Rect(3, 4)):
print(s.area()) # 分别输出 12.56636 和 12
抽象基类在实例化时会做检查，子类没有实现所有抽象方法就无法创建实例，把错误提前到了对象创建阶段。这在多人协作或对外提供接口库时特别有用，相当于给鸭子类型加了一层契约。
4. 使用typing.Protocol做结构化类型检查
如果你既想要鸭子类型的灵活性，又想在类型注解和静态检查工具中表达清楚意图，Python 3.8之后引入的Protocol是更好的选择：
from typing import Protocol
class Speaker(Protocol):
def speak(self) -> str: ...
def make_sound(obj: Speaker):
print(obj.speak())
class Person: # 不需要显式继承Speaker
def speak(self):
return "你好"
make_sound(Person()) # mypy静态检查可通过
Protocol属于结构化类型（静态鸭子类型），只要对象的方法签名匹配，类型检查器如mypy就认为它满足协议，无需显式继承。这算是把Python两种世界的优点结合了起来。
动态语言与静态语言的多态对比
理解两者的差异能帮助你写出更地道的Python代码。Java的多态是“基于类型的多态”，核心逻辑是：编译期保证类型安全，运行期通过虚函数分派。好处是错误发现早，重构有工具支撑；代价是必须维护庞大的类型层次结构。
Python的多态是“基于行为的多态”，核心逻辑是：运行期查找属性并调用。好处是极度灵活，代码量少，扩展新类型不需要改动既有调用代码；代价是方法拼写错误、漏实现等问题要等到运行时才暴露，因此大型Python项目更依赖单元测试和mypy这类静态检查工具。
另外值得一提的是，Python没有传统意义的方法重载。写两个同名的__init__，后者会直接覆盖前者。如果需要根据不同参数形态执行不同逻辑，通常的做法是给参数设置默认值、使用可变参数*args和**kwargs，或者借助functools.singledispatch实现基于类型的分派：
from functools import singledispatch
@singledispatch
def process(data):
print("默认处理：", data)
@process.register
def _(data: int):
print("处理整数：", data * 2)
@process.register
def _(data: str):
print("处理字符串：", data.upper())
process(10) # 处理整数： 20
process("abc") # 处理字符串： ABC
这种基于类型注解的分派机制，某种程度上补上了Python缺少重载的短板。
实际项目中如何用好多态
多态最大的价值在于消灭if-elif分支。假设你在做一个支付系统，最初的写法可能是这样：
def pay(channel, amount):
if channel == "alipay":
print(f"调用支付宝接口支付{amount}元")
elif channel == "wechat":
print(f"调用微信接口支付{amount}元")
elif channel == "bank":
print(f"调用银行接口支付{amount}元")
else:
raise ValueError("不支持的渠道")
每次新增支付渠道都要修改pay函数，违背了开闭原则。用多态重构后：
class Payment:
def pay(self, amount):
raise NotImplementedError
class Alipay(Payment):
def pay(self, amount):
print(f"调用支付宝接口支付{amount}元")
class WechatPay(Payment):
def pay(self, amount):
print(f"调用微信接口支付{amount}元")
def pay(payment: Payment, amount):
payment.pay(amount)
# 新增渠道只需新增一个类，调用代码零改动
更进一步，如果渠道类已经存在且不便修改，还可以结合__init_subclass__或注册表模式，把渠道名到类的映射维护在一个字典里，实现按配置动态加载。这些手段的底层思想都是同一个：让调用方依赖抽象接口，把变化封装在具体实现里。
总结一下，Python的多态是隐式的、天然的，它不靠关键字和类型声明，而靠“运行时属性查找”这一底层机制。日常写代码时，优先考虑鸭子类型保持灵活性，在需要明确契约的地方引入抽象基类或Protocol，在需要类型分派时用singledispatch。把这些工具用对场景，你的Python代码会既灵活又可靠。