【Python练习cookbook】实用模块：collections.Counter、collections.ChainMap

官方文档入口（英文）：collections --- 容器数据类型 — Python 3.10.0 文档

Counter([iterable-or-mapping])

Counter 是 dict 的子类，具有dict几乎所有属性，用于可哈希对象的计数。

创建：可从iterable 或 其他 mapping (或counter) 创建

from collections import Counter
c = Counter()                           # 空Counter
c = Counter('gallahad')                 # 从iterable创建，还可以是list,set等
c = Counter({'red': 4, 'blue': 2})      # 从mapping创建
c = Counter(cats=4, dogs=8)             # 用键值对创建

 引用不存在的元素返回0，不报错。

支持dict几乎所有属性（除了fromkeys(iterable)、update([iterable-or-mapping])），以及以下三个个方法：

1.elements()

返回所有包含元素的迭代器，无序。

c = Counter(a=4, b=2, c=0, d=-2)
sorted(c.elements())
#['a', 'a', 'a', 'a', 'b', 'b']

2.most_common([n])

返回出现频率最高的n个元素，n为空或者None时，返回所有元素。3.6以前个数相等的key，顺序随机。3.6以后，因为字典有序了，所以个数相等的key，按出现顺序排序。

Counter('abracadabra').most_common(3)  
[('a', 5), ('r', 2), ('b', 2)]

3.subtract([iterable-or-mapping]) 

从counter中减去元素：

c = Counter(a=4, b=2, c=0, d=-2)
d = Counter(a=1, b=2, c=3, d=4, e=5)
c.subtract(d)
c
Counter({'a': 3, 'b': 0, 'c': -3, 'd': -6, 'e':-5})

常用操作： 

sum(c.values())                 # total of all counts
c.clear()                       # reset all counts
list(c)                         # list unique elements
set(c)                          # convert to a set
dict(c)                         # convert to a regular dictionary
c.items()                       # convert to a list of (elem, cnt) pairs
Counter(dict(list_of_pairs))    # convert from a list of (elem, cnt) pairs
c.most_common()[:-n-1:-1]       # n least common elements
+c                              # remove zero and negative counts

c = Counter(a=3, b=1)
d = Counter(a=1, b=2)
c + d                       # add two counters together:  c[x] + d[x]
#Counter({'a': 4, 'b': 3})
c - d                       # subtract (keeping only positive counts)
#Counter({'a': 2})
c & d                       # intersection:  min(c[x], d[x]) 
#Counter({'a': 1, 'b': 1})
c | d                       # union:  max(c[x], d[x])
#Counter({'a': 3, 'b': 2})

c = Counter(a=2, b=-4)
+c
#Counter({'a': 2})
-c
#Counter({'b': 4})

 ChainMap(*maps)

一个 ChainMap 类是为了将多个映射快速的链接到一起，这样它们就可以作为一个单元处理。它通常比创建一个新字典和多次调用 update() 要快很多。同时，原map若有变动，可反映出来，而update不能

这个类可以用于模拟嵌套作用域，并且在模版化的时候比较有用。

一个 ChainMap 将多个字典或者其他映射组合在一起，创建一个单独的可更新的视图。 如果没有 maps 被指定，就提供一个默认的空字典，这样一个新链至少有一个映射。

底层映射被存储在一个列表中。这个列表是公开的，可以通过 maps 属性存取和更新。没有其他的状态。

搜索查询底层映射，直到一个键被找到。不同的是，写，更新和删除只操作第一个映射。

一个 ChainMap 通过引用合并底层映射。 所以，如果一个底层映射更新了，这些更改会反映到 ChainMap 。

支持所有常用字典方法。另外还有一个 maps 属性(attribute)，一个创建子上下文的方法(method)， 一个存取它们首个映射的属性(property):

maps

一个可以更新的映射列表。这个列表是按照第一次搜索到最后一次搜索的顺序组织的。它是仅有的存储状态，可以被修改。列表最少包含一个映射。

new_child(m=None)

返回一个新的 ChainMap 类，包含了一个新映射(map)，后面跟随当前实例的全部映射(map)。如果 m 被指定，它就成为不同新的实例，就是在所有映射前加上 m，即ChainMap(m, *d.maps)，如果没有指定，就加上一个空字典，这样的话一个 d.new_child() 调用等价于 ChainMap({}, *d.maps) 。这个方法用于创建子上下文，不改变任何父映射的值。

parents

属性返回一个新的 ChainMap 包含所有的当前实例的映射，除了第一个。这样可以在搜索的时候跳过第一个映射。 使用的场景类似在 nested scopes 嵌套作用域中使用 nonlocal 关键词。用例也可以类比内建函数 super() 。一个 d.parents 的引用等价于 ChainMap(*d.maps[1:]) 。

>>> values = ChainMap()
>>> values['x'] = 1
>>> # Add a new mapping
>>> values = values.new_child()
>>> values['x'] = 2
>>> # Add a new mapping
>>> values = values.new_child()
>>> values['x'] = 3
>>> values
ChainMap({'x': 3}, {'x': 2}, {'x': 1})
>>> values['x']
3
>>> # Discard last mapping
>>> values = values.parents
>>> values['x']
2
>>> # Discard last mapping
>>> values = values.parents
>>> values['x']
1
>>> values
ChainMap({'x': 1})