详解 Python 描述符协议：如何通过 __get__ 实现自定义属性访问

详解 Python 描述符协议：如何通过 get 实现自定义属性访问

Python 的描述符（Descriptor）是理解 Python 面向对象高级特性的关键。简单来说，描述符是一个实现了描述符协议中至少一个方法的对象，它可以控制类属性的访问（__get__）、设置（__set__）或删除（__delete__）行为。

本文将聚焦于描述符协议中最常用的方法之一：__get__，展示如何利用它来劫持属性的读取操作，实现自定义逻辑，例如访问计数、延迟加载或数据校验。

什么是 get？

当我们在一个实例或类上访问一个被描述符修饰的属性时，Python 解释器不会直接返回存储的值，而是调用描述符对象上的 __get__ 方法。

__get__ 方法的签名如下：

__get__(self, instance, owner)

参数详解：

1. ****self****: 描述符实例本身（即 AccessCounter 类的实例）。
2. ****instance****: 访问该属性的类实例。如果属性是通过类本身（而不是实例）访问的，则此参数为 None。
3. ****owner****: 拥有该属性的类（即客户端类，例如我们示例中的 DataStore）。

通过判断 instance 是否为 None，我们可以区分属性是通过实例访问还是通过类访问，并执行不同的逻辑。

实战示例：实现一个访问计数器

我们来实现一个简单的描述符 AccessCounter，它会记录属性被访问的次数，并在每次读取时打印日志。

1. 定义描述符类

class AccessCounter:
    """一个简单的描述符，用于统计属性被访问的次数，并自定义获取逻辑。"""

    def __init__(self, initial_value):
        # 存储内部值和计数器
        self._value = initial_value
        self.access_count = 0

    def __get__(self, instance, owner):
        """
        实现属性读取逻辑。
        """

        # 计数器递增
        self.access_count += 1

        # 打印访问日志
        print(f"[Log] 属性 '{owner.__name__}.{self.access_count}' 被访问了 {self.access_count} 次.")

        if instance is None:
            # 情况 1: 通过类访问 (e.g., DataStore.data_attribute)
            print(f"[Log] 属性通过类 {owner.__name__} 访问，返回描述符自身。\n")
            return self
        else:
            # 情况 2: 通过实例访问 (e.g., store.data_attribute)
            print(f"[Log] 属性通过实例 {instance} 访问，返回内部值。\n")
            # 在这里可以执行任何自定义读取逻辑，例如数据格式化
            return self._value.upper()

    # 为了演示完整性，我们添加一个简单的 __set__ 方法，让它成为数据描述符
    def __set__(self, instance, value):
        self._value = value
        print(f"[Log] 设置了新值：{value}")

2. 在客户端类中使用描述符

我们将 AccessCounter 实例作为类属性添加到 DataStore 中。

class DataStore:
    # 描述符实例必须是类属性
    data_attribute = AccessCounter(initial_value="Initial Data")

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

# 实例化客户端类
store_a = DataStore("A")
store_b = DataStore("B")

# --- 场景一：通过实例访问 (调用 __get__，instance 不是 None) ---
print("=== 第一次访问 (store_a) ===")
print(store_a.data_attribute)

print("=== 第二次访问 (store_b) (注意：计数器是共享的) ===")
print(store_b.data_attribute)

# --- 场景二：通过类访问 (调用 __get__，instance 是 None) ---
print("=== 第三次访问 (通过类) ===")
# 返回的是描述符对象本身
print(DataStore.data_attribute)

# --- 场景三：设置属性 (调用 __set__) ---
print("=== 设置属性 ===")
store_a.data_attribute = "New Value Set"

# 再次访问，观察值和计数器的变化
print("=== 第四次访问 (store_a) ===")
print(store_a.data_attribute)

运行结果片段：

=== 第一次访问 (store_a) ===
[Log] 属性 'DataStore.1' 被访问了 1 次.
[Log] 属性通过实例 <DataStore object at 0x...> 访问，返回内部值。
INITIAL DATA

=== 第二次访问 (store_b) (注意：计数器是共享的) ===
[Log] 属性 'DataStore.2' 被访问了 2 次.
[Log] 属性通过实例 <DataStore object at 0x...> 访问，返回内部值。
INITIAL DATA

=== 第三次访问 (通过类) ===
[Log] 属性 'DataStore.3' 被访问了 3 次.
[Log] 属性通过类 DataStore 访问，返回描述符自身。
<__main__.AccessCounter object at 0x...>

=== 设置属性 ===
[Log] 设置了新值：New Value Set

=== 第四次访问 (store_a) ===
[Log] 属性 'DataStore.4' 被访问了 4 次.
[Log] 属性通过实例 <DataStore object at 0x...> 访问，返回内部值。
NEW VALUE SET

总结

通过实现 __get__ 方法，我们成功地拦截了属性的读取操作：

1. 控制返回值： 在实例访问时，我们不仅返回了内部值，还将其转为大写（自定义逻辑）。
2. 副作用管理： 实现了访问计数器，每次访问都会触发计数和日志记录。
3. 区分访问类型： 通过检查 instance 参数是否为 None，我们区分了类访问和实例访问，并在类访问时返回了描述符对象本身，这是描述符的常见惯例。