python类里面如何写装饰器

在Python类中编写装饰器、可以在类内部定义装饰器函数、使用装饰器函数来增强类方法的功能。使用类内部的装饰器可以使代码更加模块化，便于维护。下面将详细描述如何在Python类中编写和使用装饰器。

一、定义类内部的装饰器

在Python中，装饰器本质上是一个函数，它接受另一个函数作为参数并返回一个新的函数。装饰器可以在函数执行前后添加额外的行为。在类中定义装饰器，可以方便地对类方法进行扩展。

class MyClass:
    def my_decorator(func):
        def wrapper(*args, kwargs):
            print("Before calling", func.__name__)
            result = func(*args, kwargs)
            print("After calling", func.__name__)
            return result
        return wrapper
    @my_decorator
    def my_method(self):
        print("Inside my_method")

在上面的示例中，我们在类MyClass中定义了一个装饰器方法my_decorator。这个装饰器在调用被装饰的方法前后打印信息。装饰器my_decorator被应用到my_method方法上。

二、装饰器的应用场景

类内部的装饰器在很多场景下都很有用，比如：

日志记录：在调用类方法前后记录日志。
权限检查：在调用类方法前检查用户权限。
性能监控：记录方法的执行时间。
事务管理：在方法调用前开启事务，调用后提交或回滚事务。

三、详细示例

1. 日志记录

下面是一个使用类内部装饰器记录日志的示例：

import logging
class Logger:
    def log_decorator(func):
        def wrapper(*args, kwargs):
            logging.info(f"Calling {func.__name__} with args {args} and kwargs {kwargs}")
            result = func(*args, kwargs)
            logging.info(f"Called {func.__name__}, result: {result}")
            return result
        return wrapper
class MyClass:
    @Logger.log_decorator
    def my_method(self, x, y):
        return x + y
if __name__ == "__mAIn__":
    logging.basicConfig(level=logging.INFO)
    obj = MyClass()
    result = obj.my_method(5, 10)

在这个示例中，我们定义了一个Logger类，其中包含一个日志记录装饰器log_decorator。这个装饰器被应用到MyClass的my_method方法上。在调用my_method时，日志记录器会记录函数调用的参数和返回值。

2. 权限检查

下面是一个使用类内部装饰器进行权限检查的示例：

class PermissionError(Exception):
    pass
class Auth:
    def check_permission_decorator(func):
        def wrapper(self, *args, kwargs):
            if not self.has_permission:
                raise PermissionError("Permission denied")
            return func(self, *args, kwargs)
        return wrapper
class MyClass:
    def __init__(self, has_permission):
        self.has_permission = has_permission
    @Auth.check_permission_decorator
    def my_method(self, x, y):
        return x * y
if __name__ == "__main__":
    obj_with_permission = MyClass(has_permission=True)
    print(obj_with_permission.my_method(3, 4))  # Should print 12
    obj_without_permission = MyClass(has_permission=False)
    try:
        obj_without_permission.my_method(3, 4)
    except PermissionError as e:
        print(e)  # Should print "Permission denied"

在这个示例中，我们定义了一个Auth类，其中包含一个权限检查装饰器check_permission_decorator。这个装饰器在调用被装饰的方法前检查self.has_permission属性，如果没有权限则抛出PermissionError异常。

3. 性能监控

下面是一个使用类内部装饰器进行性能监控的示例：

import time
class Timer:
    def time_decorator(func):
        def wrapper(*args, kwargs):
            start_time = time.time()
            result = func(*args, kwargs)
            end_time = time.time()
            print(f"{func.__name__} took {end_time - start_time:.4f} seconds")
            return result
        return wrapper
class MyClass:
    @Timer.time_decorator
    def my_method(self, x, y):
        time.sleep(2)
        return x - y
if __name__ == "__main__":
    obj = MyClass()
    print(obj.my_method(10, 3))  # Should print "my_method took 2.0000 seconds" and then "7"

在这个示例中，我们定义了一个Timer类，其中包含一个性能监控装饰器time_decorator。这个装饰器在调用被装饰的方法前后记录时间，并打印方法的执行时间。

4. 事务管理

下面是一个使用类内部装饰器进行事务管理的示例：

class Transaction:
    def transaction_decorator(func):
        def wrapper(self, *args, kwargs):
            self.begin_transaction()
            try:
                result = func(self, *args, kwargs)
                self.commit_transaction()
                return result
            except Exception as e:
                self.rollback_transaction()
                raise e
        return wrapper
class MyClass:
    def begin_transaction(self):
        print("Transaction started")
    def commit_transaction(self):
        print("Transaction committed")
    def rollback_transaction(self):
        print("Transaction rolled back")
    @Transaction.transaction_decorator
    def my_method(self, x, y):
        if y == 0:
            raise ValueError("y cannot be zero")
        return x / y
if __name__ == "__main__":
    obj = MyClass()
    try:
        print(obj.my_method(10, 2))  # Should print "Transaction started", "Transaction committed", and then "5.0"
        print(obj.my_method(10, 0))  # Should print "Transaction started", "Transaction rolled back", and then raise ValueError
    except ValueError as e:
        print(e)