实现最不经常使用算法（LFU）代码

LFU（Least Frequently Used）算法是一种缓存淘汰算法，它基于缓存中数据的使用频率来判断哪些数据应该被淘汰。下面是一个简单的 LFU 算法实现的 Python 代码：

from collections import defaultdict

class LFUCache:
    def __init__(self, capacity: int):
        self.capacity = capacity
        self.cache = {}
        self.freq = defaultdict(OrderedDict)
        self.min_freq = 0

    def get(self, key: int) -> int:
        if key not in self.cache:
            return -1
        value, freq = self.cache[key]
        self.freq[freq].pop(key)
        if not self.freq[freq]:
            del self.freq[freq]
            if freq == self.min_freq:
                self.min_freq += 1
        self.freq[freq+1][key] = value
        self.cache[key] = (value, freq+1)
        return value

    def put(self, key: int, value: int) -> None:
        if self.capacity == 0:
            return
        if key in self.cache:
            self.cache[key] = (value, self.cache[key][1]+1)
            self.get(key)
        else:
            if len(self.cache) == self.capacity:
                k, _ = self.freq[self.min_freq].popitem(last=False)
                del self.cache[k]
            self.cache[key] = (value, 1)
            self.freq[1][key] = value
            self.min_freq = 1

这个实现使用了一个字典来存储缓存中的数据，并使用一个有序字典来存储每个频率下的数据。其中，freq 字典的 key 是数据的使用频率，value 是一个有序字典，用来存储对应频率下的数据。当数据被访问时，它的频率会增加，它会从原来的频率对应的有序字典中删除，并加入到新的频率对应的有序字典中。同时，如果原来的频率对应的有序字典为空，并且它等于当前最小频率，那么最小频率就会增加。当插入新数据时，如果缓存已满，那么最小频率对应的有序字典中的最后一个数据会被淘汰。