设计LFU缓存结构

#coding:utf-8
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# lfu design
# @param operators int整型二维数组 ops
# @param k int整型 the k
# @return int整型一维数组
#
import heapq
class Solution:
    def LFU(self , operators , k ):
        # write code here
        self.dict = {}     # 存储key value
        self.capacity = k  # 容量
        self.cache = []   # 缓存key 操作的数量等数据
        self.counter = 0  # 全局 操作了第几次
        result = []
        for operator in operators:
            opt = operator[0]
            key = operator[1]
            if opt == 1:
                value = operator[2]
                self.set(key, value)
            else:
                result.append(self.get(key))
        return result

    def set(self, key, value):
        self.counter += 1  # 操作次数 + 1
        
        if key not in self.dict.keys():  # 不在列表中 直接插入
            if len(self.dict) >= self.capacity:  # 到达上限了 按逻辑删除一个
                del_node = heapq.heappop(self.cache)  # 最小堆弹出的是综合排序最小的
                self.dict.pop(del_node[2])

            node = [1, self.counter, key, value]  # [当前key操作次数 总体数据被操作次数 key value]
            self.dict[key] = node
            heapq.heappush(self.cache, node)
        else:
            node = self.dict[key]
            node[0] += 1  # key 的操作次数+1
            node[1] = self.counter
            node[3] = value
            # dict 和 cache是引用了相同的节点 修改会同步
            heapq.heapify(self.cache)  # 更新一次最小堆

    def get(self, key):
        self.counter += 1  # 操作次数 + 1
        if key in self.dict.keys():
            node = self.dict[key]
            node[0] += 1  # key 的操作次数+1
            node[1] = self.counter
            # dict 和 cache是引用了相同的节点 修改会同步
            heapq.heapify(self.cache)  # 更新一次最小堆
            return self.dict[key][3]
        else:
            return -1