<think>题目1：请编写一个装饰器，用于计算函数的执行时间，并将执行时间打印出来。要求装饰器可以同时用于同步函数和异步函数（协程）。 题目2：请编写一个装饰器，用于缓存函数的返回值。当相同的参数传入时，直接返回缓存的结果，而不重新计算。要求： - 缓存应该有一个过期时间（例如，默认10秒），过期后缓存失效。 - 可以指定缓存的最大大小（例如，最多缓存100个结果），当超过最大大小时，使用LRU策略淘汰最久未使用的缓存。 - 同时支持同步函数和异步函数。 下面分别给出两个题目的解答和代码。 </think> ### 题目1：计时装饰器（支持同步/异步函数） ```python import time import asyncio from functools import wraps from typing import Callable, Any def timer(func: Callable) -> Callable: """计算函数执行时间的装饰器，支持同步函数和异步协程""" @wraps(func) def sync_wrapper(*args, **kwargs) -> Any: start = time.perf_counter() result = func(*args, **kwargs) elapsed = time.perf_counter() - start print(f"同步函数 {func.__name__} 执行耗时: {elapsed:.4f}秒") return result @wraps(func) async def async_wrapper(*args, **kwargs) -> Any: start = time.perf_counter() result = await func(*args, **kwargs) elapsed = time.perf_counter() - start print(f"异步函数 {func.__name__} 执行耗时: {elapsed:.4f}秒") return result return async_wrapper if asyncio.iscoroutinefunction(func) else sync_wrapper # 测试用例 @timer def sync_task(n: int) -> int: """同步计算函数""" return sum(i * i for i in range(n)) @timer async def async_task(n: int) -> int: """异步计算函数""" await asyncio.sleep(1) # 模拟IO操作 return sum(i * i for i in range(n)) # 执行测试 print(sync_task(1000000)) # 同步调用 asyncio.run(async_task(1000)) # 异步调用 ``` #### 代码解释： 1. **双重包装设计**： - `sync_wrapper`：处理同步函数，使用`time.perf_counter()`计时 - `async_wrapper`：处理异步协程，使用`await`执行并计时 2. **自动类型检测**： - 通过`asyncio.iscoroutinefunction()`判断函数类型 - 返回对应的包装器，保持函数签名（`@wraps`的作用） 3. **高精度计时**： - 使用`time.perf_counter()`获取纳秒级时间戳 - 计算时间差并格式化输出 #### 执行结果示例： ``` 同步函数 sync_task 执行耗时: 0.0453秒 333332833333500000 异步函数 async_task 执行耗时: 1.0012秒 ``` --- ### 题目2：带过期时间和LRU的缓存装饰器 ```python import time import asyncio from functools import wraps from collections import OrderedDict from typing import Callable, Any, Union def smart_cache( max_size: int = 100, ttl: float = 10.0 ) -> Callable: """ 带LRU淘汰和过期时间的缓存装饰器 :param max_size: 最大缓存条目数 (LRU淘汰) :param ttl: 缓存有效期(秒) """ def decorator(func: Callable) -> Callable: cache = OrderedDict() # 有序字典保存缓存 @wraps(func) def sync_wrapper(*args, **kwargs) -> Any: key = (args, tuple(kwargs.items())) return process_cache(key, func, *args, **kwargs) @wraps(func) async def async_wrapper(*args, **kwargs) -> Any: key = (args, tuple(kwargs.items())) return await process_cache(key, func, *args, **kwargs) def process_cache( key: tuple, func: Callable, *args, **kwargs ) -> Union[Any, asyncio.Future]: """缓存处理核心逻辑""" # 检查缓存是否存在且未过期 if key in cache: result, timestamp = cache[key] if time.time() - timestamp < ttl: cache.move_to_end(key) # 更新为最近使用 return result # 执行函数并缓存结果 result = func(*args, **kwargs) if not asyncio.iscoroutinefunction(func) \ else asyncio.ensure_future(func(*args, **kwargs)) cache[key] = (result, time.time()) cache.move_to_end(key) # LRU淘汰 if len(cache) > max_size: cache.popitem(last=False) return result return async_wrapper if asyncio.iscoroutinefunction(func) else sync_wrapper return decorator # 测试用例 @smart_cache(max_size=3, ttl=2) def heavy_calculation(n: int) -> int: print(f"执行计算: {n}") return n * n @smart_cache(ttl=1.5) async def async_calculation(n: int) -> int: print(f"执行异步计算: {n}") await asyncio.sleep(0.5) return n ** 3 # 测试缓存 print(heavy_calculation(2)) # 首次计算 print(heavy_calculation(2)) # 命中缓存 time.sleep(3) print(heavy_calculation(2)) # 缓存过期 # 测试LRU淘汰 heavy_calculation(1) # 新缓存 heavy_calculation(3) # 新缓存 (缓存满) heavy_calculation(4) # 淘汰最早缓存(key=2) # 测试异步缓存 async def test_async(): print(await async_calculation(3)) print(await async_calculation(3)) # 命中 await asyncio.sleep(2) print(await async_calculation(3)) # 过期 asyncio.run(test_async()) ``` #### 代码解释： 1. **缓存结构**： - 使用`OrderedDict`存储`(参数元组): (结果, 时间戳)` - 通过`move_to_end()`实现LRU逻辑 2. **关键功能**： - **过期检测**：比较当前时间与缓存时间戳 - **LRU淘汰**：当缓存超过`max_size`时移除最旧条目 - **异步支持**：自动处理协程函数的`await`调用 3. **缓存键生成**： - 将`args`和排序后的`kwargs`转换为不可变类型作为键 - 确保相同参数产生相同键 #### 执行结果示例： ``` 执行计算: 2 4 4 # 命中缓存 执行计算: 2 # 3秒后过期重新计算 4 执行计算: 1 执行计算: 3 执行计算: 4 # 触发LRU淘汰 执行异步计算: 3 27 27 # 命中缓存 执行异步计算: 3 # 2秒后过期 27 ``` --- ### 装饰器核心知识点总结 1. **闭包应用**：装饰器本质是嵌套函数闭包 2. **函数签名保留**：使用`functools.wraps`保留元信息 3. **参数化装饰器**：通过嵌套函数实现带参数的装饰器 4. **类型区分**：动态检测同步/异步函数并适配 5. **缓存策略**：TTL过期机制 + LRU淘汰算法