Python如何实现一个简单缓存

Python实现简单缓存的方法有：使用字典、装饰器、functools.lru_cache、第三方库（如cachetools）。 其中，使用字典实现缓存最为基础，装饰器实现缓存较为优雅，functools.lru_cache提供了现成的缓存机制，而第三方库cachetools则提供了更多高级功能。下面将重点介绍如何使用字典实现缓存。

一、使用字典实现缓存

使用字典实现缓存是最基础的方法。字典的键可以是需要缓存的函数的输入参数，而值则是函数的返回结果。当函数被调用时，首先检查字典中是否已经缓存了结果，如果有则直接返回缓存的结果，否则计算结果并存入字典。

class SimpleCache:
    def __init__(self):
        self.cache = {}
    def get(self, key):
        return self.cache.get(key)
    def set(self, key, value):
        self.cache[key] = value
    def clear(self):
        self.cache.clear()

示例：缓存函数结果

def cached_function(cache, func):
    def wrapper(*args):
        if args in cache.cache:
            return cache.get(args)
        result = func(*args)
        cache.set(args, result)
        return result
    return wrapper
cache = SimpleCache()
@cached_function(cache)
def expensive_function(x):
    # 假设这是一个计算量很大的函数
    return x * x
print(expensive_function(4))  # 计算并缓存结果
print(expensive_function(4))  # 直接返回缓存结果

二、使用装饰器实现缓存

装饰器是一种优雅的方式来实现函数缓存，能够将缓存逻辑与业务逻辑分离，代码更为简洁。

def cache_decorator(func):
    cache = {}
    def wrapper(*args):
        if args in cache:
            return cache[args]
        result = func(*args)
        cache[args] = result
        return result
    return wrapper
@cache_decorator
def expensive_function(x):
    # 假设这是一个计算量很大的函数
    return x * x
print(expensive_function(4))  # 计算并缓存结果
print(expensive_function(4))  # 直接返回缓存结果

三、使用functools.lru_cache

Python的标准库functools提供了一个现成的LRU（最近最少使用）缓存装饰器，可以直接使用来缓存函数的结果。

from functools import lru_cache
@lru_cache(maxsize=128)
def expensive_function(x):
    # 假设这是一个计算量很大的函数
    return x * x
print(expensive_function(4))  # 计算并缓存结果
print(expensive_function(4))  # 直接返回缓存结果

四、使用第三方库cachetools

cachetools是一个功能强大的缓存库，提供了多种缓存策略（如LRU、LFU等）。

from cachetools import cached, LRUCache
cache = LRUCache(maxsize=128)
@cached(cache)
def expensive_function(x):
    # 假设这是一个计算量很大的函数
    return x * x
print(expensive_function(4))  # 计算并缓存结果
print(expensive_function(4))  # 直接返回缓存结果

五、缓存失效与过期策略

在实际应用中，缓存并不是永久有效的，需要考虑缓存的失效与过期策略。例如，可以在字典实现的基础上，增加缓存时间戳，并在每次获取缓存时检查是否过期。

import time
class TimedCache:
    def __init__(self, ttl):
        self.cache = {}
        self.ttl = ttl
    def get(self, key):
        if key in self.cache:
            result, timestamp = self.cache[key]
            if time.time() - timestamp < self.ttl:
                return result
        return None
    def set(self, key, value):
        self.cache[key] = (value, time.time())
    def clear(self):
        self.cache.clear()

示例：缓存函数结果并设置过期时间

def cached_function(cache, func):
    def wrapper(*args):
        result = cache.get(args)
        if result is not None:
            return result
        result = func(*args)
        cache.set(args, result)
        return result
    return wrapper
cache = TimedCache(ttl=60)  # 设置缓存过期时间为60秒
@cached_function(cache)
def expensive_function(x):
    # 假设这是一个计算量很大的函数
    return x * x
print(expensive_function(4))  # 计算并缓存结果
time.sleep(30)
print(expensive_function(4))  # 直接返回缓存结果
time.sleep(40)
print(expensive_function(4))  # 缓存过期，重新计算并缓存结果