Python的描述符协议高级应用：实现Weak Reference属性与属性访问的AOP - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

Python 描述符协议高级应用：Weak Reference 属性与属性访问的 AOP

各位朋友，大家好！今天我们将深入探讨 Python 描述符协议的高级应用，重点是如何利用它来实现 Weak Reference 属性，以及如何通过描述符实现属性访问的面向切面编程（AOP）。这两个技术点结合起来，可以帮助我们构建更健壮、更灵活的代码，尤其是在处理对象生命周期管理和横切关注点分离方面。

描述符协议回顾

在深入高级应用之前，我们先简单回顾一下 Python 的描述符协议。描述符协议允许我们自定义属性的访问行为。一个类如果定义了 __get__, __set__, 或 __delete__ 方法中的任何一个，那么它的实例就被视为一个描述符。当一个描述符被用作另一个类的类属性时，它会接管该属性的访问控制权。

具体来说：

__get__(self, instance, owner): 当访问 instance.attribute （attribute 是一个描述符）时被调用，如果 instance 是 None，则表示通过类访问，例如 OwnerClass.attribute。
__set__(self, instance, value): 当尝试设置 instance.attribute = value 时被调用。
__delete__(self, instance): 当尝试删除 instance.attribute 时被调用，例如 del instance.attribute。

理解这三个方法是掌握描述符协议的关键。

Weak Reference 属性的需求与实现

在很多情况下，我们需要持有对象的引用，但又不希望阻止该对象被垃圾回收。这时，Weak Reference 就派上了用场。考虑一种场景：一个对象需要监听另一个对象的状态变化，但又不希望因为监听关系而导致被监听对象无法释放。

Python 的 weakref 模块提供了创建 Weak Reference 的功能。我们可以使用 weakref.ref(object) 创建一个指向 object 的 Weak Reference。当 object 不再被其他强引用指向时，weakref.ref(object) 会返回 None。

现在，我们想创建一个描述符，使得通过属性访问可以直接获取到 Weak Reference 指向的对象，并且当对象被回收时，访问该属性返回 None。

import weakref

class WeakReferenceProperty:
    """
    一个描述符，用于创建 Weak Reference 属性。
    """
    def __init__(self):
        self._name = None  # 存储属性名，在 __set_name__ 中设置
        self._weak_map = {}  # 存储弱引用

    def __set_name__(self, owner, name):
        """
        在描述符被绑定到类时调用，用于获取属性名。
        """
        self._name = name

    def __get__(self, instance, owner):
        if instance is None:
            return self
        if instance not in self._weak_map:
            return None  # 没有弱引用存在
        ref = self._weak_map[instance]
        if ref is None:
            return None # 引用已经失效
        return ref() # 解引用，返回原始对象或 None

    def __set__(self, instance, value):
        if value is None:
            if instance in self._weak_map:
                del self._weak_map[instance]
        else:
            self._weak_map[instance] = weakref.ref(value)

    def __delete__(self, instance):
        if instance in self._weak_map:
            del self._weak_map[instance]

class MyClass:
    target = WeakReferenceProperty()

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

    def __repr__(self):
        return f"MyClass(name='{self.name}')"

# 示例用法
obj1 = MyClass("obj1")
obj2 = MyClass("obj2")

# 创建一个对象，并将其设置为 obj1 的 target 属性
real_object = object()
obj1.target = real_object
print(f"obj1.target: {obj1.target}")  # 输出：<object object at ...>

# 删除 real_object 的所有强引用
del real_object
import gc
gc.collect()  # 强制垃圾回收

print(f"obj1.target after deleting real_object: {obj1.target}")  # 输出：None

# obj2 还没有设置 target 属性
print(f"obj2.target: {obj2.target}") # 输出：None

obj2.target = obj1
print(f"obj2.target: {obj2.target}") # 输出：MyClass(name='obj1')

del obj1
gc.collect()
print(f"obj2.target: {obj2.target}") # 输出：None

代码解释：

WeakReferenceProperty 类: 这是我们的描述符类。
- _weak_map: 一个字典，用于存储每个实例及其对应的 Weak Reference。使用字典而不是直接存储在描述符实例中，是为了支持多个 MyClass 实例拥有各自的 target 属性。
- __get__(self, instance, owner): 当访问 instance.target 时被调用。它首先检查 instance 是否存在于 _weak_map 中。如果存在，则尝试解引用 Weak Reference。如果 Weak Reference 指向的对象已经被回收，则返回 None。
- __set__(self, instance, value): 当设置 instance.target = value 时被调用。如果 value 为 None, 则删除原有的弱引用。否则，创建一个指向 value 的 Weak Reference，并将其存储在 _weak_map 中。
- __delete__(self, instance): 当删除 del instance.target 时被调用，删除对应的弱引用。
- __set_name__(self, owner, name): 在 Python 3.6+ 版本中引入，用于在描述符被绑定到类时获取属性名。
MyClass 类: 一个使用 WeakReferenceProperty 描述符的示例类。target 属性被定义为 WeakReferenceProperty 的实例。

关键点：

_weak_map 使用实例作为键，保证每个实例都有自己独立的弱引用存储。
__get__ 方法负责解引用，并处理对象已经被回收的情况。
__set__ 方法负责创建和更新弱引用。
删除操作负责清理不再需要的弱引用，避免内存泄漏。

优点:

避免循环引用导致的内存泄漏。
可以在对象被回收后自动释放资源。
允许观察对象的状态，而不会阻止其被垃圾回收。

缺点:

增加了代码的复杂性。
访问 Weak Reference 属性时可能返回 None，需要进行额外的判断。

利用描述符实现属性访问的 AOP

面向切面编程 (AOP) 是一种编程范式，旨在通过将横切关注点（如日志记录、权限控制、事务管理等）从核心业务逻辑中分离出来，从而提高代码的可维护性和可重用性。描述符可以作为实现 AOP 的一种手段，尤其是在属性访问方面。

我们可以使用描述符来拦截属性的读取、设置和删除操作，并在这些操作前后执行额外的逻辑。这允许我们以非侵入式的方式为属性访问添加功能。

import functools

class Aspect:
    """
    AOP 切面基类。
    """
    def before_get(self, instance, owner, attribute_name):
        """在属性读取之前执行的逻辑。"""
        pass

    def after_get(self, instance, owner, attribute_name, value):
        """在属性读取之后执行的逻辑。"""
        pass

    def before_set(self, instance, attribute_name, value):
        """在属性设置之前执行的逻辑。"""
        pass

    def after_set(self, instance, attribute_name, value):
        """在属性设置之后执行的逻辑。"""
        pass

    def before_delete(self, instance, attribute_name):
        """在属性删除之前执行的逻辑。"""
        pass

    def after_delete(self, instance, attribute_name):
        """在属性删除之后执行的逻辑。"""
        pass

class LoggingAspect(Aspect):
    """
    一个简单的日志记录切面。
    """
    def before_get(self, instance, owner, attribute_name):
        print(f"Getting attribute '{attribute_name}' on {instance}")

    def after_get(self, instance, owner, attribute_name, value):
        print(f"Attribute '{attribute_name}' on {instance} is {value}")

    def before_set(self, instance, attribute_name, value):
        print(f"Setting attribute '{attribute_name}' on {instance} to {value}")

    def after_set(self, instance, attribute_name, value):
        print(f"Attribute '{attribute_name}' on {instance} set successfully.")

    def before_delete(self, instance, attribute_name):
        print(f"Deleting attribute '{attribute_name}' on {instance}")

    def after_delete(self, instance, attribute_name):
        print(f"Attribute '{attribute_name}' on {instance} deleted successfully.")

class AOPDescriptor:
    """
    一个描述符，用于实现属性访问的 AOP。
    """
    def __init__(self, aspect, storage_name=None):
        self.aspect = aspect
        self.storage_name = storage_name
        self._name = None

    def __set_name__(self, owner, name):
        self._name = name
        if self.storage_name is None:
            self.storage_name = '_' + name  # 默认使用私有变量存储实际值

    def __get__(self, instance, owner):
        if instance is None:
            return self  # 类访问
        attribute_name = self._name
        self.aspect.before_get(instance, owner, attribute_name)
        try:
            value = getattr(instance, self.storage_name)
            self.aspect.after_get(instance, owner, attribute_name, value)
            return value
        except AttributeError:
            self.aspect.after_get(instance, owner, attribute_name, None) # 处理属性不存在的情况
            return None

    def __set__(self, instance, value):
        attribute_name = self._name
        self.aspect.before_set(instance, attribute_name, value)
        setattr(instance, self.storage_name, value)
        self.aspect.after_set(instance, attribute_name, value)

    def __delete__(self, instance):
        attribute_name = self._name
        self.aspect.before_delete(instance, attribute_name)
        try:
            delattr(instance, self.storage_name)
        except AttributeError:
            pass  # 属性不存在，忽略
        self.aspect.after_delete(instance, attribute_name)

class MyClassWithAOP:
    my_attribute = AOPDescriptor(LoggingAspect())

    def __init__(self, my_attribute_value):
        self.my_attribute = my_attribute_value

# 示例用法
instance = MyClassWithAOP("initial value")

print(f"Accessing my_attribute: {instance.my_attribute}")
instance.my_attribute = "new value"
print(f"Accessing my_attribute after setting: {instance.my_attribute}")

del instance.my_attribute

try:
    print(instance.my_attribute)
except AttributeError as e:
    print(e)

代码解释：

Aspect 类: 一个抽象基类，定义了 AOP 切面需要实现的方法。
- before_get, after_get, before_set, after_set, before_delete, after_delete: 分别在属性读取、设置和删除操作前后执行的钩子方法。
LoggingAspect 类: 一个具体的切面，实现了 Aspect 类的方法，用于记录属性访问的日志。
AOPDescriptor 类: 描述符类，负责拦截属性访问，并将控制权委托给切面。
- __init__(self, aspect, storage_name=None): 构造函数，接收一个 Aspect 实例和一个可选的 storage_name。storage_name 用于存储实际的属性值。如果不指定，默认使用私有变量 '_' + attribute_name。
- __get__(self, instance, owner): 在属性读取时被调用。它首先调用切面的 before_get 方法，然后获取实际的属性值，最后调用切面的 after_get 方法。
- __set__(self, instance, value): 在属性设置时被调用。它首先调用切面的 before_set 方法，然后设置实际的属性值，最后调用切面的 after_set 方法。
- __delete__(self, instance): 在属性删除时被调用。它首先调用切面的 before_delete 方法，然后删除实际的属性值，最后调用切面的 after_delete 方法。
- __set_name__(self, owner, name)：用于在类定义时获得属性名。
MyClassWithAOP 类: 一个使用 AOPDescriptor 描述符的示例类。 my_attribute 属性被定义为 AOPDescriptor 的实例，并使用了 LoggingAspect 切面。

关键点：

AOPDescriptor 充当了属性访问的拦截器。
Aspect 类定义了切面的接口。
通过组合 AOPDescriptor 和 Aspect，可以灵活地为属性访问添加各种横切关注点。
storage_name 参数允许我们控制实际属性值的存储位置。
如果属性访问不存在，需要添加处理，避免程序崩溃。

优点：

实现了横切关注点的分离，提高了代码的可维护性和可重用性。
可以以非侵入式的方式为属性访问添加功能。
可以灵活地切换不同的切面，而无需修改核心业务逻辑。

缺点：

增加了代码的复杂性。
可能会影响性能，因为每次属性访问都需要经过切面的处理。

Weak Reference 属性与 AOP 的结合

现在，我们将把 Weak Reference 属性和 AOP 结合起来，创建一个既能避免循环引用，又能实现属性访问切面的描述符。

import weakref
import functools

class WeakReferenceAspect(Aspect):
    """
    一个切面，用于处理 Weak Reference 属性的特殊逻辑。
    """
    def before_get(self, instance, owner, attribute_name):
        print(f"Attempting to access weak reference attribute '{attribute_name}' on {instance}")

    def after_get(self, instance, owner, attribute_name, value):
        if value is None:
            print(f"Weak reference attribute '{attribute_name}' on {instance} is None (object likely garbage collected)")
        else:
            print(f"Weak reference attribute '{attribute_name}' on {instance} is {value}")

class WeakReferenceAOPDescriptor:
    """
    一个描述符，实现了 Weak Reference 属性和属性访问的 AOP。
    """
    def __init__(self, aspect, storage_name=None):
        self.aspect = aspect
        self.storage_name = storage_name
        self._weak_map = {}
        self._name = None

    def __set_name__(self, owner, name):
        self._name = name
        if self.storage_name is None:
            self.storage_name = '_' + name

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

        attribute_name = self._name
        self.aspect.before_get(instance, owner, attribute_name)

        if instance not in self._weak_map:
            self.aspect.after_get(instance, owner, attribute_name, None)
            return None

        ref = self._weak_map[instance]
        if ref is None:
            self.aspect.after_get(instance, owner, attribute_name, None)
            return None

        value = ref()
        self.aspect.after_get(instance, owner, attribute_name, value)
        return value

    def __set__(self, instance, value):
        attribute_name = self._name
        self.aspect.before_set(instance, attribute_name, value)

        if value is None:
            if instance in self._weak_map:
                del self._weak_map[instance]
        else:
            self._weak_map[instance] = weakref.ref(value)

        self.aspect.after_set(instance, attribute_name, value)

    def __delete__(self, instance):
        attribute_name = self._name
        self.aspect.before_delete(instance, attribute_name)
        if instance in self._weak_map:
            del self._weak_map[instance]
        self.aspect.after_delete(instance, attribute_name)

class MyClassWithWeakRefAOP:
    weak_target = WeakReferenceAOPDescriptor(WeakReferenceAspect())

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

    def __repr__(self):
        return f"MyClassWithWeakRefAOP(name='{self.name}')"

# 示例用法
obj1 = MyClassWithWeakRefAOP("obj1")

# 创建一个对象，并将其设置为 obj1 的 weak_target 属性
real_object = object()
obj1.weak_target = real_object
print(f"obj1.weak_target: {obj1.weak_target}")

# 删除 real_object 的所有强引用
del real_object
import gc
gc.collect()  # 强制垃圾回收

print(f"obj1.weak_target after deleting real_object: {obj1.weak_target}")

代码解释：

WeakReferenceAspect 类: 一个切面，专门用于处理 Weak Reference 属性的特殊逻辑。它在 after_get 方法中检查 Weak Reference 是否指向的对象已经被回收，并打印相应的日志。
WeakReferenceAOPDescriptor 类: 一个描述符，同时实现了 Weak Reference 属性和 AOP。它组合了 WeakReferenceProperty 和 AOPDescriptor 的功能。

关键点：

WeakReferenceAOPDescriptor 既能避免循环引用，又能实现属性访问的切面。
WeakReferenceAspect 提供了针对 Weak Reference 属性的特殊日志记录。
这个例子展示了如何将不同的技术结合起来，构建更强大的功能。

描述符协议的局限性与替代方案

虽然描述符协议非常强大，但它也有一些局限性：

复杂性： 理解和正确使用描述符协议需要一定的学习成本。
性能： 每次属性访问都需要经过描述符的处理，可能会影响性能。
元类： 如果需要对类的创建过程进行更细粒度的控制，可能需要使用元类。

一些替代方案包括：

property 装饰器： 对于简单的属性访问控制，property 装饰器可能更简单易用。
__getattr__, __getattribute__ 方法： 这两个方法可以拦截属性访问，但它们的作用范围更广，可能会影响所有属性的访问。
元类： 元类可以控制类的创建过程，允许我们动态地修改类的属性和方法。

选择哪种方案取决于具体的需求和场景。

总结

今天我们深入探讨了 Python 描述符协议的高级应用，包括 Weak Reference 属性和属性访问的 AOP。通过这些技术，我们可以构建更健壮、更灵活的代码，更好地管理对象的生命周期，并将横切关注点从核心业务逻辑中分离出来。希望这些知识能够帮助大家在实际项目中解决更复杂的问题。

总结

Weak Reference 属性避免循环引用，允许观察对象的状态而不阻止其被垃圾回收。
描述符实现 AOP，分离横切关注点，提高代码的可维护性和可重用性。
结合 Weak Reference 和 AOP，兼顾对象生命周期管理和属性访问控制。

更多IT精英技术系列讲座，到智猿学院

Python 描述符协议高级应用：Weak Reference 属性与属性访问的 AOP

描述符协议回顾

Weak Reference 属性的需求与实现

利用描述符实现属性访问的 AOP

Weak Reference 属性与 AOP 的结合

描述符协议的局限性与替代方案

总结

总结

发表回复 取消回复

发表回复取消回复