Python OOP 设计思想 13:封装服务于演化

# 未考虑变化的封装class User:    def __init__(self, name, email):        self.name = name        self.email = email        self._storage = {}  # 内部数据结构直接暴露    def save(self):        # 直接将内部数据保存        self._storage["name"] = self.name        self._storage["email"] = self.email        return self._storage# 调用方依赖内部结构user = User("艾婉婷", "xiaoai@example.com")data = user.save()print(data["name"])  # 直接访问内部数据结构

# 良好封装的示例：可替换实现class DataStore:    """稳定的接口：只承诺读写能力"""    def save(self, key, value):        """保存数据，具体实现可替换"""        raise NotImplementedError    def load(self, key):        """加载数据，具体实现可替换"""        raise NotImplementedErrorclass FileDataStore(DataStore):    """文件存储实现"""    def save(self, key, value):        with open(f"{key}.txt", "w") as f:            f.write(str(value))    def load(self, key):        with open(f"{key}.txt") as f:            return f.read()class MemoryDataStore(DataStore):    """内存存储实现"""    def __init__(self):        self._data = {}    def save(self, key, value):        self._data[key] = value    def load(self, key):        return self._data.get(key)# 调用方只依赖稳定接口def process_data(store: DataStore, data):    """可以在不修改调用方的情况下替换 store 实现"""    store.save("result", data)    return store.load("result")# 可以轻松切换实现file_store = FileDataStore()memory_store = MemoryDataStore()process_data(file_store, "file data")     # 使用文件存储process_data(memory_store, "mem data")    # 切换到内存存储

# 接口的演进示例class StorageV1:    def save(self, data):        return self._save_to_file(data)    def _save_to_file(self, data):        return f"saved:{data}"class StorageV2(StorageV1):    """演进版本：扩展功能但不破坏原有接口"""    def save(self, data, compress=False):        """增强版本：支持压缩选项"""        if compress:            data = self._compress(data)        return self._save_to_file(data)    def _compress(self, data):        """新增内部方法，不影响接口"""        return f"compressed:{data}"# 原有调用方继续工作storage = StorageV2()storage.save("data")           # 原有调用方式storage.save("data", True)     # 新增调用方式

# 封装失败的模式class ConfigManager:    def __init__(self):        # 问题 1：使用单个下划线，暗示"受保护"但实际上仍然公开        self._settings = {}    # 调用方可能直接修改        self._cache = []       # 内部实现细节暴露    # 允许直接访问内部数据    def get_raw_settings(self):        return self._settings    # 问题 2：返回内部可变对象的引用    # 调用方需要知道内部结构才能使用    def update_setting(self, key, value):        self._settings[key] = value        self._cache.clear()    # 问题 3：调用方不知道这个副作用# 更好的封装class ConfigManager2:    def __init__(self):        # 正确：使用双下划线前缀实现名称改写        self.__settings = {}        self.__cache = []    # 内部细节完全隐藏    def get_setting(self, key):        """稳定接口：返回值的副本"""        return self.__settings.get(key)    # 正确：返回数据的副本或不可变值，而不是引用    def update_setting(self, key, value):        """        正确：明确的接口，清晰的副作用        提供完整的操作语义：        1. 更新设置        2. 清空缓存（副作用在文档中说明）        3. 返回旧值（完整的事务语义）        """        old = self.__settings.get(key)        self.__settings[key] = value        self.__cache.clear()    # 副作用在方法名或文档中应明确说明        return old    # 明确返回旧值，提供完整信息

# 为变化预留空间的封装class PaymentProcessor:    """最小化接口：为演化预留空间"""    def process(self, amount, **options):        """        处理支付        Args:            amount: 金额            **options: 未来扩展参数        Returns:            支付结果        """        # 保持核心语义稳定        result = self._do_process(amount, options)        return self._format_result(result)    def _do_process(self, amount, options):        """可替换的实现细节"""        # 当前实现        return {"status": "success", "amount": amount}    def _format_result(self, raw_result):        """可调整的输出格式化"""        return raw_result  # 目前原样返回，未来可调整# 未来扩展时不破坏接口class EnhancedPaymentProcessor(PaymentProcessor):    def _do_process(self, amount, options):        # 增强处理逻辑但不改变接口        if options.get("currency") == "USD":            amount = amount * 0.85  # 汇率转换        return {"status": "success", "amount": amount, "currency": options.get("currency", "CNY")}

# 阶段 1：简单功能，轻量封装def calculate_total(prices):    """简单函数，最小封装"""    return sum(prices)# 阶段 2：功能扩展，引入类封装class OrderCalculator:    """类封装：支持更多功能"""    def calculate_total(self, prices, discount=0):        total = sum(prices)        return total * (1 - discount/100)    def calculate_tax(self, total, tax_rate):        return total * tax_rate# 阶段 3：复杂业务，完整封装class OrderProcessor:    """完整封装：隐藏所有实现细节"""    def __init__(self, tax_calculator, discount_strategy):        self.tax_calc = tax_calculator        self.discount = discount_strategy    def process(self, order):        # 完全封装计算逻辑        subtotal = self._calculate_subtotal(order.items)        discount = self.discount.apply(subtotal, order.customer)        total = subtotal - discount        tax = self.tax_calc.calculate(total, order.region)        return total + tax    def _calculate_subtotal(self, items):        """私有方法：实现细节完全隐藏"""        return sum(item.price * item.quantity for item in items)