from functools import lru_cache

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

# 調(diào)用函數(shù)并觀察緩存效果
print(fibonacci(20))  # 第一次調(diào)用，不命中緩存
print(fibonacci(20))  # 第二次調(diào)用，命中緩存

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))  # 第一次調(diào)用，不命中緩存
print(custom_fibonacci(20))  # 第二次調(diào)用，命中緩存

@lru_cache(maxsize=256)
def query_from_database(query):
    # 模擬數(shù)據(jù)庫查詢
    # ...
    return result

# 第一次數(shù)據(jù)庫查詢
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):
    # 設(shè)置緩存有效時(shí)間為60秒
    cache_duration = 60

    # 緩存的時(shí)間戳
    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:
        # 清理緩存并重新賦值時(shí)間戳
        cached_function.cache_clear()
        cached_function.cache_timestamp = current_time

    return arg  # 此處為緩存的數(shù)據(jù)，可替換為實(shí)際的計(jì)算結(jié)果

from threading import Timer

@lru_cache(maxsize=256)
def cached_function(arg):
    # ...（函數(shù)邏輯）

# 定時(shí)清理緩存，每60秒執(zhí)行一次
def periodic_cache_cleanup():
    cached_function.cache_clear()
    Timer(60, periodic_cache_cleanup).start()

# 開啟定時(shí)清理任務(wù)
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

# 使用自定義緩存并設(shè)置淘汰策略
@CustomCache(max_size=128)
def custom_function(arg):
    return arg * arg