在 Python 中，多态并非偶然的调用成功，而是一种可以被反复依赖的行为模式。这种可依赖性并非来自类型约束，而来自一个更为关键的前提——行为一致性。
6.1 行为一致性的含义
行为一致性并不要求不同对象在内部实现上相同，而是指：在相同的使用语境中，不同对象对同类调用持续给出符合约定语义的行为结果。
# 不同容器类型，相同的迭代行为def process_items(container): for item in container: # 任何可迭代对象都能工作 print(item)# 行为一致，实现各异process_items([1, 2, 3]) # 列表process_items((1, 2, 3)) # 元组process_items({1, 2, 3}) # 集合process_items({"a": 1, "b": 2}) # 字典（迭代键）process_items(range(10)) # range对象
在这些例子中，container 只需满足一个条件：能够被迭代并逐个产生元素。调用方并不关心它是否基于索引、哈希结构或动态计算。
一致的不是结构，而是：
• 调用方式一致
• 行为语义一致
• 使用结果可预期
6.2 语义一致而非实现一致
Python 的多态模型真正依赖的是语义一致性（Semantic Consistency）。
# 相同的语义：获取对象长度/大小def display_size(obj): size = len(obj) # 依赖__len__返回有意义的"大小" print(f"Size: {size}")display_size("hello") # 5 (字符数)display_size([1, 2, 3, 4]) # 4 (元素个数)display_size({"a": 1, "b": 2}) # 2 (键值对数量)
关键不在于返回值如何计算，而在于返回值是否合理表达了“大小”这一语义。
语义不符的实现会破坏多态：
class BadLength: def __len__(self): return -1 # 负数的"大小"没有意义display_size(BadLength()) # 能调用但语义错误
这说明：多态不是“能运行即可”，而是“行为是否长期可信”。
Python 接受实现差异，但依赖语义一致。
6.3 方法名并非多态核心
初学者常将多态理解为“不同对象实现同名方法”，但在 Python 中，这一条件并不充分。
# 同名方法，不同语义class FileHandler: def save(self): """保存到文件系统""" with open("data.txt", "w") as f: f.write("data")class DatabaseHandler: def save(self): """提交数据库事务""" self.connection.commit()class CacheHandler: def save(self): """缓存当前状态""" self.cache.update(self.state)# 仅仅方法名相同，语义可能完全不同handlers = [FileHandler(), DatabaseHandler(), CacheHandler()]for handler in handlers: handler.save() # 调用成功，但语义各异
从语法层面看，上述示例确实构成了一种“形式上的多态”：多个对象都暴露了同名的 save() 方法，调用也都能够成功完成。但这种一致性仅停留在调用入口层面，而未必形成可依赖的多态行为。
对于调用方而言，真正重要的问题并不是：“这个对象有没有 save() 方法？”，而是：“在当前使用语境中，调用 save() 究竟意味着什么？”
如果调用方在业务逻辑中假定 save() 具有某种明确效果（例如“数据已可靠持久化”），那么这些对象实际上并不可互换。
因此，在 Python 中，方法名相同只是多态的必要条件之一，却远非充分条件。
真正支撑多态的，并不是方法的名字，而是围绕该方法形成的稳定语义约定：包括其副作用、时机保证、失败方式以及可重复调用的行为特征。
方法名只是调用入口，行为语义才是多态的核心。
如果调用方未明确约定方法的语义边界，那么即便方法名相同，也无法构成稳定、可替换的多态接口。
6.4 属性访问中的多态
Python 的所有能力都通过属性访问暴露，多态同样如此。
def read_data(source, size=1024): return source.read(size)
class FileReader: def read(self, size=-1): """读取指定字节数，指针前移""" return self.file.read(size)class BufferReader: def read(self, size=-1): """从缓冲区读取数据""" if size == -1: return self.buffer return self.buffer[:size]class NetworkStream: def read(self, size=-1): """从网络流读取数据""" return self.socket.recv(size if size > 0 else 4096)
在 read_data(source) 的调用语境中，调用方并不关心 source 是文件、缓冲区还是网络流，而是依赖这样一个事实：通过 read() 属性访问，能够按约定获得一段数据。
只要对象在以下方面保持一致：
• 调用方式稳定
• 返回值的语义明确
• 关键行为（如读取范围、阻塞特性）符合约定
那么属性访问本身就构成了一种多态接口。
这说明，在 Python 中，多态并不局限于“方法是否同名”，也可通过统一的属性访问语义自然形成。
6.5 协作语境中的行为一致性
多态真正的价值，体现在对象在协作体系中的可替换性。
# 数据处理管道中的行为一致性def process_pipeline(source, transformer, sink): """只要各组件行为一致，就能协同工作""" data = source.read() # 一致的读取语义 processed = transformer(data) # 一致的转换语义 sink.write(processed) # 一致的写入语义def encrypt(data): return data[::-1] # 示意：反转字节序def compress(data): return data # 示意：假装压缩# 可以任意替换组件实现class FileSource: def read(self, size=-1): with open("input.txt", "rb") as f: return f.read(size)class NetworkSource: def read(self, size=-1): return self.socket.recv(size if size > 0 else 4096)class EncryptTransformer: def __call__(self, data): return encrypt(data)class CompressTransformer: def __call__(self, data): return compress(data)class FileSink: def write(self, data): with open("output.bin", "wb") as f: f.write(data)class NetworkSink: def write(self, data): self.socket.sendall(data)# 任意组合都能工作process_pipeline(FileSource(), EncryptTransformer(), FileSink())process_pipeline(NetworkSource(), CompressTransformer(), NetworkSink())
上述示例强调的是：多态并不是孤立存在的，而是在对象协作中才真正显现价值。
在这个管道模型中，每个对象只承担一个清晰角色：
• source 提供数据
• transformer 处理数据
• sink 接收结果
调用方只依赖这些角色在协作边界上的行为约定，而不关心具体实现。
只要各对象在协作点上保持行为一致：
• 输入与输出的语义不变
• 调用方式不变
• 副作用可预期
就可以在不修改调用代码的前提下，自由替换实现。
因此，这里的多态不是“对象之间的关系”，而是对象在协作体系中的可替换性。
6.6 行为一致性的实践保障
既然 Python 不强制接口和类型约束，一个自然的问题是：行为一致性靠什么来保证？
答案很简单：靠约定和验证，而不是靠语法。
在实践中，Python 通常通过三件事来维持多态的可靠性：
• 用文档或抽象基类说明“应该怎么用”
• 用测试验证“是否真的按约定工作”
• 用稳定的调用方式形成事实上的接口
# 通过文档和测试明确语义约定from abc import ABC, abstractmethodclass DataSource(ABC): """数据源协议：必须实现read方法，返回字节数据""" @abstractmethod def read(self, size=-1) -> bytes: """ 读取数据 :param size: 读取的字节数，-1表示读取全部 :return: 字节数据，读取完毕返回空字节串 """ pass# 测试验证行为一致性def test_data_source(source): """验证数据源协议的一致性""" # 验证基本读取 data = source.read(10) assert isinstance(data, bytes), "必须返回bytes" # 验证边界条件 all_data = source.read(-1) assert isinstance(all_data, bytes) # 验证多次读取的连贯性 if hasattr(source, 'seek'): source.seek(0) first = source.read(5) second = source.read(5) assert len(first + second) >= 5# 所有实现都应通过此测试test_data_source(FileSource())test_data_source(NetworkSource())
抽象基类与测试在这里的作用，并不是“强制统一实现”，而是将行为约定显性化、可验证化。
DataSource 抽象基类明确了 read() 方法的语义边界：
• 返回什么类型
• 特殊参数的含义
• 行为何时结束
而测试代码则把这些约定转化为可执行的事实检查。
在 Python 中，只要一个实现能够通过这些测试，它就被视为“行为上等价”，可以被安全替换。
多态因此不依赖编译期检查，而依赖：
• 明确的语义约定
• 稳定的调用方式
• 持续的行为验证
这正是 Python 工程实践中，多态得以长期成立的现实保障。
📘 小结
在 Python 中，多态的根基不在类型或继承结构，而在对象是否持续履行约定的行为语义。只要在既定使用语境中保持调用方式、语义含义与结果预期的一致，对象便具备可替换性。多态因此不是语法特性，而是一种由协作关系与实践验证共同维系的行为事实。
