如何限制字典的大小?

时间:2010-03-13 07:19:49

标签: python caching dictionary lru

我想在python中使用dict,但是将键/值对的数量限制为X.换句话说,如果dict当前存储X键/值对并执行插入,我会就像要删除的现有对之一一样。如果它是最近最少插入/访问密钥会很好,但这并不是完全必要的。

如果标准库中存在这种情况,请节省一些时间并指出它!

7 个答案:

答案 0 :(得分:40)

Python 2.7和3.1有OrderedDict,并且有早期Pythons的纯Python实现。

from collections import OrderedDict

class LimitedSizeDict(OrderedDict):
    def __init__(self, *args, **kwds):
        self.size_limit = kwds.pop("size_limit", None)
        OrderedDict.__init__(self, *args, **kwds)
        self._check_size_limit()

    def __setitem__(self, key, value):
        OrderedDict.__setitem__(self, key, value)
        self._check_size_limit()

    def _check_size_limit(self):
        if self.size_limit is not None:
            while len(self) > self.size_limit:
                self.popitem(last=False)

您还必须覆盖可插入项目的其他方法,例如updateOrderedDict的主要用途是,您可以轻松控制弹出的内容,否则正常的dict会起作用。

答案 1 :(得分:16)

cachetools将为您提供很好的Mapping Hashes实现(它可以在python 2和3上运行)。

文件摘录:

  

出于此模块的目的,缓存是固定的可变映射   最大尺寸。当缓存已满时,即通过添加另一个项目   缓存超过其最大大小,缓存必须选择哪个项目   基于合适的缓存算法进行丢弃。

答案 2 :(得分:9)

这是一个简单的,无LRU Python 2.6+解决方案(在较旧的Pythons中你可以用UserDict.DictMixin做类似的事情,但在2.6和更好的情况下不推荐使用,而collections的ABCs更可取无论如何...):

import collections

class MyDict(collections.MutableMapping):
    def __init__(self, maxlen, *a, **k):
        self.maxlen = maxlen
        self.d = dict(*a, **k)
        while len(self) > maxlen:
            self.popitem()
    def __iter__(self):
        return iter(self.d)
    def __len__(self):
        return len(self.d)
    def __getitem__(self, k):
        return self.d[k]
    def __delitem__(self, k):
        del self.d[k]
    def __setitem__(self, k, v):
        if k not in self and len(self) == self.maxlen:
            self.popitem()
        self.d[k] = v

d = MyDict(5)
for i in range(10):
    d[i] = i
    print(sorted(d))

正如其他提到的答案,您可能不希望继承dict - 显然委托给self.d很遗憾,但它确实保证所有其他方法都是由collections.MutableMapping

答案 3 :(得分:8)

这是一个简单而有效的LRU缓存,使用简单的Python代码编写,可在任何python 1.5.2或更高版本上运行:

class LRU_Cache:

    def __init__(self, original_function, maxsize=1000):
        self.original_function = original_function
        self.maxsize = maxsize
        self.mapping = {}

        PREV, NEXT, KEY, VALUE = 0, 1, 2, 3         # link fields
        self.head = [None, None, None, None]        # oldest
        self.tail = [self.head, None, None, None]   # newest
        self.head[NEXT] = self.tail

    def __call__(self, *key):
        PREV, NEXT = 0, 1
        mapping, head, tail = self.mapping, self.head, self.tail

        link = mapping.get(key, head)
        if link is head:
            value = self.original_function(*key)
            if len(mapping) >= self.maxsize:
                old_prev, old_next, old_key, old_value = head[NEXT]
                head[NEXT] = old_next
                old_next[PREV] = head
                del mapping[old_key]
            last = tail[PREV]
            link = [last, tail, key, value]
            mapping[key] = last[NEXT] = tail[PREV] = link
        else:
            link_prev, link_next, key, value = link
            link_prev[NEXT] = link_next
            link_next[PREV] = link_prev
            last = tail[PREV]
            last[NEXT] = tail[PREV] = link
            link[PREV] = last
            link[NEXT] = tail
        return value

if __name__ == '__main__':
    p = LRU_Cache(pow, maxsize=3)
    for i in [1,2,3,4,5,3,1,5,1,1]:
        print(i, p(i, 2))

答案 4 :(得分:2)

dict没有这种行为。您可以创建自己的类,例如

class MaxSizeDict(object):
    def __init__(self, max_size):
        self.max_size = max_size
        self.dict = {}
    def __setitem__(self, key, value):
        if key in self.dict:
            self.dict[key] = value    
            return

        if len(self.dict) >= self.max_size:
      ...

关于这个的一些注释

  • 一些人在这里继承dict很诱人。从技术上讲,您可以这样做,但它很容易出错,因为这些方法并不相互依赖。您可以使用UserDict.DictMixin来保存必须定义所有方法。如果您继承dict
  • ,则可以重复使用的方法很少
  • dict不知道最近添加的密钥是什么,因为dicts是无序的。
    • 2.7将引入collections.OrderedDict,但是现在单独按顺序保存密钥应该可以正常工作(使用collections.deque作为队列)。
    • 如果获得最旧的并不是那么重要,您只需使用popitem方法删除一个任意项目。
  • 我将最老的解释为大约第一次插入。你必须做一些不同的事情来消除LRU项目。最明显的有效策略将涉及保持一个双向链接的键列表,其中引用节点本身存储为dict值(以及实际值)。这变得更加复杂,在纯Python中实现它会带来很多开销。

答案 5 :(得分:1)

您可以通过继承dict来创建自定义词典类。在您的情况下,您必须覆盖__setitem__以检查自己的长度,并在重新调整限制时删除某些内容。以下示例将在每次插入后打印当前长度:

class mydict(dict):
    def __setitem__(self, k, v):
        dict.__setitem__(self, k, v)
        print len(self)

d = mydict()
d['foo'] = 'bar'
d['bar'] = 'baz'

答案 6 :(得分:1)

有很多很好的答案,但我想指出一个简单的pythonic实现LRU缓存。这与Alex Martelli的回答类似。

from collections import OrderedDict, MutableMapping

class Cache(MutableMapping):
    def __init__(self, maxlen, items=None):
        self._maxlen = maxlen
        self.d = OrderedDict()
        if items:
            for k, v in items:
                self[k] = v

    @property
    def maxlen(self):
        return self._maxlen

    def __getitem__(self, key):
        self.d.move_to_end(key)
        return self.d[key]

    def __setitem__(self, key, value):
        if key in self.d:
            self.d.move_to_end(key)
        elif len(self.d) == self.maxlen:
            self.d.popitem(last=False)
        self.d[key] = value

    def __delitem__(self, key):
        del self.d[key]

    def __iter__(self):
        return self.d.__iter__()

    def __len__(self):
        return len(self.d)