从基础到高级详解Python子类属性扩展的完全指南

class Person:
    """父类定义基础name属性"""
    def __init__(self, name):
        self._name = name
    
    @property
    def name(self):
        return self._name
    
    @name.setter
    def name(self, value):
        if not isinstance(value, str):
            raise TypeError("姓名必须是字符串")
        self._name = value

class VerifiedPerson(Person):
    """子类扩展name属性，添加额外验证"""
    def __init__(self, name):
        super().__init__(name)
    
    @property
    def name(self):
        # 在获取时添加日志记录
        print(f"访问姓名属性: {self._name}")
        return super().name
    
    @name.setter
    def name(self, value):
        # 添加长度验证
        if len(value) > 20:
            raise ValueError("姓名长度不能超过20个字符")
        print(f"修改姓名: {self._name} -> {value}")
        super(VerifiedPerson, VerifiedPerson).name.__set__(self, value)

# 使用示例
person = VerifiedPerson("张三")
person.name = "李四"  # 输出: 修改姓名: 张三 -> 李四
print(person.name)    # 输出: 访问姓名属性: 李四 \n 李四

class LoggedPerson(Person):
    """为属性访问添加日志功能"""
    @property
    def name(self):
        print(f"[LOG] 获取name属性值: {self._name}")
        return super().name
    
    @name.setter
    def name(self, value):
        print(f"[LOG] 设置name属性: {self._name} -> {value}")
        # 调用父类的setter方法
        super(LoggedPerson, LoggedPerson).name.__set__(self, value)

# 使用示例
logged_person = LoggedPerson("王五")
logged_person.name = "赵六"  # 输出: [LOG] 设置name属性: 王五 -> 赵六

class LengthCheckedPerson(Person):
    """只扩展setter方法，添加长度检查"""
    @Person.name.setter
    def name(self, value):
        if len(value) < 2:
            raise ValueError("姓名长度至少2个字符")
        if len(value) > 20:
            raise ValueError("姓名长度不能超过20个字符")
        super(LengthCheckedPerson, LengthCheckedPerson).name.__set__(self, value)

# 使用示例
checked_person = LengthCheckedPerson("小明")
try:
    checked_person.name = "A"  # 触发长度验证错误
except ValueError as e:
    print(f"错误: {e}")  # 输出: 错误: 姓名长度至少2个字符

class ValidatedDescriptor:
    """验证描述符，可重用于多个属性"""
    def __init__(self, name, expected_type, max_length=None):
        self.name = name
        self.expected_type = expected_type
        self.max_length = max_length
    
    def __get__(self, instance, owner):
        if instance is None:
            return self
        return instance.__dict__[f"_{self.name}"]
    
    def __set__(self, instance, value):
        if not isinstance(value, self.expected_type):
            raise TypeError(f"{self.name} 必须是 {self.expected_type.__name__}")
        if self.max_length and len(value) > self.max_length:
            raise ValueError(f"{self.name} 长度不能超过 {self.max_length}")
        instance.__dict__[f"_{self.name}"] = value

class PersonWithDescriptor:
    """使用描述符的Person类"""
    name = ValidatedDescriptor("name", str, 20)
    email = ValidatedDescriptor("email", str, 50)
    
    def __init__(self, name, email):
        self.name = name
        self.email = email

# 子类可以扩展描述符的行为
class LoggedPersonWithDescriptor(PersonWithDescriptor):
    """为描述符属性添加日志功能"""
    @property
    def name(self):
        print(f"[LOG] 访问name属性")
        return super().name
    
    @name.setter
    def name(self, value):
        print(f"[LOG] 修改name属性: {self.name} -> {value}")
        super(LoggedPersonWithDescriptor, LoggedPersonWithDescriptor).name.__set__(self, value)

class DataModel:
    """基础数据模型"""
    def __init__(self, data):
        self._data = data
    
    @property
    def data(self):
        return self._data
    
    @data.setter
    def data(self, value):
        self._data = value

class SanitizedDataModel(DataModel):
    """数据清洗扩展"""
    @property
    def data(self):
        # 获取时进行数据清洗
        raw_data = super().data
        return self._sanitize(raw_data)
    
    @data.setter
    def data(self, value):
        # 设置时进行验证和清洗
        sanitized_value = self._sanitize(value)
        if not self._validate(sanitized_value):
            raise ValueError("数据验证失败")
        super(SanitizedDataModel, SanitizedDataModel).data.__set__(self, sanitized_value)
    
    def _sanitize(self, data):
        """数据清洗逻辑"""
        if isinstance(data, str):
            return data.strip()
        return data
    
    def _validate(self, data):
        """数据验证逻辑"""
        return data is not None and data != ""

# 使用示例
model = SanitizedDataModel("  原始数据  ")
print(model.data)  # 输出: "原始数据"（已清洗）

class ExpensiveComputation:
    """基础计算类"""
    def __init__(self, base_value):
        self.base_value = base_value
    
    @property
    def result(self):
        # 模拟昂贵计算
        print("执行昂贵计算...")
        return sum(i * self.base_value for i in range(1000))

class CachedComputation(ExpensiveComputation):
    """添加缓存功能的计算类"""
    def __init__(self, base_value):
        super().__init__(base_value)
        self._cached_result = None
        self._is_dirty = True
    
    @property
    def result(self):
        if self._is_dirty or self._cached_result is None:
            print("计算并缓存结果...")
            self._cached_result = super().result
            self._is_dirty = False
        return self._cached_result
    
    @result.setter
    def result(self, value):
        # 设置基础值并标记缓存失效
        self.base_value = value
        self._is_dirty = True

# 使用示例
cached = CachedComputation(10)
print(cached.result)  # 第一次计算并缓存
print(cached.result)  # 直接使用缓存结果
cached.result = 20    # 修改基础值，缓存失效
print(cached.result)  # 重新计算

# 错误的实现 - 会导致无限递归
class BadExtension(Person):
    @property
    def name(self):
        return self.name  # 错误：这会导致递归调用自身

class CorrectExtension(Person):
    @property
    def name(self):
        return super().name  # 正确：调用父类实现