描述项目描述
python 解释器 3.10.6
counter 模块在 python 的 collections 模块中，有一个很常用的模块就是 counter。counter 是一个简单的计数器，用于统计某些可哈希对象的数量。它以字典的形式存储元素和它们的计数。
counter() 类类 counter() 能够对传入给该类的参数按照一定规则进行计数，并将计数对象与计数结果作为键值对以字典的形式进行结果的返回。
counter(iterable=none, /, **kwds)
举个栗子
from collections import counter# 返回一个空的 counter 对象cnt = counter()print(cnt)# 将可迭代对象（字符串）作为参数cnt = counter('hello world')print(cnt)# 将可迭代对象（列表）作为参数cnt = counter(['a', 'a', 'b', 'd', 'c', 'd'])print(cnt)# 使用可迭代对象（字典）作为参数cnt = counter({'a': 1, 'b': 2, 'd': 3, 'c': 2})print(cnt)# 使用关键字参数cnt = counter(a=1, b=2, d=3, c=2)print(cnt)
执行效果
counter()
counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})
counter({'a': 2, 'd': 2, 'b': 1, 'c': 1})
counter({'d': 3, 'b': 2, 'c': 2, 'a': 1})
counter({'d': 3, 'b': 2, 'c': 2, 'a': 1})
counter() 对象字典
由 counter() 返回的结果为一个字典，它拥有普通字典的大部分方法。在大多数情况下，你可以像操作字典一样操作 counter 对象。对此，请参考如下示例：
from collections import countercnt = counter('hello world')print(cnt)# 输出 counter 对象中的键值对列表print(cnt.items())# 移除 counter 对象中的最后一个键值对print(cnt.popitem())print(cnt)# 输出 counter 中键 l 对应的值print(cnt['l'])
执行结果
counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})
dict_items([('h', 1), ('e', 1), ('l', 3), ('o', 2), (' ', 1), ('w', 1), ('r', 1), ('d', 1)])
('d', 1)
counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1})
3
有序性
python 中的字典是无序的，无序的 的含义并不是说字典中的键值对没有顺序，而是指字典中的键值对的顺序是不可预测的。对此，请参考如下示例：
d = {'a': 1, 'b': 2, 'c': 3}for key in d: print(key)
该示例的输出结果可能是：
a
b
c
也可能是：
b
c
a
当然还存在其他可能，这里就不一一列举了。
python 官方对 python 3.6 版本中的字典进行了优化，使其能够记住键值对插入的顺序。此后，字典显得不那么凌乱了（字典中的键值对的顺序变得可以预测了）。
keyerror
在 python 的内置字典中，若尝试访问不存在的键，python 将抛出 keyerror 异常错误。对此，请参考如下示例：
d = dict([('a', 1), ('b', 2), ('c', 3)])print(d)# 尝试访问字典 d 中不存在的键print(d['d'])
执行效果
traceback (most recent call last):
file "c:\main.py", line 5, in <module>
print(d['d'])
keyerror: 'd'
{'a': 1, 'b': 2, 'c': 3}
同样的场景。这一次，我们让 counter 作为主角。
from collections import countercnt = counter({'a': 1, 'b': 2, 'c': 3})print(cnt)# 尝试访问 counter 中不存在的键print(cnt['d'])
执行效果
访问 counter 对象中不存在的键时，并不会抛出 keyerror 异常，而是返回默认计数值 0。
counter({'c': 3, 'b': 2, 'a': 1})
0
魔术方法 __missing__
__missing__() 是 python 中的一个特殊方法，用于处理通过键访问字典中的值时键不存在时的情况。
当我们使用字典的索引来访问一个不存在的键时，python 将会调用特殊方法 __missing__() 来尝试返回一个合适的值。若未实现 __missing__() 方法，python 将会抛出 keyerror 异常。对此，请参考如下示例：
# 创建一个字典对象，该对象继承自 python 内置的 dict 对象class mydict(dict): def __missing__(self, key): return 0# 实例化 mydict() 对象mydict = mydict()# 尝试访问 mydict 对象中不存在的键 aprint(mydict['a'])
执行效果
0
update() 方法
counter 对象与 dict 对象同样实现了 update() 方法。使用 update() 方法能够将作为参数的字典合并到调用该方法的 dict 对象中。不同的是，dict 对象的 update() 方法在遇到具有相同的键时，将会对该键对应的值执行 覆盖 操作。而 counter 对象的 update() 方法在遇到具有相同的键时，将会对该键对应的值执行 叠加 操作。对此，请参考如下示例：
from collections import counter# python 中内置的 dict 对象d = dict([('a', 1), ('b', 2), ('c', 3)])print(d)d.update({'a': 4})print(d)print()# counter 对象cnt = counter({'a': 1, 'b': 2, 'c': 3})print(cnt)cnt.update({'a': 4})print(cnt)
执行效果
{'a': 1, 'b': 2, 'c': 3}
{'a': 4, 'b': 2, 'c': 3}
counter({'c': 3, 'b': 2, 'a': 1})
counter({'a': 5, 'c': 3, 'b': 2})
counter 对象的常用方法most_common()most_common() 方法将返回一个列表，列表中的元素均为 counter 对象中的键值对组成的元组。元组在列表中的顺序取决于计数值（键值对中的值）的大小。计数值更大的元组将位于列表的前端，计数值相等的元组将按照它们首次在列表中出现的顺序进行排列（先出现的元组将更靠近列表的前端）。
most_common() 默认将使用 counter 对象中所有的键值对组成的元组作为返回列表中的元素。你可以通过向该方法提供一个数值，该数值将指定放回的列表中的元素的数量。
举个栗子
from collections import countercnt = counter({'a': 1, 'b': 2, 'c': 3})print(cnt)print()print(cnt.most_common())# 返回由 counter 中计数值最大的两个# 键值对构成的元组所组成的列表print(cnt.most_common(2))# 返回由 counter 中计数值最大的# 键值对构成的元组所组成的列表print(cnt.most_common(1))
执行效果
counter({'c': 3, 'b': 2, 'a': 1})
[('c', 3), ('b', 2), ('a', 1)]
[('c', 3), ('b', 2)]
[('c', 3)]
elements()elements() 方法将返回一个以 counter 对象中的键为元素的迭代器，其中每个元素将重复出现计数值所指定的次数。
迭代器中的元素将存在如下特点：
元素将会按照其首次添加到 counter 对象中的顺序进行返回。
某个键对应的计数值小于一，那么该键将不会作为元素出现在 element() 方法返回的迭代器中。
举个栗子
from collections import countercnt = counter({'a': 1, 'b': 2, 'c': 3, 'd': -4})print(cnt)print()print(list(cnt.elements()))
执行效果
counter({'c': 3, 'b': 2, 'a': 1, 'd': -4})
['a', 'b', 'b', 'c', 'c', 'c']
total()total() 方法将返回 counter 对象中，所有计数值累加后得到的结果。对此，请参考如下示例：
from collections import countercnt = counter({'a': 1, 'b': 2, 'c': 3, 'd': -4})cnt1 = counter('hello world')print(cnt.total())print(cnt1.total())
执行效果
2
11
subtract()该方法的效果与 counter 对象的 update() 方法类似。如果说 update() 方法执行的是 加 操作，那么 subtract() 方法执行的则是 减 操作。对此，请参考如下示例：
from collections import countercnt = counter({'a': 1, 'b': 2, 'c': 3, 'd': -4})cnt.subtract({'a': 0, 'b': 1, 'd': -11})print(cnt)
执行效果
counter({'d': 7, 'c': 3, 'a': 1, 'b': 1})
counter 对象间的运算注：
本部分内容中讲解到的运算符仅能在 python 3.3 及以后版本中正常使用。
加法运算在 python 的 counter 模块中，两个 counter 对象可以相加，相加后将返回一个新的 counter 对象，其中每个元素的计数是两个原始 counter 对象中该元素计数的总和。可以通过使用加法运算符来执行此操作。对此，请参考如下示例：
from collections import countercnt = counter('hello')cnt1 = counter('world')print(cnt)print(cnt1)print(cnt + cnt1)
执行效果
counter({'l': 2, 'h': 1, 'e': 1, 'o': 1})
counter({'w': 1, 'o': 1, 'r': 1, 'l': 1, 'd': 1})
counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, 'w': 1, 'r': 1, 'd': 1})
注：
在 counter 对象间的运算过程中，对于 counter 中不存在的键，其计数值为零。
减法运算在 python 的 counter 模块中，可以使用减法运算符来对两个 counter 对象进行减法运算，即将左侧 counter 对象中的计数器值减去右侧 counter 对象中相同键的计数器值，最后返回一个新的 counter 对象。对此，请参考如下示例：
from collections import countercnt = counter('cook')cnt1 = counter('coder')print(cnt)print(cnt1)print(cnt - cnt1)
执行效果
counter({'o': 2, 'c': 1, 'k': 1})
counter({'c': 1, 'o': 1, 'd': 1, 'e': 1, 'r': 1})
counter({'o': 1, 'k': 1})
注：
在 counter 对象间的运算过程中，对于 counter 中不存在的键，其计数值为零。
并集运算counter 对象之间的并集运算是指两个 counter 对象按照键的并集进行运算，返回的结果是一个新的 counter 对象，其中包含的键和值均为 原始 counter 对象中存在的键及其对应的最大值。对此，请参考如下示例：
from collections import countercnt = counter('hello')cnt1 = counter('world')print(cnt)print(cnt1)print(cnt | cnt1)
执行效果
counter({'l': 2, 'h': 1, 'e': 1, 'o': 1})
counter({'w': 1, 'o': 1, 'r': 1, 'l': 1, 'd': 1})
counter({'l': 2, 'h': 1, 'e': 1, 'o': 1, 'w': 1, 'r': 1, 'd': 1})
交集运算counter 对象之间的交集运算是指两个 counter 对象按照键的交集进行运算，返回的结果是一个新的 counter 对象，其中包含的键和值均为 原始 counter 对象中共同拥有的键及其对应的最小值。对此，请参考如下示例：
from collections import countercnt = counter('hello')cnt1 = counter('world')print(cnt)print(cnt1)print(cnt & cnt1)
执行效果
counter({'l': 2, 'h': 1, 'e': 1, 'o': 1})
counter({'w': 1, 'o': 1, 'r': 1, 'l': 1, 'd': 1})
counter({'l': 1, 'o': 1})
单目运算单目运算指的是表达式中存在单目运算符的运算操作。存在两种单目运算符，即单目减法运算符与单目加法运算符。无论是单目减法运算符还是单目加法运算符，它们的操作对象均为 counter 对象中的计数值。
在对 counter 对象进行单目运算后，将返回一个由大于零的计数值相关的键值对组成的 counter 对象。对此，请参考如下示例：
from collections import countercnt = counter({'a': 4, 'b': 3, 'd': 0, 'c': -5})print(+cnt)print(-cnt)
执行效果
counter({'a': 4, 'b': 3})
counter({'c': 5})
counter 对象间的比较从 python 3.10 版本开始，counter 对象间开始支持常见的比较运算符，这些运算符有：
<
<=
>
>=
==
!=
这里以 > 及 == 为例进行讲解。
>当 > 的左侧的 counter 对象的键对应的计数值均大于该符号右侧的 counter 对象中相同的键（对于 counter 中不存在的键，其计数值为零）对应的计数值时，比较结果为 true。否则为 false。对此，请参考如下示例：
from collections import countercnt = counter({'a': 4, 'b': 3, 'd': 7, 'c': 5})cnt1 = counter({'c': 3, 'd': 2, 'b': 6, 'a': 4})cnt2 = counter({'c': 4, 'd': 6, 'b': 2, 'a': 3})print(cnt > cnt1)print(cnt > cnt2)
执行效果
false
true
==当 == 的左侧的 counter 对象的键对应的计数值均等于该符号右侧的 counter 对象中相同的键（对于 counter 中不存在的键，其计数值为零）对应的计数值时，比较结果为 true。否则为 false。对此，请参考如下示例：
from collections import countercnt = counter({'a': 3, 'b': 2, 'd': 6, 'c': 4})cnt1 = counter({'c': 3, 'd': 2, 'b': 6, 'a': 4})cnt2 = counter({'c': 4, 'd': 6, 'b': 2, 'a': 3})print(cnt == cnt1)print(cnt == cnt2)
执行效果
false
true
以上就是python中的counter模块怎么使用的详细内容。