站点图标 Park Lam's 每日分享

Python实用工具：cachetools使用教程

Park Lam

一、Python在各领域的广泛性及重要性

Python作为一种高级编程语言，凭借其简洁易读的语法和强大的功能，已广泛应用于多个领域。在Web开发中，Django、Flask等框架助力开发者快速搭建高效的网站；数据分析和数据科学领域，NumPy、Pandas、Matplotlib等库让数据处理与可视化变得轻松；机器学习和人工智能方面，TensorFlow、PyTorch等推动着算法的创新与应用；桌面自动化和爬虫脚本中，Python能高效完成各种任务；金融和量化交易领域，它可用于风险分析、交易策略开发等；教育和研究方面，Python也成为了重要的工具。Python的这些应用，让其在当今科技发展中占据了重要地位。

本文将介绍Python的一个实用库——cachetools。cachetools是一个用于缓存的Python库，它能帮助开发者优化程序性能，减少重复计算，提高程序运行效率。

二、cachetools的用途、工作原理、优缺点及License类型

用途

cachetools主要用于缓存函数的返回值，当相同的参数再次调用函数时，可以直接从缓存中获取结果，而不需要重新执行函数，从而提高程序的运行效率。它适用于需要频繁调用且计算成本较高的函数。

工作原理

cachetools通过装饰器或直接使用缓存对象的方式，将函数的输入参数和返回值存储在缓存中。当函数被调用时，先检查缓存中是否存在该参数对应的结果，如果存在则直接返回缓存中的结果，否则执行函数并将结果存入缓存。

优缺点

优点：

缺点：

License类型

cachetools采用MIT License，这是一种宽松的开源许可证，允许用户自由使用、修改和分发该库。

三、cachetools的使用方式

安装

使用pip安装cachetools：

pip install cachetools

基本使用

使用装饰器缓存函数结果

cachetools提供了多种装饰器来缓存函数结果，下面是一个使用lru_cache装饰器的示例：

from cachetools import lru_cache

@lru_cache(maxsize=3)  # 最多缓存3个结果
def expensive_function(x):
    print(f"计算 {x} 的结果...")
    return x * x

# 第一次调用，需要计算
print(expensive_function(2))  # 输出: 计算 2 的结果... 4

# 第二次调用相同参数，直接从缓存获取
print(expensive_function(2))  # 输出: 4

# 调用不同参数
print(expensive_function(3))  # 输出: 计算 3 的结果... 9

# 缓存已满，再调用新参数，会淘汰最久未使用的缓存
print(expensive_function(4))  # 输出: 计算 4 的结果... 16
print(expensive_function(5))  # 输出: 计算 5 的结果... 25

# 再次调用参数2，由于之前的缓存已被淘汰，需要重新计算
print(expensive_function(2))  # 输出: 计算 2 的结果... 4

直接使用缓存对象

除了使用装饰器，还可以直接创建缓存对象来管理缓存：

from cachetools import LRUCache

# 创建一个LRU缓存，最多存储3个元素
cache = LRUCache(maxsize=3)

def expensive_function(x):
    print(f"计算 {x} 的结果...")
    return x * x

# 手动管理缓存
def cached_expensive_function(x):
    if x in cache:
        return cache[x]
    result = expensive_function(x)
    cache[x] = result
    return result

# 第一次调用，需要计算
print(cached_expensive_function(2))  # 输出: 计算 2 的结果... 4

# 第二次调用相同参数，直接从缓存获取
print(cached_expensive_function(2))  # 输出: 4

不同缓存策略

LRU（最近最少使用）缓存

LRU缓存会淘汰最久未使用的数据，适合热点数据的缓存。

from cachetools import LRUCache

cache = LRUCache(maxsize=3)

cache[1] = 'a'
cache[2] = 'b'
cache[3] = 'c'

print(cache)  # 输出: LRUCache({1: 'a', 2: 'b', 3: 'c'})

# 使用键2，使其变为最近使用
cache[2]

# 添加新元素，会淘汰最久未使用的元素1
cache[4] = 'd'

print(cache)  # 输出: LRUCache({2: 'b', 3: 'c', 4: 'd'})

LFU（最不经常使用）缓存

LFU缓存会淘汰使用频率最低的数据，适合使用频率分布不均匀的数据。

from cachetools import LFUCache

cache = LFUCache(maxsize=3)

cache[1] = 'a'
cache[2] = 'b'
cache[3] = 'c'

# 使用键1两次
cache[1]
cache[1]

# 使用键2一次
cache[2]

# 添加新元素，会淘汰使用频率最低的元素3
cache[4] = 'd'

print(cache)  # 输出: LFUCache({1: 'a', 2: 'b', 4: 'd'})

FIFO（先进先出）缓存

FIFO缓存按照元素添加的顺序淘汰数据，最先添加的元素最先被淘汰。

from cachetools import FIFOCache

cache = FIFOCache(maxsize=3)

cache[1] = 'a'
cache[2] = 'b'
cache[3] = 'c'

# 添加新元素，会淘汰最先添加的元素1
cache[4] = 'd'

print(cache)  # 输出: FIFOCache({2: 'b', 3: 'c', 4: 'd'})

RRCache（随机替换）缓存

RRCache会随机淘汰缓存中的元素。

from cachetools import RRCache

cache = RRCache(maxsize=3)

cache[1] = 'a'
cache[2] = 'b'
cache[3] = 'c'

# 添加新元素，会随机淘汰一个元素
cache[4] = 'd'

print(cache)  # 输出可能是: RRCache({1: 'a', 3: 'c', 4: 'd'}) 或其他组合

缓存参数设置

maxsize参数

maxsize参数指定缓存的最大容量，当缓存达到最大容量时，会根据缓存策略淘汰数据。

from cachetools import LRUCache

# 缓存容量为2
cache = LRUCache(maxsize=2)

cache[1] = 'a'
cache[2] = 'b'

print(cache)  # 输出: LRUCache({1: 'a', 2: 'b'})

cache[3] = 'c'  # 添加新元素，会淘汰最久未使用的元素1

print(cache)  # 输出: LRUCache({2: 'b', 3: 'c'})

typed参数

typed参数用于指定是否区分不同类型的参数，默认为False。如果设置为True，则不同类型的参数会被视为不同的缓存键。

from cachetools import lru_cache

@lru_cache(maxsize=3, typed=True)
def add(a, b):
    print(f"计算 {a} + {b}...")
    return a + b

# 整数和浮点数参数被视为不同的缓存键
print(add(1, 2))  # 输出: 计算 1 + 2... 3
print(add(1.0, 2.0))  # 输出: 计算 1.0 + 2.0... 3.0

缓存管理

清除缓存

可以使用cache_clear()方法清除缓存中的所有数据。

from cachetools import lru_cache

@lru_cache(maxsize=3)
def square(x):
    print(f"计算 {x} 的平方...")
    return x * x

# 调用函数，结果存入缓存
print(square(2))  # 输出: 计算 2 的平方... 4
print(square(2))  # 输出: 4

# 清除缓存
square.cache_clear()

# 再次调用相同参数，需要重新计算
print(square(2))  # 输出: 计算 2 的平方... 4

查看缓存信息

可以使用cache_info()方法查看缓存的统计信息，包括命中次数、未命中次数、最大容量和当前大小。

from cachetools import lru_cache

@lru_cache(maxsize=3)
def cube(x):
    print(f"计算 {x} 的立方...")
    return x * x * x

# 调用函数
print(cube(2))  # 输出: 计算 2 的立方... 8
print(cube(2))  # 输出: 8
print(cube(3))  # 输出: 计算 3 的立方... 27

# 查看缓存信息
print(cube.cache_info())  # 输出: CacheInfo(hits=1, misses=2, maxsize=3, currsize=2)

四、实际案例

案例一：API请求结果缓存

在进行API请求时，相同的请求可能会多次发送，使用cachetools可以缓存API请求结果，减少网络请求，提高程序性能。

import requests
from cachetools import TTLCache

# 创建一个TTL缓存，每个结果最多缓存60秒
cache = TTLCache(maxsize=100, ttl=60)

def get_data(url):
    if url in cache:
        print(f"从缓存获取数据: {url}")
        return cache[url]

    print(f"发送网络请求: {url}")
    response = requests.get(url)
    data = response.json()
    cache[url] = data
    return data

# 第一次请求，发送网络请求
data1 = get_data("https://api.example.com/data")

# 60秒内再次请求相同URL，从缓存获取
data2 = get_data("https://api.example.com/data")

# 等待60秒后再次请求，缓存已过期，重新发送网络请求
import time
time.sleep(61)
data3 = get_data("https://api.example.com/data")

案例二：计算密集型任务缓存

对于计算密集型任务，如递归计算斐波那契数列，使用cachetools可以显著提高计算效率。

from cachetools import lru_cache

@lru_cache(maxsize=128)
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# 第一次计算，需要递归计算多个值
print(fibonacci(30))  # 输出: 832040

# 第二次计算相同值，直接从缓存获取，几乎瞬间完成
print(fibonacci(30))  # 输出: 832040

案例三：数据库查询结果缓存

在Web应用中，经常需要查询数据库，使用cachetools可以缓存查询结果，减少数据库访问压力。

from cachetools import LRUCache
import sqlite3

# 创建一个LRU缓存，最多存储100个查询结果
cache = LRUCache(maxsize=100)

def query_db(sql, params=()):
    key = (sql, params)
    if key in cache:
        print(f"从缓存获取查询结果: {sql}")
        return cache[key]

    print(f"执行数据库查询: {sql}")
    conn = sqlite3.connect("example.db")
    cursor = conn.cursor()
    cursor.execute(sql, params)
    result = cursor.fetchall()
    conn.close()

    cache[key] = result
    return result

# 第一次查询，执行数据库查询
users = query_db("SELECT * FROM users WHERE age > ?", (25,))

# 第二次查询相同条件，从缓存获取
users = query_db("SELECT * FROM users WHERE age > ?", (25,))

五、相关资源

关注我，每天分享一个实用的Python自动化工具。

退出移动版