在Python项目里，我们常面临功能复用的选择：是用继承还是用组合。继承适合表达“是一个”的关系，但业务里很多情况只是“有一个”的能力。当功能交叉变多，深层继承会让子类被迫依赖父类实现，修改父类容易影响全部子类。组合把不同职责做成独立对象，再嵌入到需要使用它们的类里，能有效降低耦合。
继承方式的问题示例
假设我们要做一个带缓存和重试能力的文件读取器。用继承时，可能会先写基类再不断加子类：
class FileReader:
def read(self, path):
# 简单读取文件
with open(path, 'r') as f:
return f.read()
class CachedFileReader(FileReader):
def __init__(self):
self.cache = {}
def read(self, path):
if path in self.cache:
return self.cache[path]
data = super().read(path)
self.cache[path] = data
return data
class RetryCachedFileReader(CachedFileReader):
def read(self, path, retry=3):
for i in range(retry):
try:
return super().read(path)
except Exception:
if i == retry - 1:
raise
上面代码里，重试类必须清楚父类缓存读取的细节，层级加深后逻辑纠缠在一起。
用组合重构上述功能
我们把缓存和重试做成独立可复用的组件，由文件读取器持有它们：
class Cache:
def __init__(self):
self.store = {}
def get(self, key):
return self.store.get(key)
def put(self, key, value):
self.store[key] = value
class Retryer:
def do(self, func, retry=3):
for i in range(retry):
try:
return func()
except Exception:
if i == retry - 1:
raise
class ComposedFileReader:
def __init__(self):
self.cache = Cache()
self.retryer = Retryer()
def read(self, path):
cached = self.cache.get(path)
if cached is not None:
return cached
def load():
with open(path, 'r') as f:
return f.read()
data = self.retryer.do(load)
self.cache.put(path, data)
return data
组合带来的好处
- Cache和Retryer可单独测试与复用，不依赖文件读取
- ComposedFileReader只负责协调，不承担多套逻辑
- 新增功能如加密，只需加一个组件并嵌入，不影响旧代码
什么时候仍可用继承
当子类确实属于父类的特化，且不会横向叠加多种独立能力时，继承依然直观。例如动物与猫的关系。但多数业务复用场景，组合优于继承。
简单对比
| 维度 | 继承 | 组合 |
|---|---|---|
| 耦合度 | 高 | 低 |
| 扩展方式 | 改类层级 | 加组件对象 |
| 测试难度 | 较复杂 | 较简单 |
在Python中合理运用组合，可以让系统更容易应对需求变化，减少不必要的父类修改风险。