cache

1记忆
2钱包-储物柜(容量)
3代码模块
Core是最小算数逻辑单元ALU

其中D-cache最快但最小，其次是I-Cache慢一点但是大一点。L2就更大了，L3最大。在这里插入图片描述
有系统描述目前cpu的架构

LRU Cache缓存替换算法

在这里插入图片描述
查中间就不是o（1）了，但是cache是查中间的。

数存在双向链表，当A进，发现A不在cache则加进去，在头位置说明最近刚好使用，B也如此。当F进来，放不下了，则末尾A去掉，当c进来，发现有，则不用删元素，则只要调换位置到头位置。
在这里插入图片描述

LFU Cache

在这里插入图片描述

leetcode146 LRU Cache

pyhton中OrderedDICT的用法

很多人认为python中的字典是无序的，因为它是按照hash来存储的，但是python中有个模块collections(英文，收集、集合)，里面自带了一个子类OrderedDict，实现了对字典对象中元素的排序。请看下面的实例：
下图常规字典

print("Regular dictionary")
d={}
d['a']='A'
d['b']='B'
d['c']='C'
for k,v in d.items():
    print (k,v)

在这里插入图片描述
下图ordereddict的字典，可以看出按顺序排列

print ("Order dictionary")
d1 = collections.OrderedDict()
d1['c'] = 'C'
d1['a'] = 'A'
d1['b'] = 'B'
d1['1'] = '1'
d1['c'] = 'C'
d1['2'] = '2'
for k,v in d1.items():
  print(k,v)

在这里插入图片描述
可以看出按顺序排列，同样是保存了ABC等几个元素，但是使用OrderedDict会根据放入元素的先后顺序进行排序。所以输出的值是排好序的。

print (Regular dictionary:)
d2={}
d2['a']='A'
d2['b']='B'
d2['c']='C'

d3={}
d3['c']='C'
d3['a']='A'
d3['b']='B' 

print 'OrderedDict:'
d4=collections.OrderedDict()
d4['a']='A'
d4['b']='B'
d4['c']='C'
 
d5=collections.OrderedDict()
d5['c']='C'
d5['a']='A'
d5['b']='B'

print  d1==d2

输出：
Regular dictionary:
True
 
OrderedDict:
False

dd = {'banana': 3, 'apple':4, 'pear': 1, 'orange': 2}
#按key排序
kd = collections.OrderedDict(sorted(dd.items(), key=lambda t: t[0]))
print kd
#按照value排序
vd = collections.OrderedDict(sorted(dd.items(),key=lambda t:t[1]))
print vd

#输出
OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])
OrderedDict([('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)])

题目描述

运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作：获取数据 get 和写入数据 put 。

获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。
写入数据 put(key, value) - 如果密钥不存在，则写入其数据值。当缓存容量达到上限时，它应该在写入新数据之前删除最近最少使用的数据值，从而为新的数据值留出空间。

进阶:

你是否可以在 O(1) 时间复杂度内完成这两种操作？

LRUCache cache = new LRUCache( 2 /* 缓存容量 */ );

cache.put(1, 1);
cache.put(2, 2);
cache.get(1);       // 返回  1
cache.put(3, 3);    // 该操作会使得密钥 2 作废
cache.get(2);       // 返回 -1 (未找到)
cache.put(4, 4);    // 该操作会使得密钥 1 作废
cache.get(1);       // 返回 -1 (未找到)
cache.get(3);       // 返回  3
cache.get(4);       // 返回  4

pop 和popitem用法
popitem是随机删除，但是是因为字典是随机的，它基本上都删除最后第一项，第一个里面有些错误。第二个超链接正确
popitem（last=false）用法
在ordereddict中没有last=false删最后一项，有的话删第一项

class LRUCache:

    def __init__(self, capacity: int):
        self.dict=collections.OrderedDict()
        self.remain=capacity
    def get(self, key: int) -> int:
        if key not in self.dict:
            return -1
        else:
            v=self.dict.pop(key)
            self.dict[key]=v
            return v
        

    def put(self, key: int, value: int) -> None:
        if key in self.dict:
            self.dict.pop(key)
        else:
            if self.remain>0:
                self.remain-=1
            else:# 这个若是满了，字典第一项是最后加进去的
                self.dict.popitem(last=False)
        self.dict[key]=value


# Your LRUCache object will be instantiated and called as such:
# obj = LRUCache(capacity)
# param_1 = obj.get(key)
# obj.put(key,value)

LRU Cache（pyhton中OrderedDICT的用法）

文章目录