ChainMap

可以将多个字典快速的连接起来，class collections.ChainMap(*maps)中，如果maps没有被指定，则默认创建一个空字典
new_child() ：创建新的chainmap类，后面跟随当前实例的全部映射（map）；

  1. dd = collections.ChainMap({'a': 1})
  2. ddd = dd.new_child(a)
  3. dddd = ddd.new_child()
  4. print(dddd)        #ChainMap({}, {'a': 1, 'b': 2}, {'a': 1})

parents：返回一个新的ChainMap包含当前所以实例映射，除去第一个。

  1. dd = collections.ChainMap({'a': 1})
  2. ddd = dd.new_child(a)
  3. dddd = ddd.new_child()
  4. print(dddd)        #ChainMap({}, {'a': 1, 'b': 2}, {'a': 1})
  5. print(dddd.parents)        #ChainMap({'a': 1, 'b': 2}, {'a': 1})

maps：根据索引返回对应chainmap实例

  1. dd = collections.ChainMap({'a': 1})
  2. ddd = dd.new_child(a)
  3. dddd = ddd.new_child()
  4. print(dddd)
  5. print(dddd.parents)         #ChainMap({'a': 1, 'b': 2}, {'a': 1})
  6. print(dddd.maps[0])            #{'a': 1}

Counter

用于计数可哈希对象，想字典键一样存储。

  1. gg = {'e': 5, 'f': 6}
  2. g = Counter(gg.keys())
  3. ggg = Counter(cats=4, dogs=5)
  4. print(g)        #Counter({'e': 1, 'f': 1})
  5. print(ggg)        #Counter({'dogs': 5, 'cats': 4})

elements()：返回一个迭代器，每个元素重复出现的个数

  1. ggg = Counter(cats=1, dogs=5)
  2. gggg = sorted(ggg.elements())
  3. print(gggg)        #['cats', 'dogs', 'dogs', 'dogs', 'dogs', 'dogs']

most_common([n])：返回n个频率最高的元素和计数

  1. ggg = Counter(cats=1, dogs=5)
  2. print(Counter(ggg).most_common(1))        #[('dogs', 5)]

defaultdict

是内置dict类的子类 class collections.defaultdict([default_factory])中，default_factory默认为None，
default_factory可以有很多类型，list、set、str、int等等
1.将list作为default_factory，可将键-值对组成的序列变成键-列表组成的字典。

  1. s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4)]
  2. d = collections.defaultdict(list)
  3. print(d)
  4. for k, v in s:
  5.     d[k].append(v)
  6. print(sorted(d.items()))        #[('blue', [2, 4]), ('yellow', [1, 3])]

2.lambda函数可灵活的指定任意默认值

  1. strings = 'chinese'
  3. counts = collections.defaultdict(lambda: 1)
  4. for i in strings:
  5.     counts[i] += 1
  6. print(counts)    #defaultdict(<function <lambda> at 0x0000023CC9149F78>, {'c': 2, 'h': 2, 'i': 2, 'n': 2, 'e': 3, 's': 2})

OrderedDict

处理字典的重新排序
popitem(last=True)：移除并返回一个键值对，last = True，则后进先出返回键值对，last = False，则先进先出返回键值对。

  1. from collections import OrderedDict
  3. d = OrderedDict.fromkeys('abcde')
  4. print(dict(d))        #{'a': None, 'b': None, 'c': None, 'd': None, 'e': None}
  5. d.popitem(last=False)
  6. print(dict(d))        #{'b': None, 'c': None, 'd': None, 'e': None}

move_to_end(key, last=True)：将现有key移动到有序字典的任一端，last = True，则移动到末尾，last = False，则移动到开头。

  1. from collections import OrderedDict
  3. d = OrderedDict.fromkeys('abcde')
  4. d.move_to_end('b', last=False)
  5. print(dict(d))        #{'b': None, 'a': None, 'c': None, 'd': None, 'e': None}

deque

返回一个新的双向队列对象
常用方法：

  1. append(x)：添加x到右端
  2. appendleft(x)：添加x到左端
  3. clear()：移除所有元素，使其长度为0
  4. copy()：浅复制
  5. count(x)：计算队列中x的个数
  6. extend(iterable)：扩展队列的右侧
  7. extendleft(iterable)：扩展队列的左侧
  8. index(x)：返回x在队列中的位置
  9. insert(i, x)：在位置i插入x
  10. pop()：移除右侧一个元素并返回
  11. popleft()：移除左侧一个元素并返回
  12. remove(value)：移除指定value
  13. reverse()：将队列逆序排序