Python的描述符（Descriptors）：深入理解`__get__`、`__set__`和`__delete__`在属性访问中的底层机制。

Python描述符：掌控属性访问的艺术

各位朋友，大家好！今天我们来深入探讨Python中一个强大而又有些神秘的特性：描述符（Descriptors）。 描述符是Python中实现属性访问控制的核心机制，理解它能让你对Python面向对象编程的底层运作有更深刻的认识，并能编写出更灵活、更可控的代码。

1. 什么是描述符？

简单来说，描述符是一个实现了特定协议的Python对象，它能控制对类属性的访问行为。这个协议由三个特殊方法组成：__get__、__set__和__delete__。 当你试图访问、设置或删除一个类的属性时，如果该属性是一个描述符对象，Python就会调用这些方法来处理相应的操作。

更正式的定义是：如果一个类定义了__get__、__set__或__delete__中的任何一个方法，那么它的实例就可以被认为是描述符。

2. 描述符协议的核心：__get__、__set__和__delete__

• __get__(self, instance, owner): 这个方法用于访问描述符属性。

  • self: 描述符实例本身。
  • instance: 拥有该描述符属性的类的实例。如果通过类来访问描述符属性，instance 将为 None。
  • owner: 拥有该描述符属性的类本身。

  返回值是描述符属性的值。

• __set__(self, instance, value): 这个方法用于设置描述符属性的值。

  • self: 描述符实例本身。
  • instance: 拥有该描述符属性的类的实例。
  • value: 要设置的新值。

  此方法通常返回 None。

• __delete__(self, instance): 这个方法用于删除描述符属性。

  • self: 描述符实例本身。
  • instance: 拥有该描述符属性的类的实例。

  此方法通常返回 None。

3. 描述符的种类：数据描述符与非数据描述符

描述符根据是否同时定义了__get__和__set__方法，可以分为两类：

• 数据描述符 (Data Descriptor): 同时定义了__get__和__set__方法。数据描述符对属性的访问具有优先控制权。

• 非数据描述符 (Non-Data Descriptor): 只定义了__get__方法。非数据描述符通常用于实现只读属性或方法。

这两者之间的区别在于属性查找的优先级。当访问一个属性时，Python会按照一定的顺序进行查找，这个顺序对于数据描述符和非数据描述符是不同的。

4. 属性查找的优先级

了解描述符之前，必须了解Python的属性查找机制。 当访问一个对象的属性时，Python会按照以下顺序进行查找：

1. 实例字典 (instance.__dict__): 首先在实例的 __dict__ 中查找。
2. 类字典 (Class.__dict__): 如果在实例字典中找不到，则在类的 __dict__ 中查找。
3. 继承链: 如果类有父类，则沿着继承链向上查找父类的 __dict__。

如果找到的属性是一个描述符，则会调用相应的描述符方法。 关键在于描述符在类字典中的位置会影响属性查找的顺序。

• 数据描述符: 如果在类的 __dict__ 中找到一个数据描述符，Python会优先调用该描述符的 __get__ 和 __set__ 方法，即使实例的 __dict__ 中也存在同名的属性。

• 非数据描述符: 如果在类的 __dict__ 中找到一个非数据描述符，并且实例的 __dict__ 中也存在同名的属性，Python会优先返回实例 __dict__ 中的属性值。 这意味着实例属性会 "遮蔽" 非数据描述符。

可以用下表来总结：

查找顺序	位置	属性类型	行为
1	instance.__dict__	任何属性	直接返回属性值。
2	Class.__dict__	数据描述符	调用描述符的 __get__ 方法。
3	Class.__dict__	非数据描述符	调用描述符的 __get__ 方法，除非 instance.__dict__ 中存在同名属性，此时返回 instance.__dict__ 中的属性值。
4	Class.__dict__	普通属性	直接返回属性值。
5	继承链	根据属性类型重复上述步骤	沿着类的继承链向上查找，重复上述步骤。

5. 描述符的应用场景与示例

描述符在Python中有很多应用场景，例如：

• 属性验证: 确保属性值满足特定条件。
• 只读属性: 防止属性被修改。
• 延迟计算: 只在需要时才计算属性值。
• 属性代理: 将属性访问委托给另一个对象。
• ORM (Object-Relational Mapping): 将数据库字段映射到对象属性。

下面我们通过一些具体的例子来演示描述符的使用。

示例 1：属性验证

假设我们需要创建一个表示温度的类，要求温度值必须在一定范围内。 我们可以使用描述符来实现属性验证。

class Temperature:
    def __init__(self, celsius=0):
        self._celsius = celsius

    def to_fahrenheit(self):
        return (self._celsius * 9/5) + 32

    def get_celsius(self):
        return self._celsius

    def set_celsius(self, value):
        if value < -273.15:
            raise ValueError("Temperature cannot be below -273.15 Celsius")
        self._celsius = value

    celsius = property(get_celsius, set_celsius)

# 不使用描述符验证
temperature = Temperature()
temperature.celsius = -300
print(temperature.celsius)

这个例子使用了property来实现属性验证。 property实际上是一种内置的描述符。 现在，我们用自定义的描述符来实现相同的功能。

class ValidatedTemperature:
    def __init__(self, celsius=0):
        self._celsius = celsius

    def to_fahrenheit(self):
        return (self._celsius * 9/5) + 32

    def get_celsius(self):
        return self._celsius

    def set_celsius(self, value):
        if value < -273.15:
            raise ValueError("Temperature cannot be below -273.15 Celsius")
        self._celsius = value

    @property
    def celsius(self):
        return self.get_celsius()

    @celsius.setter
    def celsius(self, value):
        self.set_celsius(value)

# 使用 @property 验证
temperature = ValidatedTemperature()
try:
    temperature.celsius = -300
    print(temperature.celsius)
except ValueError as e:
    print(e)

现在我们使用更底层的描述符来实现温度验证：

class Celsius:
    def __get__(self, instance, owner):
        return instance._celsius

    def __set__(self, instance, value):
        if value < -273.15:
            raise ValueError("Temperature cannot be below -273.15 Celsius")
        instance._celsius = value

class Temperature:
    celsius = Celsius()  # 描述符实例

    def __init__(self, celsius=0):
        self._celsius = celsius

    def to_fahrenheit(self):
        return (self._celsius * 9/5) + 32

# 使用描述符验证
temperature = Temperature()
try:
    temperature.celsius = -300
    print(temperature.celsius)
except ValueError as e:
    print(e)

temperature.celsius = 25
print(temperature.celsius)

在这个例子中，Celsius 类是一个描述符，它实现了 __get__ 和 __set__ 方法。 Temperature 类使用 Celsius 描述符来控制对 celsius 属性的访问。 当我们尝试设置 temperature.celsius 时，Celsius 描述符的 __set__ 方法会被调用，从而实现属性验证。

示例 2：只读属性

有时候我们需要创建只读属性，即属性的值只能在对象创建时设置，之后不能被修改。 我们可以使用描述符来实现只读属性。

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

    def __get__(self, instance, owner):
        return self._value

    def __set__(self, instance, value):
        raise AttributeError("Cannot set read-only attribute")

class MyClass:
    read_only = ReadOnlyProperty(10)

    def __init__(self):
        pass

obj = MyClass()
print(obj.read_only)  # 输出: 10

try:
    obj.read_only = 20  # 尝试修改只读属性
except AttributeError as e:
    print(e)  # 输出: Cannot set read-only attribute

在这个例子中，ReadOnlyProperty 类是一个描述符，它只实现了 __get__ 方法，而 __set__ 方法抛出一个 AttributeError 异常。 当尝试设置 obj.read_only 时，ReadOnlyProperty 描述符的 __set__ 方法会被调用，从而阻止属性被修改。

示例 3：延迟计算

延迟计算是一种优化技术，它只在真正需要时才计算属性值。 我们可以使用描述符来实现延迟计算。

import time

class LazyProperty:
    def __init__(self, func):
        self.func = func
        self._value = None

    def __get__(self, instance, owner):
        if self._value is None:
            print("Calculating value...")
            self._value = self.func(instance)
        return self._value

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

    @LazyProperty
    def expensive_attribute(self):
        # 模拟一个耗时的计算过程
        time.sleep(2)
        return self.data * 2

obj = MyClass(5)
print("First access:")
print(obj.expensive_attribute)  # 第一次访问，会进行计算

print("Second access:")
print(obj.expensive_attribute)  # 第二次访问，直接返回缓存的值

在这个例子中，LazyProperty 类是一个描述符，它实现了 __get__ 方法。 当第一次访问 obj.expensive_attribute 时，LazyProperty 描述符的 __get__ 方法会被调用，它会调用 func (这里是 expensive_attribute 方法) 来计算属性值，并将结果缓存到 self._value 中。 之后再次访问 obj.expensive_attribute 时，LazyProperty 描述符的 __get__ 方法会直接返回缓存的值，而不会再次进行计算。

示例 4：属性代理

属性代理是指将属性访问委托给另一个对象。 我们可以使用描述符来实现属性代理。

class Delegate:
    def __init__(self, delegate_obj, attribute_name):
        self.delegate_obj = delegate_obj
        self.attribute_name = attribute_name

    def __get__(self, instance, owner):
        return getattr(self.delegate_obj, self.attribute_name)

    def __set__(self, instance, value):
        setattr(self.delegate_obj, self.attribute_name, value)

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

class OuterClass:
    def __init__(self, inner_obj):
        self.inner = inner_obj
        self.delegated_value = Delegate(self.inner, 'value')

inner = InnerClass(10)
outer = OuterClass(inner)

print(outer.delegated_value)  # 输出: 10
outer.delegated_value = 20
print(outer.delegated_value)  # 输出: 20
print(inner.value)  # 输出: 20 (inner 对象的 value 也被修改了)

在这个例子中，Delegate 类是一个描述符，它实现了 __get__ 和 __set__ 方法。 OuterClass 使用 Delegate 描述符来将 delegated_value 属性的访问委托给 inner 对象的 value 属性。 当我们访问或设置 outer.delegated_value 时，实际上是在访问或设置 inner.value。

6. __set_name__ (Python 3.6+)

从 Python 3.6 开始，描述符还支持 __set_name__(self, owner, name) 方法。 这个方法会在类创建时被自动调用，用于将描述符实例与类的属性名关联起来。 这在某些情况下可以简化代码，避免硬编码属性名。

class MyDescriptor:
    def __set_name__(self, owner, name):
        self.public_name = name
        self.private_name = '_' + name

    def __get__(self, instance, owner):
        return getattr(instance, self.private_name)

    def __set__(self, instance, value):
        setattr(instance, self.private_name, value)

class MyClass:
    my_attribute = MyDescriptor()

    def __init__(self, my_attribute):
        setattr(self, 'my_attribute', my_attribute)  # 使用 setattr 避免再次触发描述符的 __set__

obj = MyClass(10)
print(obj.my_attribute)  # 输出: 10
obj.my_attribute = 20
print(obj.my_attribute)  # 输出: 20

在这个例子中，MyDescriptor 的 __set_name__ 方法会在 MyClass 创建时被调用，它会将 self.public_name 设置为 "my_attribute"，并将 self.private_name 设置为 "_my_attribute"。 这样，在 __get__ 和 __set__ 方法中，我们就可以使用 self.private_name 来访问实例的私有属性，而无需硬编码属性名。 这提高了代码的可读性和可维护性。

7. 描述符与元类

描述符和元类都是Python中高级的特性，它们可以一起使用来实现更复杂的属性控制。 元类可以用来在类创建时自动应用描述符。

class AutoDescriptor(type):
    def __new__(cls, name, bases, attrs):
        for attr_name, attr_value in attrs.items():
            if isinstance(attr_value, Celsius):
                attr_value.__set_name__(cls, attr_name)  # Manually call __set_name__
        return super().__new__(cls, name, bases, attrs)

class Celsius:
    def __set_name__(self, owner, name):
        self.name = name

    def __get__(self, instance, owner):
        return instance.__dict__[self.name]

    def __set__(self, instance, value):
        if value < -273.15:
            raise ValueError("Temperature cannot be below -273.15 Celsius")
        instance.__dict__[self.name] = value

class Temperature(metaclass=AutoDescriptor):
    celsius = Celsius()  # 描述符实例

    def __init__(self, celsius=0):
        self.celsius = celsius

    def to_fahrenheit(self):
        return (self.celsius * 9/5) + 32

temperature = Temperature()
try:
    temperature.celsius = -300
    print(temperature.celsius)
except ValueError as e:
    print(e)

temperature.celsius = 25
print(temperature.celsius)

在这个例子中，AutoDescriptor 是一个元类，它会在类创建时自动遍历类的属性，如果发现有 Celsius 类型的属性，就调用其 __set_name__ 方法，将属性名传递给描述符。 这样，我们就可以避免在每个使用 Celsius 描述符的类中都手动调用 __set_name__ 方法。

8. 描述符的注意事项

• 性能: 描述符会增加属性访问的开销，因为每次访问属性都需要调用描述符的方法。 因此，应该谨慎使用描述符，只在真正需要控制属性访问行为时才使用。

• 命名冲突: 如果描述符的属性名与实例的属性名相同，可能会导致命名冲突。 为了避免这种情况，可以使用私有属性名（以下划线开头）。

• 理解属性查找顺序: 理解Python的属性查找顺序是理解描述符的关键。 数据描述符和非数据描述符在属性查找中的优先级不同，这会影响属性访问的行为。

最后的话，掌握属性访问的精髓

通过今天的讲解，相信大家对Python描述符有了更深入的理解。 描述符是Python中一个强大而灵活的特性，它可以用于实现各种高级的属性控制。 掌握描述符能让你编写出更健壮、更可维护的代码，并能更好地理解Python面向对象编程的底层机制。希望这些知识对你在Python开发中有所帮助。

理解描述符的核心概念

• 描述符通过__get__、__set__和__delete__方法控制属性访问。
• 数据描述符和非数据描述符在属性查找优先级上有所不同。
• 掌握描述符能提升代码的灵活性和可控性。