Python应用利器之缓存机制的妙用详解

from functools import lru_cache

@lru_cache(maxsize=128)
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# 调用函数并观察缓存效果
print(fibonacci(20))  # 第一次调用，不命中缓存
print(fibonacci(20))  # 第二次调用，命中缓存

def custom_cache(func):
    cache = {}

    def wrapper(*args):
        if args in cache:
            return cache[args]
        result = func(*args)
        cache[args] = result
        return result

    return wrapper

@custom_cache
def custom_fibonacci(n):
    if n <= 1:
        return n
    return custom_fibonacci(n-1) + custom_fibonacci(n-2)

# 测试自定义缓存效果
print(custom_fibonacci(20))  # 第一次调用，不命中缓存
print(custom_fibonacci(20))  # 第二次调用，命中缓存

@lru_cache(maxsize=256)
def query_from_database(query):
    # 模拟数据库查询
    # ...
    return result

# 第一次数据库查询
result1 = query_from_database('SELECT * FROM table')

# 第二次相同查询，命中缓存
result2 = query_from_database('SELECT * FROM table')

from functools import lru_cache
import time

@lru_cache(maxsize=256)
def cached_function(arg):
    # 设置缓存有效时间为60秒
    cache_duration = 60

    # 缓存的时间戳
    if not hasattr(cached_function, "cache_timestamp"):
        cached_function.cache_timestamp = time.time()

    current_time = time.time()
    if current_time - cached_function.cache_timestamp > cache_duration:
        # 清理缓存并重新赋值时间戳
        cached_function.cache_clear()
        cached_function.cache_timestamp = current_time

    return arg  # 此处为缓存的数据，可替换为实际的计算结果

from threading import Timer

@lru_cache(maxsize=256)
def cached_function(arg):
    # ...（函数逻辑）

# 定时清理缓存，每60秒执行一次
def periodic_cache_cleanup():
    cached_function.cache_clear()
    Timer(60, periodic_cache_cleanup).start()

# 开启定时清理任务
Timer(60, periodic_cache_cleanup).start()

from functools import lru_cache
from collections import OrderedDict

# 自定义缓存
class CustomCache:
    def __init__(self, max_size):
        self.max_size = max_size
        self.cache = OrderedDict()

    def __call__(self, func):
        def wrapper(*args):
            if args in self.cache:
                self.cache.move_to_end(args)
                return self.cache[args]
            result = func(*args)
            if len(self.cache) >= self.max_size:
                self.cache.popitem(last=False)
            self.cache[args] = result
            return result
        return wrapper

# 使用自定义缓存并设置淘汰策略
@CustomCache(max_size=128)
def custom_function(arg):
    return arg * arg