Python如何使用LRU缓存策略进行缓存

在编程中，缓存是一种常用的优化技术，用于存储计算结果，以便在后续的相同请求中快速返回结果，而不必重新计算。LRU（Least Recently Used，最近最少使用）是一种常见的缓存替换策略，它会优先淘汰最近最少使用的缓存项。Python 提供了多种方式来实现 LRU 缓存，本文将介绍如何使用 Python 内置的 functools.lru_cache 装饰器以及如何手动实现 LRU 缓存。

1. 使用 functools.lru_cache 装饰器

Python 的 functools 模块提供了一个非常方便的装饰器 lru_cache，可以轻松地为函数添加 LRU 缓存功能。lru_cache 装饰器会自动缓存函数的返回值，并在后续调用时直接返回缓存的结果，而不必重新计算。

1.1 基本用法

from functools import lru_cache

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

print(fibonacci(50))

在上面的例子中，fibonacci 函数计算斐波那契数列的第 n 项。由于斐波那契数列的计算具有重叠子问题，使用 lru_cache 可以显著提高计算效率。maxsize 参数指定了缓存的最大大小，当缓存达到最大大小时，最近最少使用的缓存项将被淘汰。

1.2 缓存命中与未命中

lru_cache 装饰器还提供了 cache_info() 方法，用于查看缓存的命中率、未命中次数等信息。

print(fibonacci.cache_info())

输出可能类似于：

CacheInfo(hits=48, misses=51, maxsize=128, currsize=51)

• hits：缓存命中的次数。
• misses：缓存未命中的次数。
• maxsize：缓存的最大大小。
• currsize：当前缓存的大小。

1.3 清除缓存

如果需要清除缓存，可以使用 cache_clear() 方法。

fibonacci.cache_clear()

2. 手动实现 LRU 缓存

虽然 functools.lru_cache 提供了非常方便的 LRU 缓存功能，但在某些情况下，我们可能需要手动实现 LRU 缓存，以便更灵活地控制缓存的行为。

2.1 使用 collections.OrderedDict

Python 的 collections 模块中的 OrderedDict 可以用于手动实现 LRU 缓存。OrderedDict 是一个有序字典，它会记住键值对的插入顺序。

from collections import OrderedDict

class LRUCache:
    def __init__(self, capacity: int):
        self.cache = OrderedDict()
        self.capacity = capacity

    def get(self, key: int) -> int:
        if key not in self.cache:
            return -1
        else:
            self.cache.move_to_end(key)
            return self.cache[key]

    def put(self, key: int, value: int) -> None:
        if key in self.cache:
            self.cache.move_to_end(key)
        self.cache[key] = value
        if len(self.cache) > self.capacity:
            self.cache.popitem(last=False)

在上面的代码中，LRUCache 类实现了一个简单的 LRU 缓存。get 方法用于获取缓存项，如果缓存项存在，则将其移动到字典的末尾（表示最近使用）。put 方法用于添加或更新缓存项，如果缓存项已存在，则将其移动到末尾；如果缓存大小超过容量，则移除最旧的缓存项。

2.2 使用示例

cache = LRUCache(2)

cache.put(1, 1)
cache.put(2, 2)
print(cache.get(1))  # 返回 1
cache.put(3, 3)      # 移除键 2
print(cache.get(2))  # 返回 -1 (未找到)
cache.put(4, 4)      # 移除键 1
print(cache.get(1))  # 返回 -1 (未找到)
print(cache.get(3))  # 返回 3
print(cache.get(4))  # 返回 4

3. 总结

LRU 缓存是一种非常有效的缓存策略，特别适用于需要频繁访问相同数据的场景。Python 提供了 functools.lru_cache 装饰器，可以轻松地为函数添加 LRU 缓存功能。此外，我们还可以使用 collections.OrderedDict 手动实现 LRU 缓存，以便更灵活地控制缓存的行为。

无论是使用内置的 lru_cache 还是手动实现 LRU 缓存，都可以显著提高程序的性能，特别是在处理递归或重复计算时。