Python `__getattr__`, `__setattr__`, `__delattr__`：实现属性代理与拦截

好的，各位观众，欢迎来到“Python 属性魔法秀”！今天我们要聊聊 Python 中三个非常酷炫的“魔法方法”：__getattr__，__setattr__ 和 __delattr__。准备好开启你的属性拦截和代理之旅了吗？系好安全带，我们这就出发！

第一幕：属性访问的幕后故事

在 Python 的世界里，当我们尝试访问一个对象的属性时（比如 obj.name），解释器会按照一定的顺序去寻找这个属性：

首先，它会在对象的 __dict__ 中查找。__dict__ 是一个存储对象属性的字典。
如果没有找到，它会沿着对象的类继承链向上查找。
如果还是找不到，它就会调用 __getattr__ 方法（如果定义了的话）。

__setattr__ 和 __delattr__ 则分别在属性被设置和删除时被调用。

第二幕：__getattr__：属性不存在时的救星

__getattr__ 方法就像一个守门员，当 Python 在对象的 __dict__ 和继承链中都找不到某个属性时，它就会挺身而出。

class MyClass:
    def __init__(self, name):
        self.name = name

    def __getattr__(self, attribute):
        print(f"尝试访问不存在的属性: {attribute}")
        return None  # 或者抛出一个 AttributeError 异常

在这个例子中，如果我们尝试访问 obj.age，因为 age 属性并不存在，__getattr__ 方法会被调用，打印一条消息并返回 None。

__getattr__ 的应用场景：动态属性和属性代理

动态属性： 我们可以使用 __getattr__ 来动态地创建属性。

class DynamicAttributes:
    def __init__(self, data):
        self.data = data

    def __getattr__(self, attribute):
        if attribute in self.data:
            return self.data[attribute]
        else:
            raise AttributeError(f"属性 '{attribute}' 不存在")

data = {"age": 30, "city": "New York"}
obj = DynamicAttributes(data)

print(obj.age)  # 输出: 30
print(obj.city) # 输出: New York

#print(obj.country) # 抛出 AttributeError

在这个例子中，__getattr__ 检查 data 字典中是否存在请求的属性。如果存在，就返回对应的值，否则抛出一个 AttributeError 异常。

属性代理： 我们可以使用 __getattr__ 将属性访问代理给另一个对象。

class InnerClass:
    def __init__(self):
        self.value = 42

    def get_value(self):
        return self.value

class OuterClass:
    def __init__(self):
        self.inner = InnerClass()

    def __getattr__(self, attribute):
        return getattr(self.inner, attribute)

obj = OuterClass()
print(obj.value)  # 输出: 42 (代理到 InnerClass 的 value 属性)
print(obj.getvalue()) #42

在这个例子中，OuterClass 的 __getattr__ 方法将属性访问代理给 InnerClass 的实例。

注意事项：

__getattr__ 只在属性查找失败时才会被调用。如果属性存在于对象的 __dict__ 或继承链中，__getattr__ 不会被触发。
如果你想阻止属性访问，应该抛出一个 AttributeError 异常。

第三幕：__setattr__：属性设置的拦截器

__setattr__ 方法允许我们拦截属性设置操作。每当我们尝试设置一个对象的属性时（比如 obj.name = "Alice"），__setattr__ 都会被调用。

class MyClass:
    def __init__(self, name):
        self.name = name

    def __setattr__(self, attribute, value):
        print(f"尝试设置属性: {attribute} = {value}")
        super().__setattr__(attribute, value)  # 调用父类的 __setattr__ 方法

在这个例子中，每当我们设置一个属性时，__setattr__ 方法会打印一条消息，然后调用父类的 __setattr__ 方法来实际设置属性。

__setattr__ 的应用场景：属性验证和只读属性

属性验证： 我们可以使用 __setattr__ 来验证属性的值。

class Person:
    def __init__(self, age):
        self.age = age

    def __setattr__(self, attribute, value):
        if attribute == "age":
            if not isinstance(value, int):
                raise TypeError("年龄必须是整数")
            if value < 0 or value > 150:
                raise ValueError("年龄必须在 0 到 150 之间")
        super().__setattr__(attribute, value)

person = Person(30)
person.age = 40  # 正常设置
#person.age = "abc"  # 抛出 TypeError
#person.age = -10  # 抛出 ValueError

在这个例子中，__setattr__ 方法检查 age 属性的值是否是整数，并且是否在 0 到 150 之间。如果不是，就抛出一个异常。

只读属性： 我们可以使用 __setattr__ 来创建只读属性。

class ReadOnly:
    def __init__(self, value):
        self._value = value

    def __setattr__(self, attribute, value):
        if attribute == "value":
            raise AttributeError("value 属性是只读的")
        super().__setattr__(attribute, value)

    def get_value(self):
        return self._value

obj = ReadOnly(42)
#obj.value = 100  # 抛出 AttributeError
print(obj.get_value()) #42

在这个例子中，__setattr__ 方法阻止对 value 属性的设置。

注意事项：

在 __setattr__ 方法中，一定要调用父类的 __setattr__ 方法（通常使用 super().__setattr__(attribute, value)）来实际设置属性，否则会导致无限递归。
如果你想完全阻止属性设置，可以不调用父类的 __setattr__ 方法，但这样做可能会导致一些问题，需要谨慎使用。

第四幕：__delattr__：属性删除的守护者

__delattr__ 方法允许我们拦截属性删除操作。每当我们尝试删除一个对象的属性时（比如 del obj.name），__delattr__ 都会被调用。

class MyClass:
    def __init__(self, name):
        self.name = name

    def __delattr__(self, attribute):
        print(f"尝试删除属性: {attribute}")
        super().__delattr__(attribute)  # 调用父类的 __delattr__ 方法

在这个例子中，每当我们删除一个属性时，__delattr__ 方法会打印一条消息，然后调用父类的 __delattr__ 方法来实际删除属性。

__delattr__ 的应用场景：阻止属性删除

我们可以使用 __delattr__ 来阻止属性删除。

class Immutable:
    def __init__(self, value):
        self.value = value

    def __delattr__(self, attribute):
        raise AttributeError("不能删除属性")

    def get_value(self):
        return self.value

    def set_value(self, new_value):
        self.value = new_value

obj = Immutable(42)
#del obj.value  # 抛出 AttributeError
print(obj.get_value()) #42
obj.set_value(10)
print(obj.get_value()) #10

在这个例子中，__delattr__ 方法总是抛出一个 AttributeError 异常，阻止任何属性的删除。

注意事项：

在 __delattr__ 方法中，一定要调用父类的 __delattr__ 方法（通常使用 super().__delattr__(attribute)）来实际删除属性，否则会导致属性无法被删除。
如果你想完全阻止属性删除，可以不调用父类的 __delattr__ 方法，但这样做可能会导致一些问题，需要谨慎使用。

第五幕：综合应用：属性访问控制

我们可以结合 __getattr__、__setattr__ 和 __delattr__ 来实现更复杂的属性访问控制。

class ProtectedAttributes:
    def __init__(self, data):
        self._data = data
        self._protected = ["secret"]

    def __getattr__(self, attribute):
        if attribute in self._protected:
            raise AttributeError("不能访问受保护的属性")
        return self._data.get(attribute)

    def __setattr__(self, attribute, value):
        if attribute in self._protected:
            raise AttributeError("不能设置受保护的属性")
        super().__setattr__(attribute, value)

    def __delattr__(self, attribute):
        if attribute in self._protected:
            raise AttributeError("不能删除受保护的属性")
        super().__delattr__(attribute)

data = {"name": "Alice", "age": 30, "secret": "password"}
obj = ProtectedAttributes(data)

print(obj.name)  # 输出: Alice
#print(obj.secret)  # 抛出 AttributeError

#obj.secret = "new_password"  # 抛出 AttributeError
#del obj.secret  # 抛出 AttributeError

在这个例子中，我们定义了一个 ProtectedAttributes 类，它使用 _protected 列表来存储受保护的属性。__getattr__、__setattr__ 和 __delattr__ 方法都会检查属性是否在 _protected 列表中，如果是，就抛出一个 AttributeError 异常。

第六幕：总结与进阶

恭喜各位，我们已经完成了 Python 属性魔法的学习！现在，你已经掌握了 __getattr__、__setattr__ 和 __delattr__ 这三个强大的工具，可以用来实现属性代理、属性验证、只读属性、属性访问控制等等。

表格总结：

方法	何时调用	作用
`__getattr__`	尝试访问不存在的属性时	1. 动态创建属性。 2. 将属性访问代理给另一个对象。 3. 抛出一个 `AttributeError` 异常来阻止属性访问。
`__setattr__`	尝试设置属性时	1. 验证属性的值。 2. 创建只读属性。 3. 在设置属性之前或之后执行一些操作。
`__delattr__`	尝试删除属性时	1. 阻止属性删除。 2. 在删除属性之前或之后执行一些操作。

进阶学习：

__getattribute__ 方法： __getattribute__ 方法会在每次属性访问时都被调用，无论属性是否存在。它比 __getattr__ 更加强大，但也更加危险，因为如果你不小心，可能会导致无限递归。
描述器（Descriptors）： 描述器是一种更加高级的属性访问控制机制，它可以让你更精确地控制属性的访问、设置和删除。

希望今天的讲座对你有所帮助！记住，熟练掌握这些“魔法方法”需要大量的实践。快去尝试一下吧，看看你能创造出什么样的属性魔法！

谢谢大家！我们下次再见！

Python `getattr`, `setattr`, `delattr`：实现属性代理与拦截

发表回复取消回复

发表回复 取消回复

发表回复取消回复