管窥程序

Today is a gift

0%

让你的方法快人一步的缓存利器

发表于 阅读次数： Valine：

在编程的世界里，性能优化是个大问题。有时候我们会遇到一些执行起来比较慢的方法，它们可能会消耗大量的时间和资源。为了提高程序的速度，最容易想到的方法就是利用缓存，将相同参数的返回值缓存起了，避免重复执行。但用好缓存难度很大，对编程的要求比较高。今天，我要向大家介绍一个超级厉害的缓存工具库——cachetools

cachetools 是什么？

cachetools 是一个牛逼的 Python 缓存工具库，它可以让我们轻松地缓存方法的返回值。它的设计初衷就是为了让方法执行起来更快。cachetools 提供了各种各样的缓存策略和数据结构，比如基于时间的过期策略、基于大小的淘汰策略等等，你可以根据自己的需求来选择合适的策略。

安装

如果你还没有安装这个库，不用但心，安装 cachetools 是非常简单的。

首先，确保你的 Python 环境已经安装了 pip。然后，打开终端或命令提示符窗口，并执行以下命令：

1
pip install cachetools

这将会从 Python 包索引中下载并安装最新版本的 cachetools。安装完成后，你就可以在你的项目中使用 cachetools 了。

现在你已经安装了 cachetools，可以开始享受它带来的缓存优势了！

小试牛刀

cachetools 提供了一个超级方便的 cached() 装饰器，可以让我们轻松地缓存方法的返回值。下面是一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from cachetools import cached

@cached(cache={})
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# 第一次调用 fibonacci(5)，它会执行实际的逻辑并缓存结果
result = fibonacci(5)
print(result)  # 输出: 5

# 第二次调用 fibonacci(5)，它会直接从缓存中拿结果
result = fibonacci(5)
print(result)  # 输出: 5

在这个例子中，我们把 fibonacci() 方法装饰成了一个缓存方法，并用一个空字典作为缓存存储。

第一次调用 fibonacci(5) 时，它会执行实际的逻辑，并把结果存到缓存里。

第二次调用 fibonacci(5) 时，它会直接从缓存中拿结果，避免了重复执行相同参数的方法。

使用策略

上面的例子中，我们只是创建了一个最简单的缓存，cachetools 还提供了很多缓存淘汰策略，用于在缓存空间不足时决定哪些条目应该被淘汰。比如先进先出（FIFO）策略。

FIFO 策略指定当缓存空间不足时，应该淘汰最早添加到缓存中的条目。这种策略适用于那些不需要频繁更新的数据，例如静态数据或者只读数据。它可以确保缓存中的数据始终是最新的，同时避免缓存中存储过多的过时数据。

要在 cachetools 中使用 FIFO 策略，你可以使用 FIFOCache 类。下面是一个示例：

1
2
3
4
5
6
7
8
from cachetools import cached, FIFOCache

@cached(cache=FIFOCache(maxsize=100))
def expensive_operation(n):
    # 执行昂贵的操作
    return result

result = expensive_operation(42)

在这个示例中，我们使用 FIFOCache 类创建了一个最大容量为 100 的缓存。当缓存空间不足时，最早添加到缓存中的条目将被淘汰。

需要注意的是，FIFO 策略只是 cachetools 提供的众多缓存淘汰策略之一。根据你的具体需求，你也可以选择其他策略，如最近最少使用（LRU）策略、最少使用（LFU）策略等。每种策略都有其适用的场景，你可以根据实际情况选择合适的策略来优化缓存性能。

缓存的秘密

cachetools 是基于什么创建的缓存呢？也许你已经想到了，是基于调用方法的参数为缓存创建的索引。每次调用被缓存的方法时，cachetools 会根据方法的参数生成一个唯一的键，并把这个键和方法的返回值关联起来。只要再次调用方法时，如果提供的参已经创建过缓存了，就会直接通过参数转换过来的索引值，提取缓存值返回了。

需要注意的是，由于缓存是基于参数的哈希值进行的，所以对于非方法返回值的缓存，你需要确保参数的唯一性，以避免不同参数的结果被错误地缓存和混淆。

现在我们能注意到，cachetools 的关键是缓存策略，比如 {}、FIFO 等，那么我们就可以单独使用这些策略，构筑更个性的缓存工具。

扩展应用

现在我们利用生存时间策略（TTL），构筑一个 Store 类。这个类提供一个 set 和 get 方法，用于设置值和提取值。看例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from cachetools import TTLCache

class Store:
    def __init__(self):
        self.cache = TTLCache(ttl=60)  # 不限制缓存大小，只设置超时时间为60秒

    def set(self, key, value):
        self.cache[key] = value

    def get(self, key):
        return self.cache.get(key)

# 示例用法
store = Store()
store.set('key1', 'value1')
store.set('key2', 'value2')

print(store.get('key1'))  # 输出: value1
print(store.get('key2'))  # 输出: value2
print(store.get('key3'))  # 输出: None

在上面的示例中，我们创建了一个 Store 类，其中使用 TTLCache 类作为缓存的实现。

TTLCache 类接受两个参数：maxsize 表示缓存的最大大小（可选，默认不限制大小），ttl 表示缓存的超时时间（以秒为单位）。

在 set 方法中，我们将键值对存储到缓存中。

在 get 方法中，我们使用 cache.get(key) 来获取缓存中的值，如果键不存在或已过期，则返回 None。

相同的，我们也可以通过其他策略类构筑其他业务上需要的缓存工具。

总结

cachetools 是一个超级厉害的缓存工具库，可以帮助我们提升方法的执行效率。通过使用 cached() 装饰器，我们可以轻松地缓存方法的返回值，避免重复执行相同参数的方法，并且可以选择不同的缓存策略。

不过要记住，由于缓存是基于参数的哈希值进行的，所以确保方法在相同的参数下始终返回相同的值是非常重要的，这样才能避免缓存结果和实际方法调用的结果不一致。

我们还可以利用 cachetools 提供的策略类，构筑个性的缓存工具，而不必重复造轮子。

笔者的水平有限，文章中难免出现各种错误和问题，恳请读者不吝批评、指正。十分感谢！

比心。