Python中的属性拦截与属性管理（__getattr__、__getattribute__、__setattr__、__delattr__）详解

属性拦截是Python面向对象编程中的一个高级特性，它允许你在访问、设置或删除对象属性时插入自定义逻辑。这主要通过四个特殊方法实现：__getattr__、__getattribute__、__setattr__ 和 __delattr__。

1. 基本概念与区别

• __getattr__(self, name): 当正常属性查找失败时被调用（即属性不存在时）
• __getattribute__(self, name): 每次属性访问时都会被调用，无论属性是否存在
• __setattr__(self, name, value): 在设置属性时被调用
• __delattr__(self, name): 在删除属性时被调用

2. __getattr__ 方法详解

当通过点号访问属性时，Python会按以下顺序查找：

1. 在实例的 __dict__ 中查找
2. 在类的 __dict__ 中查找
3. 在父类的 __dict__ 中查找
4. 如果都找不到，调用 __getattr__ 方法

class DynamicAttributes:
    def __init__(self):
        self.existing_attr = "我是已存在的属性"
    
    def __getattr__(self, name):
        """只有当属性不存在时才会被调用"""
        print(f"访问不存在的属性: {name}")
        return f"动态创建的属性: {name}"

obj = DynamicAttributes()
print(obj.existing_attr)  # 正常输出：我是已存在的属性
print(obj.non_existing)   # 触发__getattr__，返回："动态创建的属性: non_existing"

3. __getattribute__ 方法详解

这个方法会在每次属性访问时被调用，包括访问存在的和不存在的属性。使用时需要特别小心，容易导致无限递归。

class LoggingAttributes:
    def __init__(self):
        self.value = 10
    
    def __getattribute__(self, name):
        """每次属性访问都会调用"""
        print(f"访问属性: {name}")
        # 必须使用super()来避免递归
        return super().__getattribute__(name)

obj = LoggingAttributes()
print(obj.value)  # 先打印"访问属性: value"，然后输出10

4. __setattr__ 方法详解

在设置属性值时被调用，包括在 __init__ 方法中的赋值。

class ValidatedAttributes:
    def __init__(self):
        # 这里的赋值也会触发__setattr__
        self._data = {}
    
    def __setattr__(self, name, value):
        """设置属性时调用"""
        if name.startswith('_'):
            # 允许以下划线开头的属性
            super().__setattr__(name, value)
        elif not isinstance(value, (int, float, str)):
            raise ValueError(f"属性 {name} 的值必须是基本类型")
        else:
            # 将属性存储到_data字典中
            self._data[name] = value
    
    def __getattr__(self, name):
        """从_data字典中获取属性"""
        if name in self._data:
            return self._data[name]
        raise AttributeError(f"属性 {name} 不存在")

obj = ValidatedAttributes()
obj.name = "Python"    # 正常设置
obj.age = 20           # 正常设置
# obj.obj_list = []    # 会抛出ValueError

5. __delattr__ 方法详解

在删除属性时被调用。

class ProtectedAttributes:
    def __init__(self):
        self.important_data = "重要数据"
        self.temp_data = "临时数据"
    
    def __delattr__(self, name):
        """删除属性时调用"""
        if name == 'important_data':
            raise AttributeError("不能删除重要属性")
        else:
            print(f"删除属性: {name}")
            super().__delattr__(name)

obj = ProtectedAttributes()
del obj.temp_data      # 正常删除，打印"删除属性: temp_data"
# del obj.important_data  # 抛出AttributeError

6. 综合应用示例：实现一个属性代理

class AttributeProxy:
    """将属性访问代理到另一个对象"""
    def __init__(self, target):
        # 使用__setattr__来避免递归
        super().__setattr__('_target', target)
    
    def __getattr__(self, name):
        """将不存在的属性访问转发到目标对象"""
        return getattr(self._target, name)
    
    def __setattr__(self, name, value):
        """设置属性时也转发到目标对象"""
        setattr(self._target, name, value)
    
    def __delattr__(self, name):
        """删除属性时也转发到目标对象"""
        delattr(self._target, name)

class DataClass:
    def __init__(self):
        self.x = 1
        self.y = 2

original = DataClass()
proxy = AttributeProxy(original)

print(proxy.x)        # 输出: 1
proxy.z = 3           # 通过代理设置属性
print(original.z)     # 输出: 3

7. 注意事项和最佳实践

1. 避免递归：在 __getattribute__、__setattr__ 和 __delattr__ 中，必须使用 super() 或直接操作 __dict__ 来避免无限递归
2. 性能考虑：__getattribute__ 会影响所有属性访问的性能，谨慎使用
3. 明确意图：清楚区分 __getattr__（处理不存在的属性）和 __getattribute__（处理所有属性访问）

通过合理使用这些属性拦截方法，你可以实现动态属性创建、属性验证、代理模式等高级功能，大大增强Python类的灵活性。