Python中描述符(Descriptor)概念的深入理解，10大问题，由浅到深教程。

问题一：描述符（Descriptor）的概念和参数详解

1. 什么是描述符？

描述符是实现了特定方法（__get__、__set__、__delete__）的类。它允许你自定义属性的访问逻辑，是 Python 面向对象的高级特性。

2. 描述符的三个核心方法

方法	作用	触发场景
`__get__(self, instance, owner)`	读取属性时调用	`obj.attr` 或 `Class.attr`
`__set__(self, instance, value)`	设置属性时调用	`obj.attr = value`
`__delete__(self, instance)`	删除属性时调用	`del obj.attr`

3. 参数解释

以 __get__ 方法为例：

def __get__(self, instance, owner):
    # self: 描述符实例本身
    # instance: 调用描述符的**对象实例**（若通过类访问则为 None）
    # owner: 调用描述符的**类**
    pass

4. 示例 1：最简单的描述符

一个将属性值自动转为大写的描述符：

class UpperCase:
    def __init__(self, initial_value=None):
        self.value = initial_value  # 存储实际数据

    def __get__(self, instance, owner):
        return self.value.upper()  # 读取时转为大写

    def __set__(self, instance, value):
        self.value = value  # 直接存储原始值


class Person:
    name = UpperCase("alice")  # 类属性由描述符管理

p = Person()
print(p.name)  # 输出 "ALICE"（自动转大写）
p.name = "bob"
print(p.name)  # 输出 "BOB"

5. 示例 2：类型检查描述符

强制属性必须为整数：

class IntegerField:
    def __set__(self, instance, value):
        if not isinstance(value, int):
            raise TypeError("必须为整数！")
        instance.__dict__[self.name] = value  # 存储到实例字典

    def __set_name__(self, owner, name):
        self.name = name  # 自动获取属性名（Python 3.6+）


class User:
    age = IntegerField()  # 描述符绑定到类属性 age

u = User()
u.age = 20    # 正确
u.age = "20"  # 抛出 TypeError

6. 数据描述符 vs 非数据描述符

数据描述符：实现了 __set__ 或 __delete__ 的描述符。
- 优先级高于实例属性。
非数据描述符：仅实现 __get__ 的描述符。
- 优先级低于实例属性。

8. 描述符的优先级规则

当访问 obj.attr 时，Python 按以下顺序查找：

数据描述符（类中定义的 __set__ 或 __delete__）
实例属性（obj.__dict__）
非数据描述符（仅实现 __get__ 的描述符）

9. 描述符的典型应用场景

延迟加载（如 LazyProperty）
属性类型校验
实现 @property 的高级版本
ORM 框架中的字段映射（如 Django 模型的字段）

10. 总结：描述符的核心价值

代码复用：封装属性访问逻辑，多个属性可复用同一描述符。
透明控制：隐藏复杂的属性处理逻辑（如类型检查、延迟加载）。
协议驱动：通过实现特定方法，无缝集成到 Python 对象模型中。

通过描述符，你可以将属性的读取、写入和删除行为完全自定义，实现高度灵活的对象模型控制。

问题二：在上面的示例2中，对于里面的多个参数对应的返回值，分别是什么？

class IntegerField:
    def __set__(self, instance, value):
        if not isinstance(value, int):
            raise TypeError('must be integer!')
        instance.__dict__[self.name] = value
        print(f'【self】: {str(self)}, 【intance】: {str(instance)}, 【instance.__dict__】: {instance.__dict__}, 【value】: {value}')
    def __set_name__(self, owner, name):
        self.name = name
        print(f'【owner】: {owner}, 【self.name】: {self.name}, 【name】：{name}')

class User:
    age = IntegerField()

u = User()
u.age = 20
# u.age = '20'

执行如上代码后，返回结果如下：

【owner】: <class '__main__.User'>, 【self.name】: age, 【name】：age
【self】: <__main__.IntegerField object at 0x00000287A42930B0>, 【intance】: <__main__.User object at 0x00000287A4293080>, 【instance.__dict__】: {'age': 20}, 【value】: 20

这下各个变量分别对应谁的关系，就一目了然了。

问题三：如何理解描述符访问的优先级顺序？

描述符优先级规则的代码演示

通过以下示例，我们分步验证数据描述符 > 实例属性 > 非数据描述符的优先级规则：

1. 定义两个描述符类

# 数据描述符（实现 __set__）
class DataDescriptor:
    def __get__(self, instance, owner):
        print("调用 DataDescriptor 的 __get__")
        #print(f'self: {self}, instance: {instance}, owner: {owner}')  #返回 self: <__main__.DataDescriptor object at 0x0000016A9DF33140>, instance: <__main__.MyClass object at 0x0000016A9DF33260>, owner: <class '__main__.MyClass'>
        return "来自数据描述符的值"
    
    def __set__(self, instance, value):
        print("调用 DataDescriptor 的 __set__")
        instance.__dict__["attr"] = value  # 绕过描述符，直接存储到实例字典

# 非数据描述符（仅实现 __get__）
class NonDataDescriptor:
    def __get__(self, instance, owner):
        print("调用 NonDataDescriptor 的 __get__")
        return "来自非数据描述符的值"


class MyClass:
    attr = DataDescriptor()  # 数据描述符（优先级最高）
    lazy_attr = NonDataDescriptor()  # 非数据描述符（优先级最低）

2. 场景 1：数据描述符 vs 实例属性

class MyClass:
    attr = DataDescriptor()
    lazy_attr = NoneDataDescriptor()


obj = MyClass()

# 场景 1：数据描述符 vs 实例属性
obj.attr = '直接设置的实例属性值'  # 返回：调用 DataDescriptor 的 __set__
print('obj.__dict__ =', obj.__dict__)  # obj.__dict__里面存储的是 {'attr': '直接设置的实例属性值'}，但是obj.attr优先访问的却是 DataDescriptor的__get__
print('obj.attr =', obj.attr)

# 结论: 即使实例字典中有 attr，Python 仍优先调用 数据描述符的 __get__。

返回结果：

调用 DataDescriptor 的 __set__ 
obj.__dict__ = {'attr': '直接设置的实例属性值'}
调用 DataDescriptor 的 __get__
obj.attr = 来自数据描述符的值

3. 场景 2：实例属性 vs 非数据描述符

# 场景 2：实例属性 vs 非数据描述符
obj.lazy_attr = '直接设置的实例属性值'
print(f'obj.lazy_attr = ', obj.lazy_attr)

del obj.lazy_attr
print("obj.lazy_attr = ", obj.lazy_attr)

# 结论：实例属性优先级高于 非数据描述符。

返回结果：

obj.lazy_attr =  直接设置的实例属性值
调用 NonDataDescriptor 的 __get__
obj.lazy_attr =  来自非数据描述符的值

4. 优先级规则总结

操作	实际访问的优先级顺序
`obj.attr`（数据描述符存在）	1. 数据描述符的 `__get__` <br> 2. 实例属性 <br> 3. 非数据描述符
`obj.attr = value`（数据描述符存在）	1. 数据描述符的 `__set__`

关键结论

数据描述符：控制属性的读写行为，优先级最高。
实例属性：仅在无数据描述符时生效。
非数据描述符：仅在无数据描述符且无实例属性时生效。

这种规则使得框架（如 Django ORM、SQLAlchemy）可以严格控制属性的行为，同时允许实例在必要时覆盖非核心逻辑。

问题四：Python 中 __get__、__set__ 和 __delete__ 这三个描述符（descriptor）相关的特殊方法（dunder methods）

这三个方法是 Python 数据模型中用于实现描述符协议的核心，常常让人混淆，但理解它们的参数和使用场景后会清晰很多。以下我会结合你的代码示例逐一讲解。

示例代码：

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

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

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

    def __delete__(self, instance):
        ...

背景：什么是描述符？

描述符是 Python 中一种强大的机制，用于控制属性访问行为。一个类如果定义了 __get__、__set__ 或 __delete__ 中的至少一个方法，就被认为是一个描述符。

描述符通常用于实现属性（property）的自定义行为，比如 getter、setter 或 deleter。

你的示例代码中，Test 类看起来像是想实现描述符，但需要注意的是，描述符通常是作为另一个类的属性来使用的，而不是直接在类本身上操作。

下面我会假设 Test 是描述符类，并结合典型用法解释这三个方法。

1. get(self, instance, owner)

作用：

__get__ 定义了当通过实例或类访问描述符属性时返回什么值。

参数含义：

self：描述符对象自身的引用（即 Test 类的实例）。

instance：调用描述符的实例（如果通过实例访问）。如果通过类直接访问，则为 None。

owner：拥有描述符的类（通常是定义描述符属性的那个类）。

返回值：

由你决定，通常是从 instance 中获取某个值，或者返回默认值。

使用场景：

当你访问 obj.attr 或 Class.attr 时，如果 attr 是描述符，就会触发 __get__。

示例：

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

    def __get__(self, instance, owner):
        if instance is None:
            return self  # 通过类访问时返回描述符本身
        return f"Getting {self.name} from {instance}"

class MyClass:
    desc = Test("descriptor")

obj = MyClass()
print(obj.desc)  # 输出: Getting descriptor from <__main__.MyClass object at ...>
print(MyClass.desc)  # 输出: <__main__.Test object at ...>

当 obj.desc 被访问时，instance 是 obj，owner 是 MyClass。

当 MyClass.desc 被访问时，instance 是 None，owner 是 MyClass。

2. set(self, instance, value)

作用：

__set__ 定义了当试图给描述符属性赋值时（例如 obj.attr = value）的行为。

参数含义：

self：描述符对象自身的引用。

instance：调用描述符的实例（被赋值的对象）。

value：试图设置的值。

返回值：

无返回值（通常修改 instance 的状态）。

使用场景：

当你执行 obj.attr = value 时，如果 attr 是描述符，就会触发 __set__。

示例：

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

    def __set__(self, instance, value):
        print(f"Setting {self.name} on {instance} to {value}")
        instance.__dict__[self.name] = value  # 将值存储到实例的 __dict__ 中

class MyClass:
    desc = Test("my_attr")

obj = MyClass()
obj.desc = 42  # 输出: Setting my_attr on <__main__.MyClass object at ...> to 42
print(obj.my_attr)  # 输出: 42

instance 是 obj，value 是 42。

__set__ 通常用来控制赋值逻辑，比如验证 value 或存储到特定位置。

3. delete(self, instance)

作用：

__delete__ 定义了当试图删除描述符属性时（例如 del obj.attr）的行为。

参数含义：

self：描述符对象自身的引用。

instance：调用描述符的实例（属性被删除的对象）。

返回值：

无返回值（通常从 instance 中移除某个值）。

使用场景：

当你执行 del obj.attr 时，如果 attr 是描述符，就会触发 __delete__。

示例：

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

    def __delete__(self, instance):
        print(f"Deleting {self.name} from {instance}")
        del instance.__dict__[self.name]

class MyClass:
    desc = Test("my_attr")

obj = MyClass()
obj.my_attr = 42  # 先赋值
print(obj.my_attr)  # 输出: 42
del obj.desc  # 输出: Deleting my_attr from <__main__.MyClass object at ...>
# print(obj.my_attr)  # 会报错，因为 my_attr 已被删除

instance 是 obj。

__delete__ 负责清理或移除相总结：参数对比

方法	参数 (self, ...)	触发条件	典型用途
__get__	instance, owner	访问属性 obj.attr	获取属性值
__set__	instance, value	赋值 obj.attr = v	设置属性值
__delete__	instance	删除 del obj.attr	删除属性或清理相关数据

易混点解析：

instance 的作用：

owner 只出现在 __get__：

value 只出现在 __set__：
- 因为只有赋值操作需要传递新值。

完整示例：结合三者

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

    def __get__(self, instance, owner):
        if instance is None:
            return self
        return instance.__dict__.get(self.name, "Not set")

    def __set__(self, instance, value):
        instance.__dict__[self.name] = value

    def __delete__(self, instance):
        del instance.__dict__[self.name]

class MyClass:
    attr = Test("my_attr")

obj = MyClass()
print(obj.attr)      # 输出: Not set  理解这个返回结果，见下面追问.
obj.attr = 100       # 设置值
print(obj.attr)      # 输出: 100
del obj.attr         # 删除属性
print(obj.attr)      # 输出: Not set

记忆技巧

__get__：获取（get），需要知道“谁在访问”（instance 或 owner）。

__set__：设置（set），需要知道“设置什么值”（value）。
__delete__：删除（delete），只需要知道“删除谁的”（instance）。

追问：在最后的例子中，为什么 obj = MyClass() print(obj.attr) # 输出: Not set 不是输出my_attr，而是输出Not set呢？

在上面例子中 print(obj.attr) 输出的是 "Not set" 而不是 "my_attr"。这涉及到描述符的工作机制和 __get__ 方法的具体实现逻辑。

代码回顾

我们先看看完整的代码：

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

    def __get__(self, instance, owner):
        if instance is None:
            return self
        return instance.__dict__.get(self.name, "Not set")

    def __set__(self, instance, value):
        instance.__dict__[self.name] = value

    def __delete__(self, instance):
        del instance.__dict__[self.name]

class MyClass:
    attr = Test("my_attr")

obj = MyClass()
print(obj.attr)      # 输出: Not set

为什么输出 "Not set" 而不是 "my_attr"？

关键在于 __get__ 方法的实现：

def __get__(self, instance, owner):
    if instance is None:
        return self
    return instance.__dict__.get(self.name, "Not set")

执行流程：

创建对象：

访问 obj.attr：

执行 __get__：
- 因为 instance 不为 None（它是 obj），所以不会返回 self，而是执行：

return instance.__dict__.get(self.name, "Not set")

这里：

self.name 是 "my_attr"（在 Test.__init__ 中设置的）。

instance.__dict__ 是 obj 的实例属性字典。

此时 obj.__dict__ 是空的（{}），因为我们还没有通过 __set__ 或其他方式给 obj 添加任何实例属性。

- instance.__dict__.get("my_attr", "Not set")：
  - - 因为 obj.__dict__ 中没有 "my_attr"，所以返回 "Not set"。

输出结果：
- 因此，print(obj.attr) 输出的是 "Not set"。

为什么不是 "my_attr"？

你可能期望输出 "my_attr"，因为 Test 的 self.name 是 "my_attr"。但 __get__ 的逻辑并没有直接返回 self.name，而是试图从 instance.__dict__ 中获取键 "my_attr" 对应的值：

self.name（"my_attr"）只是描述符的一个标识符，告诉 __get__ 去哪里查找值。

在这个例子中，__get__ 被设计为从实例的 __dict__ 中查找，而 obj 还没有设置过 "my_attr" 这个属性，所以返回默认值 "Not set"。

如果 __get__ 被写成这样：

def __get__(self, instance, owner):
    if instance is None:
        return self
    return self.name

那么 print(obj.attr) 就会输出 "my_attr"，因为它直接返回了描述符的 name 属性，而不是去 instance.__dict__ 中查找。

总结

输出 "Not set" 是因为 __get__ 的逻辑是从 instance.__dict__ 中找 self.name（"my_attr"）对应的值，而 obj.__dict__ 初始为空，所以返回了默认值 "Not set"。

如果你想要 obj.attr 输出 "my_attr"，需要修改 __get__ 的返回值逻辑，例如直接返回 self.name。
当前代码的设计意图是把 "my_attr" 作为键，动态管理 obj 的实例属性，而不是直接返回描述符的 name。

问题五：为什么如下代码结果返回{} ?

class LazyLoading:
    def __init__(self, method):
        self.method = method

    def __get__(self, instance, owner):
        if not instance:
            return self
        value = self.method(instance)  # time consuming
        setattr(instance, self.method.__name__, value)
        return value


class MyClass:
    @LazyLoading
    def data(self):
        print('计算数据...')
        return [1, 2, 3]


obj = MyClass()
print(obj.__dict__)  # 输出: {}
print(obj.data)      # 触发 __get__，计算并缓存值
print(obj.__dict__)  # 输出: {'data': [1, 2, 3]}

# 输出：
{}
计算数据...
[1, 2, 3]
{'data': [1, 2, 3]}

为什么初始输出是 {}？

回到你的问题，初始输出是 {} 的根本原因：

obj.__dict__ 只记录实例属性。

在你访问 obj.data 之前，LazyLoading.__get__ 没有被触发，没有执行 setattr，所以 obj.__dict__ 没有任何内容。

理解的关键点

实例属性 vs 类属性：

描述符的延迟计算：

缓存行为：
- 一旦访问 obj.data，__get__ 会通过 setattr 将结果存入 obj.__dict__，这就是“延迟加载并缓存”的本质。

总结

print(obj.__dict__) 输出 {} 是因为在访问 obj.data 之前，没有任何实例属性被添加到 obj。

- 如果你访问了 obj.data，LazyLoading.__get__ 会触发，计算值并通过 setattr 将结果存入 obj.__dict__，此时 obj.__dict__ 就会变成 {'data': [1, 2, 3]}。

问题六：如下是需要动态扩展的描述符，如何理解该代码?

class ConfigurableDescriptor:
    def __init__(self, getter):
        self.getter = getter
        self.setter = None
    
    def __get__(self, instance, owner):
        return self.getter(instance)
    
    def setter(self, setter):
        self.setter = setter
        return self
    
    def __set__(self, instance, value):
        if self.setter:
            self.setter(instance, value)
        else:
            raise AttributeError("属性不可写")

class User:
    @ConfigurableDescriptor
    def age(self):
        return self._age
    
    @age.setter
    def age(self, value):
        if value < 0:
            raise ValueError("年龄不能为负数")
        self._age = value

u = User()
u.age = 20   # 调用 ConfigurableDescriptor 的 __set__

这段代码实现了一个可以动态扩展的描述符 ConfigurableDescriptor，允许在定义时只提供 getter 方法，随后通过装饰器动态添加 setter 方法。

我们会一步步拆解代码的定义、执行流程，以及为什么最终可以正确设置 u.age = 20。

逐行解释

定义 ConfigurableDescriptor 类

class ConfigurableDescriptor:
    def __init__(self, getter):
        self.getter = getter
        self.setter = None

ConfigurableDescriptor 是一个描述符类，__init__ 方法接收一个 getter 函数，并将其存储在 self.getter 中。

self.setter 初始化为 None，表示默认没有 setter 方法。

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

__get__ 是描述符的核心方法，当访问属性时（例如 u.age）被调用。

参数：

逻辑：调用 self.getter(instance)，即调用传入的 getter 函数，并返回结果。

没有检查 instance 是否为 None，所以通过类访问（如 User.age）会出错（需要 instance 来调用 getter），但这里我们只关注实例访问。

    def setter(self, setter):
        self.setter = setter
        return self

setter 是一个普通方法（不是特殊方法），用于动态设置 self.setter。

参数：

逻辑：

这个设计允许在描述符创建后动态添加 setter 功能。

    def __set__(self, instance, value):
        if self.setter:
            self.setter(instance, value)
        else:
            raise AttributeError("属性不可写")

__set__ 是描述符的赋值方法，当试图设置属性时（例如 u.age = 20）被调用。

参数：

逻辑：
1. 如果不存在，抛出 AttributeError，表示属性不可写。

class User:
    @ConfigurableDescriptor
    def age(self):
        return self._age

age 方法被 @ConfigurableDescriptor 装饰。

@ConfigurableDescriptor 等价于 age = ConfigurableDescriptor(age)。

这里：

原始 age 方法的作用是返回实例的 _age 属性（但此时 _age 尚未定义，需要通过 setter 设置）。

    @age.setter
    def age(self, value):
        if value < 0:
            raise ValueError("年龄不能为负数")
        self._age = value

@age.setter 调用 ConfigurableDescriptor.setter 方法。

age 是 User.age，即 ConfigurableDescriptor 的实例。

age.setter 调用 ConfigurableDescriptor.setter，传入新的 age 方法（setter）。

ConfigurableDescriptor.setter：

新的 age 方法（setter）的作用：

总结 User 类定义

经过装饰器处理，User.age 是 ConfigurableDescriptor 的实例，具有：
- self.getter：原始的 age 方法（return self._age）。
- self.setter：后添加的 age 方法（if value < 0 ... self._age = value）。

创建实例并设置属性

u = User()

创建 User 的实例 u。

没有显式的 __init__ 方法，u 初始化时没有任何实例属性。

u.__dict__ 是 {}。

u.age = 20   # 调用 ConfigurableDescriptor 的 __set__

这一行尝试设置 u.age 为 20，触发 ConfigurableDescriptor.__set__。

流程：
1. 1. 调用 self.setter：
  - self.setter(instance, value) 调用新的 age 方法：
  - instance 是 u，value 是 20。
  - 执行：

if value < 0:
    raise ValueError("年龄不能为负数")
self._age = value

value = 20，不小于 0，所以不抛异常。

self._age = 20，即 u._age = 20。

u.__dict__ 现在是 {'_age': 20}。

为什么可以成功设置 u.age = 20？

ConfigurableDescriptor 的设计允许动态扩展：
- 初始时只有 getter，通过 @ConfigurableDescriptor 创建描述符。
- 随后通过 @age.setter 添加 setter，支持写操作。

- u.age = 20 触发 __set__，调用设置好的 setter，成功设置 u._age = 20。

如果访问 u.age 会怎样？

如果我们再加一行 print(u.age)，会触发 __get__：

print(u.age)

u.age 触发 ConfigurableDescriptor.__get__：

self.getter(instance) 调用原始的 age 方法：

def age(self):
    return self._age

self 是 u，self._age 是 20，所以返回 20。
输出：20。

完整扩展代码和输出

如果我们运行以下代码：

u = User()
u.age = 20
print(u.age)
print(u.__dict__)

输出：

20
{'_age': 20}

总结：代码工作原理

ConfigurableDescriptor：

User 类：

u.age = 20：
- - 触发 __set__，调用 setter，设置 u._age = 20。

为什么这个设计有用？

动态扩展：允许在定义描述符后根据需要添加 setter。

灵活性：可以只提供 getter（只读），后续通过装饰器添加 setter（可写）。

- 控制：setter 可以添加验证逻辑（如 value >= 0），增强属性管理的灵活性。

问题七：是不是所有的描述符都能够写成装饰器的形式？比如@property.

核心结论

不是所有描述符都能直接写成装饰器形式。

装饰器（如 @property）是一种语法糖，用于简化描述符的创建和使用，

但能否写成装饰器形式取决于描述符的设计目的和实现方式。

以下是详细分析：

1. 装饰器与描述符的关系

1.1 `@property` 的本质

@property 是 Python 内置的数据描述符，其底层实现通过装饰器语法简化了描述符的定义：

class User:
    def __init__(self):
        self._age = 0

    @property
    def age(self):          # 创建描述符的 __get__ 方法
        return self._age
    
    @age.setter
    def age(self, value):   # 创建描述符的 __set__ 方法
        if value < 0:
            raise ValueError("年龄不能为负数")
        self._age = value

u = User()
u.age = 20   # 实际调用描述符的 __set__

@property 和 @age.setter 本质上是分步构建一个描述符对象，并将其绑定到类属性 age。

1.2 装饰器的局限性

装饰器通常用于包装函数或方法，而描述符是类属性。因此：

直接等价性：只有特定类型的描述符（如 @property）可以通过装饰器语法直接创建。
通用性：大多数自定义描述符需要显式定义为类，无法直接用装饰器语法生成。

2. 哪些描述符可以写成装饰器形式？

2.1 类似 `@property` 的描述符

若描述符的目标是包装一个方法并管理属性访问，可以通过装饰器语法实现。例如：

class LazyLoad:
    def __init__(self, func):
        self.func = func
    
    def __get__(self, instance, owner):
        if instance is None:
            return self
        value = self.func(instance)
        setattr(instance, self.func.__name__, value)
        return value

class MyClass:
    @LazyLoad
    def data(self):
        print("计算数据...")
        return [1, 2, 3]

obj = MyClass()
print(obj.data)  # 第一次调用触发 data 方法计算
print(obj.data)  # 直接返回缓存值（不再计算）

这里 @LazyLoad 是一个自定义装饰器，创建了一个非数据描述符，用于延迟计算属性。

2.2 需要动态扩展的描述符

若描述符需要支持类似 @x.setter 的分步配置，需模仿 @property 的实现：

class ConfigurableDescriptor:
    def __init__(self, getter):
        self.getter = getter
        self.setter = None
    
    def __get__(self, instance, owner):
        return self.getter(instance)
    
    def setter(self, setter):
        self.setter = setter
        return self
    
    def __set__(self, instance, value):
        if self.setter:
            self.setter(instance, value)
        else:
            raise AttributeError("属性不可写")

class User:
    @ConfigurableDescriptor
    def age(self):
        return self._age
    
    @age.setter
    def age(self, value):
        if value < 0:
            raise ValueError("年龄不能为负数")
        self._age = value

u = User()
u.age = 20   # 调用 ConfigurableDescriptor 的 __set__

这种设计模仿了 @property 的链式装饰器语法。

3. 哪些描述符无法写成装饰器形式？

3.1 需要初始化参数的描述符

若描述符依赖外部参数，无法直接用装饰器语法（除非通过闭包或类工厂）：

class RangeValidator:
    def __init__(self, min_val, max_val):
        self.min = min_val
        self.max = max_val
    
    def __set__(self, instance, value):
        if not (self.min <= value <= self.max):
            raise ValueError(f"值必须在 {self.min}~{self.max} 之间")
        instance.__dict__[self.name] = value

class Product:
    price = RangeValidator(0, 1000)  # 必须显式实例化描述符

p = Product()
p.price = 500   # 合法
p.price = 2000  # 报错

这里 RangeValidator 需要参数 min_val 和 max_val，无法直接用 @RangeValidator 装饰器语法。

3.2 需要复杂逻辑的描述符

若描述符需管理多个属性或复杂状态，装饰器语法可能不够灵活：

class Relationship:
    def __init__(self, model_class):
        self.model_class = model_class
        self.cache = {}
    
    def __get__(self, instance, owner):
        if instance is None:
            return self
        if instance.id not in self.cache:
            self.cache[instance.id] = self.model_class.query(instance.id)
        return self.cache[instance.id]

class User:
    posts = Relationship(Post)  # 描述符需要关联另一个类

u = User()
print(u.posts)  # 查询并缓存 Post 数据

这类描述符需显式绑定到类属性，无法用装饰器简化。

4. 总结

描述符类型	能否写成装饰器形式	示例
无参数、仅包装单方法	✅ 是	`@property`, `@LazyLoad`
需要参数初始化	❌ 否（需显式实例化）	`RangeValidator`
需分步配置（如 setter）	✅ 是（需模仿 `@property` 设计）	`ConfigurableDescriptor`
管理复杂状态或多属性	❌ 否	`Relationship`

关键结论

装饰器是语法糖：用于简化特定场景下的描述符定义（如 @property）。
灵活性受限：需要参数或复杂逻辑的描述符通常需显式定义为类属性。
设计决定形式：能否使用装饰器取决于描述符是否需要无参数初始化和单方法绑定。

通过合理选择设计模式，可以在需要时模仿 @property 的装饰器风格，但不必强求所有描述符都写成装饰器形式。

参考文章:

[1] 深入理解python中的描述符

[2] 深入浅出描述符

[3] Python Descriptors: An Introduction

posted @ 2025-02-28 16:12 AlphaGeek 阅读(213) 评论(0) 收藏举报

刷新页面返回顶部

Running water never grows stale. So you just have to keep on flowing.

世上无难事，只要肯攀登。

Python中描述符(Descriptor)概念的深入理解，10大问题，由浅到深教程。

1. 什么是描述符？

2. 描述符的三个核心方法

3. 参数解释

4. 示例 1：最简单的描述符

5. 示例 2：类型检查描述符

6. 数据描述符 vs 非数据描述符

8. 描述符的优先级规则

9. 描述符的典型应用场景

10. 总结：描述符的核心价值

描述符优先级规则的代码演示

1. 定义两个描述符类

2. 场景 1：数据描述符 vs 实例属性

3. 场景 2：实例属性 vs 非数据描述符

4. 优先级规则总结

关键结论

示例代码：

背景：什么是描述符？

1. __get__(self, instance, owner)

作用：

参数含义：

返回值：

使用场景：

示例：

2. __set__(self, instance, value)

作用：

参数含义：

返回值：

使用场景：

示例：

3. __delete__(self, instance)

作用：

参数含义：

返回值：

使用场景：

示例：

易混点解析：

记忆技巧

代码回顾

为什么输出 "Not set" 而不是 "my_attr"？

执行流程：

为什么不是 "my_attr"？

总结

为什么初始输出是 {}？

理解的关键点

总结

逐行解释

定义 ConfigurableDescriptor 类

总结 User 类定义

为什么可以成功设置 u.age = 20？

如果访问 u.age 会怎样？

完整扩展代码和输出

总结：代码工作原理

为什么这个设计有用？

核心结论

1. 装饰器与描述符的关系

1.1 @property 的本质

1.2 装饰器的局限性

2. 哪些描述符可以写成装饰器形式？

2.1 类似 @property 的描述符

2.2 需要动态扩展的描述符

3. 哪些描述符无法写成装饰器形式？

3.1 需要初始化参数的描述符

3.2 需要复杂逻辑的描述符

4. 总结

关键结论

公告

1. get(self, instance, owner)

2. set(self, instance, value)

3. delete(self, instance)

1.1 `@property` 的本质

2.1 类似 `@property` 的描述符