Using Python Dictionaries as a Cache Mechanism

In Python, dictionaries are flexible and efficient data structures that store key‑value pairs, and they can also be used as a simple caching mechanism to improve program performance.

1. Basic Concept of Dictionaries

Dictionaries are built‑in types where each key is unique and values can be accessed quickly. Creating a dictionary is straightforward:

<code># 创建一个字典
my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}
print(my_dict)  # 输出: {'apple': 1, 'banana': 2, 'cherry': 3}</code>

2. Basic Operations

Dictionaries support adding, deleting, modifying, and querying entries. Common operations include:

<code># 添加键值对
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 Found</code>

3. Dictionary as a Cache Mechanism

Caching stores computed results or frequently accessed data to return them quickly; dictionary look‑ups run in O(1) time, making them ideal for simple caches.

3.1 Basic Cache Example

Suppose we have a function compute that calculates the square root of a number. We can cache results in a dictionary to avoid recomputation:

<code>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.0</code>

4. Advanced Caching Techniques

4.1 Cache Size Limitation with LRU

In real applications, caches can grow large; limiting size and evicting the least‑recently‑used items prevents memory bloat. The following LRUCache class demonstrates this strategy:

<code>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
        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</code>

4.2 Using functools.lru_cache

The standard library functools provides an lru_cache decorator for effortless LRU caching:

<code>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 (cached)
print(compute(25))  # Computed result for 25 -> 5.0
print(compute(25))  # 5.0 (cached)</code>

5. Practical Example: Caching API Request Results

When an API call returns data, caching the response can greatly improve performance. The example below caches API responses using functools.lru_cache :

<code>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)</code>

In summary, the article demonstrates how to use Python dictionaries as a cache, from simple examples to advanced LRU strategies and the built‑in functools.lru_cache decorator, providing practical code snippets for efficient caching.