使用装饰器实现函数结果缓存：避免 setdefault 的陷阱（缓存.函数.陷阱.装饰.setdefault...）

使用装饰器实现函数结果缓存：避免 setdefault 的陷阱

在 Python 中，我们经常需要对一些计算密集型的函数进行优化，避免重复计算相同参数的结果。一种常见的做法是使用缓存，将函数的结果保存下来，下次使用相同的参数调用时直接返回缓存的结果。装饰器是一种优雅的实现缓存的方式，但如果不小心，可能会掉入一些陷阱。

setdefault 的误用

一个常见的误用是在缓存装饰器中使用 dict.setdefault 方法。例如：

def wrapper2(*args, **kwargs):
    global cache
    return cache.setdefault(args, func(*args, **kwargs))

这段代码看起来似乎很简洁，但实际上存在问题。dict.setdefault(key, default) 的行为是：如果 key 存在于字典中，则返回 key 对应的值；否则，将 key 和 default 添加到字典中，并返回 default。

关键在于，无论 key 是否存在于字典中，default 都会被计算。因此，func(*args, **kwargs) 会在每次调用 wrapper2 时执行，即使缓存中已经存在结果。这完全违背了缓存的初衷。

等价于：

result = func(*args, **kwargs)
return cache.setdefault(args, result)

更健壮的缓存装饰器

为了避免 setdefault 的陷阱，我们需要手动检查缓存中是否存在结果。一个更健壮的缓存装饰器实现如下：

Teleporthq

一体化AI网站生成器，能够快速设计和部署静态网站

182 查看详情 Teleporthq

import functools

def cacheDecorator(func):
    cache = {}  # 为每个函数创建一个独立的缓存

    @functools.wraps(func)  # 保留原始函数的元数据
    def wrapper(*args, **kwargs):
        # 创建缓存键，考虑 args 和 kwargs
        cache_key = (args, tuple(sorted(kwargs.items())))
        if cache_key in cache:
            return cache[cache_key]
        else:
            ret_val = func(*args, **kwargs)
            cache[cache_key] = ret_val
            return ret_val

    return wrapper

代码解释：

functools.wraps(func): 这个装饰器用于保留原始函数的元数据，例如 __name__ 和 __doc__。这有助于调试和文档生成。
独立的缓存: cache = {} 在 cacheDecorator 内部定义，为每个被装饰的函数创建一个独立的缓存。避免了多个函数共享同一个缓存导致的问题。
缓存键的生成: cache_key = (args, tuple(sorted(kwargs.items()))) 将 args 和 kwargs 组合成一个元组作为缓存键。 kwargs 需要先排序再转换为元组，以确保相同键值对但顺序不同的 kwargs 生成相同的缓存键。
缓存查找和更新: 如果 cache_key 存在于缓存中，直接返回缓存的值；否则，调用原始函数计算结果，并将结果添加到缓存中。

示例：

import logging
import sys
import time

logging.basicConfig(
    format="%(asctime)s [%(levelname)s] %(name)s - %(message)s",
    level=logging.INFO,
    datefmt="%Y-%m-%d %H:%M:%S",
    stream=sys.stdout,
)
logger = logging.getLogger("mylogger")

import functools

def cacheDecorator(func):
    cache = {}  # 为每个函数创建一个独立的缓存

    @functools.wraps(func)  # 保留原始函数的元数据
    def wrapper(*args, **kwargs):
        # 创建缓存键，考虑 args 和 kwargs
        cache_key = (args, tuple(sorted(kwargs.items())))
        if cache_key in cache:
            logger.info(f"Cache hit for {func.__name__} with args: {args}, kwargs: {kwargs}")
            return cache[cache_key]
        else:
            logger.info(f"Cache miss for {func.__name__} with args: {args}, kwargs: {kwargs}")
            ret_val = func(*args, **kwargs)
            cache[cache_key] = ret_val
            return ret_val

    return wrapper

@cacheDecorator
def slow_function(a, b, c=1):
    logger.info("Executing slow_function...")
    time.sleep(2)  # 模拟耗时操作
    return a * b * c

logger.info (f'Result from executing slow_function(1,2) = {slow_function(1,2)}')
logger.info (f'Result from executing slow_function(1,2) again = {slow_function(1,2)}')
logger.info (f'Result from executing slow_function(1,2, c=3) = {slow_function(1,2, c=3)}')
logger.info (f'Result from executing slow_function(1,2, c=3) again = {slow_function(1,2, c=3)}')

输出:

2024-10-27 16:31:27 [INFO] mylogger - Cache miss for slow_function with args: (1, 2), kwargs: {}
2024-10-27 16:31:27 [INFO] mylogger - Executing slow_function...
2024-10-27 16:31:29 [INFO] mylogger - Result from executing slow_function(1,2) = 2
2024-10-27 16:31:29 [INFO] mylogger - Cache hit for slow_function with args: (1, 2), kwargs: {}
2024-10-27 16:31:29 [INFO] mylogger - Result from executing slow_function(1,2) again = 2
2024-10-27 16:31:29 [INFO] mylogger - Cache miss for slow_function with args: (1, 2), kwargs: {'c': 3}
2024-10-27 16:31:29 [INFO] mylogger - Executing slow_function...
2024-10-27 16:31:31 [INFO] mylogger - Result from executing slow_function(1,2, c=3) = 6
2024-10-27 16:31:31 [INFO] mylogger - Cache hit for slow_function with args: (1, 2), kwargs: {'c': 3}
2024-10-27 16:31:31 [INFO] mylogger - Result from executing slow_function(1,2, c=3) again = 6

可以看到，第一次调用 slow_function(1, 2) 和 slow_function(1, 2, c=3) 时，Executing slow_function... 会被打印，说明函数被实际执行了。后续使用相同的参数调用时，直接从缓存中返回结果，不再执行原始函数。

注意事项

缓存键的唯一性: 确保缓存键能够唯一标识函数的输入。如果函数的参数是可变对象（例如列表或字典），需要小心处理，避免缓存键的冲突。可以使用 tuple(arg) 来将列表转换为元组作为缓存键，但要注意列表内容的变化会导致缓存失效。
缓存大小限制: 缓存可能会占用大量内存，特别是当函数的输入空间很大时。可以考虑使用 LRU (Least Recently Used) 缓存或其他缓存淘汰策略来限制缓存的大小。 functools.lru_cache 是一个方便的工具，可以实现 LRU 缓存。
线程安全性: 如果你的程序是多线程的，需要确保缓存的访问是线程安全的。可以使用锁或其他同步机制来保护缓存。

总结

使用装饰器实现函数结果缓存是一种有效的优化手段。避免使用 dict.setdefault，并仔细考虑缓存键的生成、缓存大小限制和线程安全性，可以编写出健壮的缓存装饰器，提高程序的性能。

以上就是使用装饰器实现函数结果缓存：避免 setdefault 的陷阱的详细内容，更多请关注知识资源分享宝库其它相关文章！

相关标签： python app 工具 ai 键值对同步机制 asic Python 线程多线程对象 default 大家都在看： Python自定义异常钩子：优雅抑制未捕获异常的控制台输出使用 LaTeX 和 Sage 软件包调用 Python 函数获取单词释义将Python日志输出到PySimpleGUI多行文本框的教程与常见陷阱解析 Python中定制异常处理：抑制未捕获异常的默认控制台输出 python如何使用socket进行网络通信_python socket套接字网络编程入门