python中类装饰器的实现示例_Python

在 python 中，类装饰器是一种强大的工具，可以用来增强或修改类的行为。类装饰器本质上是一个函数，它接受一个类作为参数，并返回一个新的类或对原类进行修改。通过使用类装饰器，你可以实现诸如日志记录、权限检查、属性验证等功能，而无需修改类的内部实现。

1. 类装饰器的基本语法

类装饰器的基本语法如下：

@decorator
class myclass:
    pass

这等价于：

class myclass:
    pass

myclass = decorator(myclass)

2. 类装饰器的工作原理

类装饰器是一个函数，它接受一个类作为参数，并返回一个新的类或对原类进行修改。以下是类装饰器的基本实现：

def decorator(cls):
    # 修改类或返回一个新的类
    return cls

3. 类装饰器的示例

3.1 添加类属性

假设我们想为一个类添加一个类属性，可以使用类装饰器来实现：

def add_class_attribute(attr_name, attr_value):
    def decorator(cls):
        setattr(cls, attr_name, attr_value)
        return cls
    return decorator

@add_class_attribute('new_attribute', 42)
class myclass:
    pass

print(myclass.new_attribute)  # 输出 42

3.2 添加实例方法

假设我们想为一个类添加一个实例方法，可以使用类装饰器来实现：

def add_instance_method(method_name, method):
    def decorator(cls):
        setattr(cls, method_name, method)
        return cls
    return decorator

def greet(self):
    return f"hello, my name is {self.name}"

@add_instance_method('greet', greet)
class person:
    def __init__(self, name):
        self.name = name

person = person("alice")
print(person.greet())  # 输出 "hello, my name is alice"

3.3 修改类的行为

假设我们想在类的初始化时记录日志，可以使用类装饰器来实现：

import logging

def log_initialization(cls):
    original_init = cls.__init__

    def new_init(self, *args, **kwargs):
        logging.info(f"initializing {cls.__name__} with args={args} and kwargs={kwargs}")
        original_init(self, *args, **kwargs)

    cls.__init__ = new_init
    return cls

@log_initialization
class myclass:
    def __init__(self, name):
        self.name = name

obj = myclass("test")
# 日志输出: info:root:initializing myclass with args=('test',) and kwargs={}

4. 类装饰器与函数装饰器的区别

函数装饰器：用于装饰函数，通常用于修改函数的行为。函数装饰器接受一个函数作为参数，并返回一个新的函数。
类装饰器：用于装饰类，通常用于修改类的行为。类装饰器接受一个类作为参数，并返回一个新的类或对原类进行修改。

5. 类装饰器的高级用法

5.1 使用类装饰器实现单例模式

单例模式是一种常见的设计模式，确保一个类只有一个实例。可以使用类装饰器来实现单例模式：

def singleton(cls):
    instance = none

    def wrapper(*args, **kwargs):
        nonlocal instance
        if instance is none:
            instance = cls(*args, **kwargs)
        return instance

    return wrapper

@singleton
class myclass:
    def __init__(self, name):
        self.name = name

obj1 = myclass("alice")
obj2 = myclass("bob")

print(obj1 is obj2)  # 输出 true
print(obj1.name)  # 输出 alice
print(obj2.name)  # 输出 alice

5.2 使用类装饰器实现属性验证

假设我们想为类的属性添加验证逻辑，可以使用类装饰器来实现：

def validate_attributes(**validations):
    def decorator(cls):
        original_init = cls.__init__

        def new_init(self, *args, **kwargs):
            original_init(self, *args, **kwargs)
            for attr_name, validation_func in validations.items():
                value = getattr(self, attr_name)
                if not validation_func(value):
                    raise valueerror(f"invalid value for {attr_name}: {value}")

        cls.__init__ = new_init
        return cls
    return decorator

def is_positive(value):
    return value > 0

@validate_attributes(age=is_positive)
class person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

person = person("alice", 30)
# person = person("alice", -1)  # 抛出 valueerror: invalid value for age: -1