详解如何利用Python装饰器优化代码

import time

# 定义计时器装饰器
def timer_decorator(func):
    # 定义内部包装函数，用于接收任意数量的位置参数和关键字参数
    def wrapper(*args, **kwargs):
        # 记录函数运行开始时间
        start_time = time.time()
        # 调用原始函数并将结果存储在result中
        result = func(*args, **kwargs)
        # 记录函数运行结束时间
        end_time = time.time()
        # 计算函数运行时间并打印结果
        print(f"函数 {func.__name__} 运行时间为 {end_time - start_time} 秒")
        # 返回原始函数的结果
        return result
    # 返回包装函数
    return wrapper

@timer_decorator
def slow_function():
    time.sleep(2)
    print("使用 timer_decorator 计算下 slow_function 函数的运行时长")

slow_function()

# 定义缓存装饰器
def cache_decorator(func):
    # 创建一个字典来存储缓存的结果
    cache = dict()
    # 定义内部包装函数，用于接收任意数量的位置参数
    def wrapper(*args):
        # 检查当前参数是否在缓存中
        if args in cache:
            # 如果在缓存中，则从缓存中获取结果并打印提示信息
            print(f"从缓存中获取 {args} 的结果")
            return cache[args]
        # 如果不在缓存中，则调用原始函数计算结果
        result = func(*args)
        # 将计算结果存储到缓存中，并打印提示信息
        cache[args] = result
        print(f"计算 {args} 的结果并将其存入缓存")
        # 返回计算结果
        return result
    # 返回包装函数
    return wrapper
# 使用缓存装饰器修饰fibonacci函数
@cache_decorator
def fibonacci(n):
    if n < 2:
        return n
    else:
        return fibonacci(n-1) + fibonacci(n-2)
print(fibonacci(3))
print("*****************")
print(fibonacci(5))

# 定义类型检查装饰器
def type_check_decorator(func):
    # 定义内部包装函数，用于接收任意数量的位置参数和关键字参数
    def wrapper(*args, **kwargs):
        # 遍历位置参数
        for i, arg in enumerate(args):
            # 如果参数不是字符串类型，抛出TypeError异常
            if not isinstance(arg, str):
                raise TypeError(f"第 {i+1} 个参数值 {arg} 必须是 str 类型")
        # 遍历关键字参数
        for key, value in kwargs.items():
            # 如果关键字参数的值不是字符串类型，抛出TypeError异常
            if not isinstance(value, str):
                raise TypeError(f"关键字参数 {key} 必须是 str 类型")
        # 参数检查通过后，调用原始函数并返回结果
        return func(*args, **kwargs)
    # 返回包装函数
    return wrapper
# 使用类型检查装饰器修饰concat_strings函数
@type_check_decorator
def concat_strings(*strings, sep=" "):
    return sep.join(strings)

import logging
# 定义日志装饰器
def log_decorator(func):
    # 配置日志记录器，将日志记录到文件example.log，日志级别为INFO
    logging.basicConfig(filename="example.log", level=logging.INFO)
    # 定义内部包装函数，用于接收任意数量的位置参数和关键字参数
    def wrapper(*args, **kwargs):
        # 记录函数调用信息到日志文件中
        logging.info(f"Calling function {func.__name__}")
        # 调用原始函数并将结果存储在result中
        result = func(*args, **kwargs)
        # 记录函数返回值信息到日志文件中
        logging.info(f"Function {func.__name__} returned {result}")
        # 返回原始函数的结果
        return result
    # 返回包装函数
    return wrapper
# 使用日志装饰器修饰add函数
@log_decorator
def add(a, b):
    return a + b
# 调用add函数并打印结果
print(add(1, 2))

# 定义一个高阶函数，接受一个所需角色列表作为参数
def roles_required(required_roles):
    # 定义授权装饰器
    def authorization_decorator(func):
        # 定义包装函数，用于接收任意数量的位置参数和关键字参数
        def wrapper(*args, **kwargs):
            # 获取用户角色，默认为"guest"
            user_role = kwargs.get("user_role", "guest")
            # 检查用户角色是否在所需角色列表中
            if user_role not in required_roles:
                # 如果不在列表中，抛出一个 PermissionError 异常
                raise PermissionError(f"访问被拒绝: 需要 {', '.join(required_roles)} 其中之一的角色")
            # 如果用户角色在所需角色列表中，调用原始函数并返回结果
            return func(*args, **kwargs)
        # 返回包装函数
        return wrapper
    # 返回授权装饰器
    return authorization_decorator
# 使用 roles_required 装饰器，允许 admin 和 user 角色的用户访问受保护的功能
@roles_required(["admin", "user"])
def protected_function(user_role="guest"):
    print("受保护的功能已成功执行")
# 尝试使用 guest 角色访问受保护的功能
try:
    protected_function(user_role="guest")
except PermissionError as e:
    print(e)
# 尝试使用 user 角色访问受保护的功能
try:
    protected_function(user_role="user")
except PermissionError as e:
    print(e)
# 尝试使用 admin 角色访问受保护的功能
try:
    protected_function(user_role="admin")
except PermissionError as e:
    print(e)