Python中的高性能容器--collections

集合模块

　　相对于 Python 中内置的称为链表、集合、字典和元组的默认容器类型来说，集合模块（ collection module ）提供了高性能的备选方案（ alternative ）。

　　简单地看看集合模块中如下的容器类型：

　　　　1 ) deque ：一个链表容器的备选方案，支持在队列两端快速插入和弹出（ pop ）。

　　　　2 ) defaultdict : dict 的子类，它为类型提供了工厂函数，用于提供缺省值。

　　　　3 ) orderedDict : dict 的子类，它记录了关键字插入的顺序。

　　　　4 ) Counter : dict 子类，用于保存可哈希类型的计数和统计信息。

　　　　5 ) ChainMap ：带有一个类似字典接口的类，用于持续跟踪多重映射。

　　　　6 ) namedtuple ：用于创建类似元组的类的类型，带有命名字段。

　　1 . deque

　　一个双端队列（ double ended queue ）像一个链表，但和链表不同，它支持近乎常量时间（ O ( 1) ）的从队列两端进行的增加和弹出操作，而链表对于在左端进行的弹出和插入操作，有一个 0 ( n ）数量级的时间成本。

　　双端队列也支持一些操作，比如旋动（ rotation ) ，用于将列表中 k 个元素从表尾移动到表头，或者反过来，它们的平均性能为 O ( k ）。这通常比链表中类似的操作稍微快一点，链表涉及切割（ slicing ）和追加（ appending ）操作：

　　

# 定义一个双端队列
import collections

dq = collections.deque()

# append往右边添加一个元素
dq.append(1)
dq.append(2)
print(dq)  # deque([1, 2])

# appendleft往左边添加一个元素
dq.appendleft(3)
dq.appendleft(4)
print(dq)  # deque([4, 3, 1, 2])

# clear 清空队列
dq.clear()
print(dq)  # deque([])

# copy浅拷贝
dq.append(1)
dq2 = dq.copy()
print(id(dq))  #
print(id(dq2))  #

# count 返回指定元素的出现次数
dq3 = collections.deque()
dq3.append(1)
dq3.append(1)
print(dq3.count(1))  #

# extend 从队列右端添加多个元素
dq4 = collections.deque()
dq4.append(1)
dq4.extend([2, 3, 4])
print(dq4)  # deque([1, 2, 3, 4])

# extendleft 从队列左端添加多个元素  注意添加顺序
dq4.extendleft([5, 6, 7, 8])
print(dq4)  # deque([8, 7, 6, 5, 1, 2, 3, 4])

# index 查找某个元素的索引位置，如果查无结果  会报异常 ValueError: xxx is not in deque
print(dq4.index(5))  #
print(dq4.index(2, 3, 7))  # 后面的两个参数可用于指定查找区间

# insert 在队列指定位置插入元素
dq4.insert(2, "c")
print(dq4)  # deque([8, 7, 'c', 6, 5, 1, 2, 3, 4])

# pop 返回队列最右边的元素，并将其在队列中删除
print(dq4)  # deque([8, 7, 'c', 6, 5, 1, 2, 3, 4])
x = dq4.pop()
print(x)  #
print(dq4)  # deque([8, 7, 'c', 6, 5, 1, 2, 3])

# popleft 返回最左边的元素，并将其在队列中删除
print(dq4)  # deque([8, 7, 'c', 6, 5, 1, 2, 3])
y = dq4.popleft()
print(y)  #
print(dq4)  # deque([7, 'c', 6, 5, 1, 2, 3])

# remove 删除指定元素, 只删除一个值，从左向右查找
dq5 = collections.deque([1, 2, 3, 4, 5, 2])
print(dq5)  # deque([1, 2, 3, 4, 5, 2])
dq5.remove(2)
print(dq5)  # deque([1, 3, 4, 5, 2])
dq5.remove(2)
print(dq5)  # deque([1, 3, 4, 5])

# reverse 反转队列
print(dq5)  # deque([1, 3, 4, 5])
dq5.reverse()
print(dq5)  # deque([5, 4, 3, 1])

# rotate 将右边元素放置到队列左边
dq5.rotate(2)  # 可指定次数
print(dq5)  # deque([3, 1, 5, 4])

　　2 . defaultdict

　　默认dict是dict子类， 它使用类型工厂提供对于字典关键字的默认值。

　　在Python中，当在一个列表数据项上循环，并试着增加一个字典计数值的时候，我们会遇到一个常见问题，即有可能没有对应数据项的任何已存在的条目

　　比如，对一个单词在一段文本中的出现次数进行计数：

counts = {}

for word in text.split():
    word = word.lower().strip()
    try:
        counts[word] += 1
    except KeyError:
        counts[word] = 1

　　再比如，试着对所有的字符串分组，相同长度的字符串放到一个字典中：

cities = ['Jakarta', 'Delhi', 'Newyork', 'Bonn', 'Kolkata', 'Bangalore', 'Seoul']

cities_len = {}
for city in cities:
    clen = len(city)
    # First create entry
    if clen not in cities_len:
        cities_len[clen] = []
    cities_len[clen].append(city)

　　一个defaultdict容器优雅地解决了这个问题，它通过定义一个类型工厂为任务没在字典中出现的关键字提供默认参数值。 默认工厂类型支持任意的默认类型， 而且默认值设为None。

　　对于每种类型，它的空值是默认值，即：

　　int -> 0

　　[] -> list

　　'' ->strings

　　{} ->dict

　　单词计数代码可以按照如下方式重写：

counts = collections.defaultdict(int)

for word in text.split():
    word = word.split()
    # Value is set to 0 and incremented by 1 in one go
    counts[word] += 1

　　类似地，根据字符串长度分组它们的代码如下：　　

cities = ['Jakarta', 'Delhi', 'Newyork', 'Bonn', 'Kolkata', 'Bangalore', 'Seoul']

cities_len = collections.defaultdict(list)

for city in cities:
    # Empty list is created as value and appended to in one go
    cities_len[len(city)].append(city)

　　3 . OrderedDict

　　OrderedDict 是一个dict子类， 它记录了条目插入的顺序，它有点像一个字典和链表的结合体，它表现得像一个映射类型，但是在记录插入顺序，甚至支持诸如用于删除头尾条目的popitem方法上，也有类似链表的行为

cities = ['Jakarta', 'Delhi', 'Newyork', 'Bonn', 'Kolkata', 'Bangalore', 'Seoul']
cities_dict= collections.OrderedDict.fromkeys(cities)
print(cities_dict)  # OrderedDict([('Jakarta', None), ('Delhi', None), ('Newyork', None), ('Bonn', None), ('Kolkata', None), ('Bangalore', None), ('Seoul', None)])
print(cities_dict.popitem())  # ('Seoul', None)
print(cities_dict.popitem(last=False))  #('Jakarta', None)

　　比较和对照字典是如何改变顺序的，而OrderedDict容器是如何保持原有顺序的。

　　这里给出了一些使用OrderedDict容器的做法。

　　1）不丢失顺序地从一个容器中删除重复元素。

cities = ['Jakarta', 'Delhi', 'Newyork', 'Bonn', 'Kolkata', 'Bangalore', 'Bonn', 'Seoul', 'Delhi', 'Jakarta', 'Mumbai']

cities_odict = collections.OrderedDict.fromkeys(cities)
print(cities_odict.keys())

　　2) 实现一个最近最少使用（LRU）的缓存字典。

　　一个LRU缓存优先考虑最近被使用（或被访问）的条目，删除那些最少被使用的条目。这是一个常见的缓存算法，用在诸如Squid的HTTP缓存服务器中，也用在其他一些情况中，即需要维护一个被限制了大小的容器，这个容器优先保存最近被访问的条目。

　　这里使用了OrderedDict的操作，即当删除了一个存在的关键字，然后再重新添加时，它被添加到了末尾（右端）：

　　

class LRU(collections.OrderedDict):
    """ Least recently used cache dictionary"""

    def __init__(self, size=10):
        self.size = size

    def set(self, key):
        # if key is there delete and reinsert so
        # it moves to end
        if key in self:
            del self[key]

        self[key] = 1
        if len(self) > self.size:
            # pop from left
            self.popitem(lastp=False)

lru = LRU(5)
lru.set("bangalore")
lru.set("chennai")
lru.set("mumbai")
lru.set("bangalore")
lru.set("kolkata")
lru.set("delhi")
lru.set("chennai")
lru.set("kochi")

print(lru) # LRU([('bangalore', 1), ('kolkata', 1), ('delhi', 1), ('chennai', 1), ('kochi', 1)])

　　因为关键字mumbai第一个被设置，之后没有再被设置过，所以它变成了最左边的一个，然后被删除了。

　　注意：要删除的下一个关键字是 bangalore， 接着是 chennai，这是因为chennai在bangalore设置之后被多设置了一次

　　4. Counter

　　5. ChainMap

　　6. Namedtuple