2k Star！cachetools：一款超好用的Python高效缓存管理工具 - 文章 - 开发者社区

点击上方“蓝色字体”关注我，选择“设为星标”！

回复“电子书”领取超多经典计算机书籍

picture.image

引言

在现代软件开发中，缓存是提高应用程序性能的关键技术之一。

它通过减少对数据库、API或其他慢速数据源的重复查询，显著降低了系统的响应时间。

而Python的cachetools库提供了一个简单而强大的接口，用于实现各种缓存策略。

安装cachetools

cachetools可以通过Python的包管理工具pip进行安装。

在命令行中输入以下命令即可完成安装：

  
pip install cachetools

基本使用

cachetools提供了多种缓存策略，其中最常用的是使用 LRU缓存 。

下面是一个简单的LRU缓存使用示例：


   
from cachetools import LRUCache  
  
# 创建一个最大容量为10的LRU缓存  
cache = LRUCache(maxsize=10)  
  
# 向缓存中添加数据  
cache['key1'] = 'value1'  
cache['key2'] = 'value2'  
  
# 访问缓存中的数据  
print(cache['key1'])  # 输出: value1  
  
# 添加新数据，如果缓存已满，将移除最近最少使用的项  
cache['key3'] = 'value3'  
  
# 尝试访问一个不存在的键，将返回None  
print(cache.get('nonexistent'))  # 输出: None

当然我们最常用的是cachetools的装饰器用法，通常将其应用于函数缓存。自动处理函数的调用和缓存逻辑。

cachetools提供了一个名为cached 的装饰器，它可以用来缓存函数的结果。

这个装饰器接受几个参数，包括缓存的最大大小和可选的过期时间。

下面是一个使用cached装饰器的简单示例：


   
from cachetools import cached, LRUCache  
  
# 创建一个LRU缓存对象，最大容量为10  
cache = LRUCache(maxsize=10)  
  
# 定义一个简单的函数  
@cached(cache)  
def add(a, b):  
    return a + b  
  
# 调用函数，结果将被缓存  
print(add(2, 3))  # 输出: 5  
  
# 再次调用相同的函数，将直接从缓存中获取结果  
print(add(2, 3))  # 输出: 5（从缓存中获取）

应用场景

1. 计算密集型操作

计算密集型函数通常需要消耗大量的CPU资源。

通过使用cachetools的装饰器，我们可以避免重复计算，从而提高效率。


   
from math import sqrt  
from cachetools import cached  
  
@cached(cache=LRUCache(maxsize=100))  
def compute\_square\_root(n):  
    """计算并缓存一个数的平方根"""  
    return sqrt(n)  
  
# 第一次调用时会计算并缓存结果  
print(compute\_square\_root(25))  # 输出: 5.0  
  
# 后续调用将直接从缓存中获取结果  
print(compute\_square\_root(25))  # 输出: 5.0（从缓存中获取）

2. I/O密集型操作

I/O密集型操作，如文件读取或数据库查询，通常涉及等待外部资源，使用缓存可以显著减少这些操作的响应时间。


   
from cachetools import cached  
import time  
  
# 假设这是一个I/O密集型操作  
@cached(cache=LRUCache(maxsize=10))  
def read\_file(filename):  
    time.sleep(2)  # 模拟I/O操作耗时  
    with open(filename, 'r') as file:  
        return file.read()  
  
# 第一次调用时会模拟I/O操作并缓存结果  
print(read\_file('example.txt'))  # 输出文件内容，等待2秒  
  
# 后续调用将直接从缓存中获取结果，无需等待  
print(read\_file('example.txt'))  # 立即输出文件内容，无需等待

代码Demo

以下是上述应用场景的完整代码示例：


   
import time  
from cachetools import LRUCache, cached  
  
# 计算平方根的缓存函数  
@cached(cache=LRUCache(maxsize=100))  
def compute\_square\_root(n):  
    return n ** 0.5  
  
# 模拟I/O操作的缓存函数  
@cached(cache=LRUCache(maxsize=10))  
def simulate\_io\_operation():  
    time.sleep(2)  # 模拟耗时的I/O操作  
    return "Result of I/O operation"  
  
# 测试计算平方根的缓存函数  
print(compute\_square\_root(16))  # 第一次调用，计算并缓存结果  
time.sleep(1)  # 等待1秒  
print(compute\_square\_root(16))  # 再次调用，从缓存中获取结果  
  
# 测试模拟I/O操作的缓存函数  
print(simulate\_io\_operation())  # 第一次调用，模拟I/O操作并缓存结果  
time.sleep(1)  # 等待1秒  
print(simulate\_io\_operation())  # 再次调用，从缓存中获取结果，无需等待