在 Python 中，字典是一种非常灵活且高效的数据结构，常用于存储键值对。除了基本的数据存储功能外，字典还可以作为一种简单的缓存机制，提高程序的性能。本文将详细介绍如何使用字典作为缓存机制，并通过实际代码示例逐步引导你理解和应用这一技术。
1. 字典的基本概念
字典是 Python 中的一种内置数据类型，它以键值对的形式存储数据。每个键都是唯一的，可以通过键快速访问对应的值。创建字典非常简单：
# 创建一个字典
my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}
print(my_dict) # 输出: {'apple': 1, 'banana': 2, 'cherry': 3}2. 字典的基本操作
字典支持多种操作，包括添加、删除、修改和查询键值对。以下是一些常见的操作示例：
# 添加键值对
my_dict['date'] = '2023-10-01'
print(my_dict) # 输出: {'apple': 1, 'banana': 2, 'cherry': 3, 'date': '2023-10-01'}
# 修改键值对
my_dict['apple'] = 10
print(my_dict) # 输出: {'apple': 10, 'banana': 2, 'cherry': 3, 'date': '2023-10-01'}
# 删除键值对
del my_dict['banana']
print(my_dict) # 输出: {'apple': 10, 'cherry': 3, 'date': '2023-10-01'}
# 查询键值对
print(my_dict.get('cherry')) # 输出: 3
print(my_dict.get('orange', 'Not Found')) # 输出: Not Found3. 字典作为缓存机制
缓存是一种优化技术，用于存储计算结果或频繁访问的数据，以便在后续请求中快速返回。字典非常适合用作缓存，因为它的查找时间复杂度为 O(1)，即常数时间。
基本缓存示例
假设我们有一个函数 compute，计算一个数字的平方根。我们可以使用字典来缓存已经计算过的结果，避免重复计算。
import math
# 创建一个空字典作为缓存
cache = {}
def compute(x):
if x in cache:
print(f"Using cached result for {x}")
return cache[x]
else:
result = math.sqrt(x)
cache[x] = result
print(f"Computed and cached result for {x}")
return result
# 测试缓存
print(compute(16)) # 输出: Computed and cached result for 16
# 4.0
print(compute(16)) # 输出: Using cached result for 16
# 4.0
print(compute(25)) # 输出: Computed and cached result for 25
# 5.0
print(compute(25)) # 输出: Using cached result for 25
# 5.04. 高级缓存技术
(1) 缓存大小限制
在实际应用中，缓存可能会变得非常大，占用大量内存。为了防止这种情况，我们可以限制缓存的大小。当缓存达到最大容量时，可以使用 LRU（Least Recently Used）策略移除最近最少使用的项。
from collections import OrderedDict
class LRUCache:
def __init__(self, capacity):
self.cache = OrderedDict()
self.capacity = capacity
def get(self, key):
if key not in self.cache:
return -1
else:
self.cache.move_to_end(key) # 将访问的键移到末尾
return self.cache[key]
def put(self, key, value):
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) # 移除最早添加的项
# 测试 LRU 缓存
lru_cache = LRUCache(3)
lru_cache.put(1, 'one')
lru_cache.put(2, 'two')
lru_cache.put(3, 'three')
print(lru_cache.get(1)) # 输出: one
lru_cache.put(4, 'four') # 2 被移除
print(lru_cache.get(2)) # 输出: -1(2) 使用 functools.lru_cache
Python 的 functools 模块提供了一个 lru_cache 装饰器，可以轻松地为函数添加 LRU 缓存功能。
from functools import lru_cache
import math
@lru_cache(maxsize=32)
def compute(x):
result = math.sqrt(x)
print(f"Computed result for {x}")
return result
# 测试缓存
print(compute(16)) # 输出: Computed result for 16
# 4.0
print(compute(16)) # 输出: 4.0
print(compute(25)) # 输出: Computed result for 25
# 5.0
print(compute(25)) # 输出: 5.05. 实战案例：缓存 API 请求结果
假设我们有一个 API，每次请求都会返回一些数据。为了提高性能，我们可以使用字典缓存 API 的响应结果。
import requests
from functools import lru_cache
@lru_cache(maxsize=100)
def get_api_data(url):
response = requests.get(url)
if response.status_code == 200:
return response.json()
else:
return None
# 测试缓存
url = 'https://api.example.com/data'
data = get_api_data(url)
print(data)
# 再次请求相同的 URL，使用缓存
data = get_api_data(url)
print(data)总结
本文介绍了如何使用字典作为缓存机制，从基本的缓存示例到高级的 LRU 缓存技术，以及如何使用 functools.lru_cache 装饰器。通过实际的代码示例，我们展示了如何在 Python 中实现高效的缓存。
