Python如何实现缓存？提升程序效率方法-Python教程-PHP中文网

Python如何实现缓存？提升程序效率方法

星夢妙者

发布： 2025-07-23 09:45:41

原创

753人浏览过

python实现缓存的核心在于通过空间换时间提升效率，具体方法包括：1.使用字典存储计算结果，优点是简单易懂但存在内存溢出和冲突风险；2.使用functools.lru_cache装饰器，自动管理缓存大小，适合参数可哈希的场景；3.使用cachetools库，支持多种缓存算法但使用较复杂；4.使用redis或memcached实现分布式缓存，适合大数据量和分布式部署但需额外维护。选择策略应根据需求权衡，同时注意处理缓存失效、雪崩、击穿和穿透问题以保障系统稳定性。

Python如何实现缓存？提升程序效率方法

Python实现缓存，本质上就是在时间和空间上做权衡，用空间换时间，避免重复计算，提升程序运行效率。简单来说，就是把计算结果存起来，下次再用的时候直接拿，不用重新算。

解决方案

Python实现缓存的方法有很多种，从简单的字典到复杂的第三方库，可以根据实际需求选择。

使用字典 (Dictionary) 作为缓存:

立即学习“Python免费学习笔记（深入）”；

这是最简单的一种方式。用一个字典来存储已经计算过的结果，key是输入参数，value是对应的结果。
```
cache = {}

def fibonacci(n):
    if n in cache:
        return cache[n]
    if n <= 1:
        result = n
    else:
        result = fibonacci(n-1) + fibonacci(n-2)
    cache[n] = result
    return result

print(fibonacci(10)) # 输出: 55
print(fibonacci(10)) # 输出: 55 (直接从缓存读取)
```
登录后复制
这种方法的优点是简单易懂，缺点是缓存大小没有限制，可能会导致内存溢出。而且，这种缓存是全局的，多个函数之间共享可能会导致冲突。
使用 functools.lru_cache 装饰器:

functools.lru_cache 是 Python 内置的缓存装饰器，可以自动缓存函数的结果。它使用 LRU (Least Recently Used) 算法来淘汰缓存中的数据，可以限制缓存的大小。
```
from functools import lru_cache

@lru_cache(maxsize=128) # 设置缓存最大大小为128
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(10)) # 输出: 55
print(fibonacci(10)) # 输出: 55 (直接从缓存读取)
print(fibonacci.cache_info()) # 查看缓存信息
```
登录后复制
lru_cache 的优点是使用简单，功能强大，可以自动管理缓存的大小。缺点是只能缓存函数的参数和返回值都是可哈希的类型。
使用第三方缓存库 (例如 cachetools):

Natural Language Playlist
探索语言和音乐之间丰富而复杂的关系，并使用 Transformer 语言模型构建播放列表。

67

查看详情

cachetools 是一个功能更强大的缓存库，提供了多种缓存算法，例如 LRU, LFU (Least Frequently Used), MRU (Most Recently Used) 等。
```
import cachetools

cache = cachetools.LRUCache(maxsize=128)

def fibonacci(n):
    if n in cache:
        return cache[n]
    if n <= 1:
        result = n
    else:
        result = fibonacci(n-1) + fibonacci(n-2)
    cache[n] = result
    return result

print(fibonacci(10)) # 输出: 55
print(fibonacci(10)) # 输出: 55 (直接从缓存读取)
print(cache.currsize) # 查看当前缓存大小
```
登录后复制
cachetools 的优点是灵活性高，可以根据实际需求选择不同的缓存算法。缺点是使用起来稍微复杂一些。
使用 Redis 或 Memcached 作为分布式缓存:

如果程序是分布式部署的，或者需要缓存的数据量很大，可以考虑使用 Redis 或 Memcached 作为分布式缓存。这些缓存系统可以将数据存储在内存中，并提供快速的读写速度。
```
import redis

r = redis.Redis(host='localhost', port=6379, db=0)

def fibonacci(n):
    key = f"fibonacci:{n}"
    result = r.get(key)
    if result:
        return int(result)
    if n <= 1:
        result = n
    else:
        result = fibonacci(n-1) + fibonacci(n-2)
    r.set(key, result)
    return result

print(fibonacci(10)) # 输出: 55
print(fibonacci(10)) # 输出: 55 (直接从缓存读取)
```
登录后复制
使用 Redis 或 Memcached 的优点是缓存容量大，可以支持分布式部署。缺点是需要额外的部署和维护成本。

如何选择合适的缓存策略？

选择合适的缓存策略取决于你的具体需求。如果只是简单的函数缓存，functools.lru_cache 通常就足够了。如果需要更复杂的缓存策略，或者需要分布式缓存，可以考虑使用 cachetools、Redis 或 Memcached。

缓存失效策略有哪些？如何选择？

缓存失效策略决定了何时从缓存中移除数据。常见的策略包括：

TTL (Time To Live): 设置缓存的过期时间，超过时间后自动失效。适用于数据有时间限制的场景。
LRU (Least Recently Used): 移除最近最少使用的数据。适用于数据访问频率不均匀的场景。
LFU (Least Frequently Used): 移除使用频率最低的数据。适用于需要保留常用数据的场景。
手动失效: 通过代码手动移除缓存中的数据。适用于需要精确控制缓存失效的场景。

选择哪种策略取决于数据的特点和业务需求。例如，对于经常变化的数据，应该使用较短的 TTL。对于不经常变化的数据，可以使用 LRU 或 LFU。

缓存雪崩、击穿和穿透是什么？如何避免？

这三个是缓存常见的并发问题，理解它们有助于更好地使用缓存：

缓存雪崩: 大量缓存同时失效，导致请求直接打到数据库，造成数据库压力过大甚至崩溃。
- 避免方法: 设置不同的过期时间，避免同时失效；使用互斥锁，保证只有一个请求打到数据库；使用熔断降级策略，保护数据库。
缓存击穿: 某个热点数据缓存失效，导致大量请求打到数据库。
- 避免方法: 设置永不过期的热点数据；使用互斥锁，保证只有一个请求打到数据库；预热缓存，提前将热点数据加载到缓存中。
缓存穿透: 请求的数据在缓存和数据库中都不存在，导致每次请求都打到数据库。
- 避免方法: 缓存空对象，将不存在的数据也缓存起来；使用布隆过滤器，快速判断数据是否存在；限制非法请求，防止恶意攻击。