编写一段python代码实现这个功能：一个缓存结构需要实现如下功能。 set(key, value)：将记录(key, value)插入该结构 get(key)：返回key对应的value值 但是缓存结构中最多放K条记录，如果新的第K+1条记录要加入，就需要根据策略删掉一条记录，然后才能把新记录加入。这个策略为：在缓存结构的K条记录中，哪一个key从进入缓存结构的时刻开始，被调用set或者get的次数最少，就删掉这个key的记录； 如果调用次数最少的key有多个，上次调用发生最早的key被删除 这就是LFU缓存替换算法。实现这个结构，K作为参数给出 数据范围：0 <k≤10^5，val≤2×10^9 要求：get和set的时间复杂度都是 O(logn)，空间复杂度是 O(n) 若opt=1，接下来两个整数x, y，表示set(x, y) 若opt=2，接下来一个整数x，表示get(x)，若x未出现过或已被移除，则返回-1 对于每个操作2，返回一个答案

以下是一个实现 LFU 缓存替换算法的 Python 代码：

from collections import OrderedDict

class LFU:
    def __init__(self, capacity: int):
        self.capacity = capacity
        self.time = 0
        self.cache = OrderedDict()
        self.freq = {}
        self.min_freq = None

    def set(self, key: int, value: int):
        # 如果 key 已经存在，则更新它的值
        if key in self.cache:
            self.cache[key] = (value, self.freq[key])
            return
        
        # 如果缓存满了，则删除调用次数最少的 key
        if len(self.cache) == self.capacity:
            self._evict()
        
        # 将新的 key-value 对插入缓存
        self.cache[key] = (value, self.time)
        self.freq[key] = self.time
        self.min_freq = self.time
        self.time += 1
    
    def get(self, key: int) -> int:
        # 如果 key 不存在或已被移除，则返回 -1
        if key not in self.cache:
            return -1
        
        # 更新 key 的调用次数
        value, freq = self.cache[key]
        self.freq[key] = self.time
        self.time += 1
        self.cache.move_to_end(key)
        
        # 更新最小调用次数
        if freq == self.min_freq:
            self.min_freq += 1
        
        return value
    
    def _evict(self):
        # 找到调用次数最少的 key
        for key, (value, freq) in self.cache.items():
            if freq == self.min_freq:
                del self.cache[key]
                del self.freq[key]
                break

这段代码使用了 Python 的 OrderedDict 来实现双向链表，从而使得 set 和 get 操作的时间复杂度都是 O(logn)。

要在程序中使用这个 LFU 缓存，可以这样做：

cache = LFU(k)

while True: