好的，我们开始。
各位同学，今天我们来深入探讨 Python 中的描述符（Descriptors）。描述符是 Python 中一个非常强大但有时容易被忽视的特性。理解描述符的工作原理，对于理解 Python 的对象模型，以及编写更加灵活、可控的代码至关重要。我们将深入了解 __get__、__set__ 和 __delete__ 这三个特殊方法，以及它们如何在 property 和 ORM（Object-Relational Mapping）中发挥作用。
什么是描述符？
简单来说，描述符是一个实现了 __get__、__set__ 或 __delete__ 方法的 Python 对象。当一个类的属性被设置为一个描述符实例时，对该属性的访问、赋值和删除操作会被委托给这些方法。
更正式地说，如果一个对象定义了以下任何一个方法，它就是一个描述符：
__get__(self, instance, owner): 用于获取属性的值。__set__(self, instance, value): 用于设置属性的值。__delete__(self, instance): 用于删除属性。
描述符协议
描述符协议定义了 Python 如何处理描述符对象。当解释器遇到一个属性访问时，它会检查该属性是否是一个描述符。如果是，它会调用相应的描述符方法。
__get__ 方法
__get__(self, instance, owner) 是描述符中最核心的方法。它定义了如何获取属性的值。
self: 描述符实例本身。instance: 拥有该描述符属性的类的实例。如果通过类访问该属性，则instance为None。owner: 拥有该描述符属性的类。
让我们看一个简单的例子：
class MyDescriptor:
def __get__(self, instance, owner):
print(f"__get__ called: self={self}, instance={instance}, owner={owner}")
if instance is None:
return self
return instance._my_attribute # Assuming the attribute is stored as a private attribute
class MyClass:
my_attribute = MyDescriptor()
def __init__(self, value):
self._my_attribute = value
# Usage
obj = MyClass(10)
print(obj.my_attribute) # Accessing through instance
print(MyClass.my_attribute) # Accessing through class输出：
__get__ called: self=<__main__.MyDescriptor object at 0x...>, instance=<__main__.MyClass object at 0x...>, owner=<class '__main__.MyClass'>
10
__get__ called: self=<__main__.MyDescriptor object at 0x...>, instance=None, owner=<class '__main__.MyClass'>
<__main__.MyDescriptor object at 0x...>在这个例子中，当我们通过 obj.my_attribute 访问属性时，__get__ 方法被调用，并且 instance 参数是 obj。当我们通过 MyClass.my_attribute 访问属性时，__get__ 方法被调用，并且 instance 参数是 None。
__set__ 方法
__set__(self, instance, value) 定义了如何设置属性的值。
self: 描述符实例本身。instance: 拥有该描述符属性的类的实例。value: 要设置的新值。
例如：
class MyDescriptor:
def __set__(self, instance, value):
print(f"__set__ called: self={self}, instance={instance}, value={value}")
instance._my_attribute = value * 2 # Modify the value before storing
class MyClass:
my_attribute = MyDescriptor()
def __init__(self):
self._my_attribute = None # Initialize with a default value
# Usage
obj = MyClass()
obj.my_attribute = 5
print(obj._my_attribute)输出：
__set__ called: self=<__main__.MyDescriptor object at 0x...>, instance=<__main__.MyClass object at 0x...>, value=5
10在这个例子中，当我们执行 obj.my_attribute = 5 时，__set__ 方法被调用，并且传入的值 5 被乘以 2 后存储到 _my_attribute 中。
__delete__ 方法
__delete__(self, instance) 定义了如何删除属性。
self: 描述符实例本身。instance: 拥有该描述符属性的类的实例。
例如：
class MyDescriptor:
def __delete__(self, instance):
print(f"__delete__ called: self={self}, instance={instance}")
del instance._my_attribute
class MyClass:
my_attribute = MyDescriptor()
def __init__(self, value):
self._my_attribute = value
# Usage
obj = MyClass(10)
del obj.my_attribute
try:
print(obj._my_attribute)
except AttributeError as e:
print(e)输出：
__delete__ called: self=<__main__.MyDescriptor object at 0x...>, instance=<__main__.MyClass object at 0x...>,
'MyClass' object has no attribute '_my_attribute'当我们执行 del obj.my_attribute 时，__delete__ 方法被调用，并且 _my_attribute 被删除。
数据描述符与非数据描述符
描述符可以分为两类：
- 数据描述符 (Data Descriptors): 同时定义了
__get__和__set__方法的描述符。 - 非数据描述符 (Non-Data Descriptors): 只定义了
__get__方法的描述符。
数据描述符比实例字典中的属性具有更高的优先级。这意味着，如果一个类定义了一个数据描述符和一个同名的实例属性，那么数据描述符会覆盖实例属性。非数据描述符则优先级较低，实例属性会覆盖非数据描述符。
优先级规则
当访问一个属性时，Python 会按照以下优先级顺序查找：
- 数据描述符 (Data Descriptors)
- 实例字典 (Instance Dictionary)
- 非数据描述符 (Non-Data Descriptors)
- 类字典 (Class Dictionary) – 查找失败，触发
__getattr__
描述符在 property 中的应用
property 是 Python 内置的一个非数据描述符，它允许你定义一个属性的 getter、setter 和 deleter 方法，而无需直接使用 __get__、__set__ 和 __delete__。
class MyClass:
def __init__(self, value):
self._my_attribute = value
def get_my_attribute(self):
print("Getter called")
return self._my_attribute
def set_my_attribute(self, value):
print("Setter called")
self._my_attribute = value * 2
def del_my_attribute(self):
print("Deleter called")
del self._my_attribute
my_attribute = property(get_my_attribute, set_my_attribute, del_my_attribute, "My attribute")
# Usage
obj = MyClass(5)
print(obj.my_attribute)
obj.my_attribute = 10
print(obj.my_attribute)
del obj.my_attribute
try:
print(obj._my_attribute)
except AttributeError as e:
print(e)输出：
Getter called
5
Setter called
Getter called
20
Deleter called
'MyClass' object has no attribute '_my_attribute'在这个例子中，property 描述符将 get_my_attribute、set_my_attribute 和 del_my_attribute 方法分别绑定到 my_attribute 属性的 get、set 和 delete 操作。
使用 @property 装饰器
更常见和更简洁的方式是使用 @property 装饰器：
class MyClass:
def __init__(self, value):
self._my_attribute = value
@property
def my_attribute(self):
print("Getter called")
return self._my_attribute
@my_attribute.setter
def my_attribute(self, value):
print("Setter called")
self._my_attribute = value * 2
@my_attribute.deleter
def my_attribute(self):
print("Deleter called")
del self._my_attribute
# Usage
obj = MyClass(5)
print(obj.my_attribute)
obj.my_attribute = 10
print(obj.my_attribute)
del obj.my_attribute
try:
print(obj._my_attribute)
except AttributeError as e:
print(e)输出与之前的例子相同。使用 @property 装饰器使得代码更加清晰易读。
描述符在 ORM 中的应用
ORM 框架使用描述符来将数据库表中的列映射到 Python 类的属性。这允许你以面向对象的方式与数据库进行交互，而无需编写大量的 SQL 代码。
让我们创建一个简化的 ORM 示例，它使用描述符来处理数据库列的访问和修改。 这个示例只关注描述符的应用，省略了实际的数据库连接和查询逻辑。
class Column:
def __init__(self, column_type):
self.column_type = column_type
self.name = None # Will be set by the metaclass
def __get__(self, instance, owner):
if instance is None:
return self
# In a real ORM, this would fetch the data from the database
return instance._data.get(self.name)
def __set__(self, instance, value):
# In a real ORM, this would update the data in the database
if not isinstance(value, self.column_type):
raise TypeError(f"Expected {self.column_type}, got {type(value)}")
instance._data[self.name] = value
class Integer(Column):
def __init__(self):
super().__init__(int)
class String(Column):
def __init__(self):
super().__init__(str)
class ModelMeta(type):
def __new__(cls, name, bases, attrs):
# Find all Column instances in the class definition
columns = {}
for attr_name, attr_value in attrs.items():
if isinstance(attr_value, Column):
columns[attr_name] = attr_value
attr_value.name = attr_name # Set the column name
# Remove the Column instances from the class attributes
for attr_name in columns:
del attrs[attr_name]
attrs['_columns'] = columns # Store the columns in a private attribute
return super().__new__(cls, name, bases, attrs)
class Model(metaclass=ModelMeta):
def __init__(self, **kwargs):
self._data = {}
for column_name, column in self._columns.items():
if column_name in kwargs:
setattr(self, column_name, kwargs[column_name]) # Use the descriptor's __set__
else:
self._data[column_name] = None # Or set to None if not provided
def __repr__(self):
return f"{self.__class__.__name__}({self._data})"
class User(Model):
id = Integer()
name = String()
age = Integer()
# Usage
user = User(id=1, name="Alice", age=30)
print(user)
print(user.name)
user.age = 31
print(user)
try:
user.age = "thirty" # Raises TypeError
except TypeError as e:
print(e)输出：
User({'id': 1, 'name': 'Alice', 'age': 30})
Alice
User({'id': 1, 'name': 'Alice', 'age': 31})
Expected <class 'int'>, got <class 'str'>在这个简化的 ORM 示例中：
Column类是一个描述符，它定义了__get__和__set__方法，用于处理数据库列的访问和修改。Integer和String类是Column的子类，它们指定了列的数据类型。ModelMeta是一个元类，它负责收集类定义中的Column实例，并将它们存储在一个私有属性_columns中。它还负责设置每个Column实例的name属性，该属性对应于类中声明的属性名称。Model类是所有模型的基类。它使用元类ModelMeta来处理列的定义。它还提供了一个__init__方法，用于初始化模型实例的数据。User类是一个具体的模型类，它定义了id、name和age列。
当我们访问 user.name 时，String 描述符的 __get__ 方法被调用，它从 user._data 中获取 name 的值。当我们设置 user.age = 31 时，Integer 描述符的 __set__ 方法被调用，它将 age 的值更新到 user._data 中。 这个例子演示了描述符如何用于控制属性的访问和修改，并在 ORM 框架中实现类型检查和其他高级功能。
描述符的实际应用场景
除了 property 和 ORM，描述符还在许多其他场景中非常有用：
- 验证 (Validation): 可以使用描述符来验证属性的值，例如，确保一个数字在特定范围内，或者一个字符串符合特定的格式。
- 类型转换 (Type Conversion): 可以使用描述符来自动将属性的值转换为正确的类型。
- 缓存 (Caching): 可以使用描述符来缓存属性的值，以提高性能。
- 延迟加载 (Lazy Loading): 可以使用描述符来延迟加载属性的值，直到第一次访问该属性时才加载。
- 状态管理 (State Management): 可以使用描述符来跟踪对象的状态变化，并在状态变化时执行特定的操作。
描述符的优势
- 代码重用: 描述符允许你在多个属性之间共享相同的逻辑。
- 封装性: 描述符允许你隐藏属性的实现细节，并提供一个清晰的接口。
- 灵活性: 描述符允许你完全控制属性的访问和修改行为。
需要注意的地方
- 理解优先级: 记住数据描述符、实例字典和非数据描述符之间的优先级关系非常重要。
- 性能: 过度使用描述符可能会影响性能，因为每次属性访问都会调用描述符方法。因此，应该谨慎使用描述符，只在必要时才使用。
- 复杂性: 描述符可能会增加代码的复杂性，特别是对于不熟悉描述符的开发人员来说。因此，应该确保代码清晰易懂，并提供足够的文档。
描述符协议的关键方法及其作用
| 方法 | 作用 |
|---|---|
__get__ |
获取属性的值，可以控制属性的访问行为。 |
__set__ |
设置属性的值，可以进行验证、类型转换或其他自定义操作。 |
__delete__ |
删除属性，可以执行清理操作或阻止属性被删除。 |
描述符是强大的工具，要理解其工作原理，才能写出更灵活的代码。
描述符通过 __get__、__set__ 和 __delete__ 方法，提供了属性访问控制的能力。它们在 property 中简化了属性的 getter、setter 和 deleter 的定义，并在 ORM 中实现了数据库列到对象属性的映射。
掌握描述符协议，写出更Pythonic的代码。
数据描述符和非数据描述符的区别在于是否定义了 __set__ 方法，以及它们在属性查找中的优先级。理解这些概念对于避免意外行为至关重要。
实践是最好的老师，多写代码才能真正理解描述符。
通过实际例子，我们学习了如何使用描述符进行验证、类型转换和延迟加载等高级操作。描述符是 Python 中一个非常强大的工具，可以帮助我们编写更加灵活、可控的代码。