Python中的Counter模块及使用详解搞定重复计数

文章目录 参考描述Counter 模块Counter) 类Counter) 对象字典有序性KeyError魔术方法 \_\_missing\_\_ update) 方法 Counter 对象的常用方法most_common)elements)total)subtract) Counter 对象间的运算加法运算减法运算并集运算交集运算单目运算 Counter 对象间的比较>==

参考

项目	描述
Python 标准库	DougHellmann 著 / 刘炽 等 译
搜索引擎	Bing
Python 官方文档	collections — 容器数据类型

描述

项目	描述
Python 解释器	3.10.6

Counter 模块

在 Python 的 collections 模块中，有一个很常用的模块就是 Counter。Counter 是一个简单的计数器，用于统计某些可哈希对象的数量。它以字典的形式存储元素和它们的计数。

Counter) 类

类 Counter) 能够对传入给该类的参数按照一定规则进行计数，并将计数对象与计数结果作为键值对以字典的形式进行结果的返回。

Counteriterable=None, /, **kwds)

举个栗子

from collections import Counter
# 返回一个空的 Counter 对象
cnt = Counter)
printcnt)

# 将可迭代对象（字符串）作为参数
cnt = Counter'Hello World')
printcnt)

# 将可迭代对象（列表）作为参数
cnt = Counter['a', 'a', 'b', 'd', 'c', 'd'])
printcnt)

# 使用可迭代对象（字典）作为参数
cnt = Counter{'a': 1, 'b': 2, 'd': 3, 'c': 2})
printcnt)

# 使用关键字参数
cnt = Countera=1, b=2, d=3, c=2)
printcnt)

执行效果

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 Counter
cnt = Counter'Hello World')
printcnt)

# 输出 Counter 对象中的键值对列表
printcnt.items))

# 移除 Counter 对象中的最后一个键值对
printcnt.popitem))
printcnt)

# 输出 Counter 中键 l 对应的值
printcnt['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:
    printkey)

该示例的输出结果可能是：

a
b
c

也可能是：

b
c
a

当然还存在其他可能，这里就不一一列举了。

Python 官方对 Python 3.6 版本中的字典进行了优化，使其能够记住键值对插入的顺序。此后，字典显得不那么凌乱了（字典中的键值对的顺序变得可以预测了）。

KeyError

在 Python 的内置字典中，若尝试访问不存在的键，Python 将抛出 KeyError 异常错误。对此，请参考如下示例：

d = dict['a', 1), 'b', 2), 'c', 3)])
printd)

# 尝试访问字典 d 中不存在的键
printd['d'])

执行效果

Traceback most recent call last):
  File "C:\main.py", line 5, in <module>
    printd['d'])
KeyError: 'd'
{'a': 1, 'b': 2, 'c': 3}

同样的场景。这一次，我们让 Counter 作为主角。

from collections import Counter
cnt = Counter{'a': 1, 'b': 2, 'c': 3})
printcnt)

# 尝试访问 Counter 中不存在的键
printcnt['d'])

执行效果

访问 Counter 对象中不存在的键时，并不会抛出 KeyError 异常，而是返回默认计数值 0。

Counter{'c': 3, 'b': 2, 'a': 1})
0

魔术方法 __missing__

__missing__) 是 Python 中的一个特殊方法，用于处理通过键访问字典中的值时键不存在时的情况。
当我们使用字典的索引来访问一个不存在的键时，Python 将会调用特殊方法 __missing__) 来尝试返回一个合适的值。若未实现 __missing__) 方法，Python 将会抛出 KeyError 异常。对此，请参考如下示例：

# 创建一个字典对象，该对象继承自 Python 内置的 dict 对象
class MyDictdict):
    def __missing__self, key):
        return 0

# 实例化 MyDict) 对象
myDict = MyDict)
# 尝试访问 myDict 对象中不存在的键 a
printmyDict['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)])
printd)

d.update{'a': 4})
printd)

print)

# Counter 对象
cnt = Counter{'a': 1, 'b': 2, 'c': 3})
printcnt)

cnt.update{'a': 4})
printcnt)

执行效果

{'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 Counter
cnt = Counter{'a': 1, 'b': 2, 'c': 3})
printcnt)

print)

printcnt.most_common))
# 返回由 Counter 中计数值最大的两个
# 键值对构成的元组所组成的列表
printcnt.most_common2))
# 返回由 Counter 中计数值最大的
# 键值对构成的元组所组成的列表
printcnt.most_common1))

执行效果

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 Counter
cnt = Counter{'a': 1, 'b': 2, 'c': 3, 'd': -4})
printcnt)

print)

printlistcnt.elements)))

执行效果

Counter{'c': 3, 'b': 2, 'a': 1, 'd': -4})

['a', 'b', 'b', 'c', 'c', 'c']

total)

total) 方法将返回 Counter 对象中，所有计数值累加后得到的结果。对此，请参考如下示例：

from collections import Counter
cnt = Counter{'a': 1, 'b': 2, 'c': 3, 'd': -4})
cnt1 = Counter'Hello World')
printcnt.total))
printcnt1.total))

执行效果

2
11

subtract)

该方法的效果与 Counter 对象的 update) 方法类似。如果说 update) 方法执行的是 加 操作，那么 subtract) 方法执行的则是 减 操作。对此，请参考如下示例：

from collections import Counter
cnt = Counter{'a': 1, 'b': 2, 'c': 3, 'd': -4})

cnt.subtract{'a': 0, 'b': 1, 'd': -11})
printcnt)

执行效果

Counter{'d': 7, 'c': 3, 'a': 1, 'b': 1})

Counter 对象间的运算

注：

本部分内容中讲解到的运算符仅能在 Python 3.3 及以后版本中正常使用。

加法运算

在 Python 的 Counter 模块中，两个 Counter 对象可以相加，相加后将返回一个新的 Counter 对象，其中每个元素的计数是两个原始 Counter 对象中该元素计数的总和。可以通过使用加法运算符来执行此操作。对此，请参考如下示例：

from collections import Counter

cnt = Counter'Hello')
cnt1 = Counter'World')

printcnt)
printcnt1)
printcnt + 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 Counter

cnt = Counter'cook')
cnt1 = Counter'coder')

printcnt)
printcnt1)
printcnt - 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 Counter

cnt = Counter'Hello')
cnt1 = Counter'World')

printcnt)
printcnt1)
printcnt | 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 Counter

cnt = Counter'Hello')
cnt1 = Counter'World')

printcnt)
printcnt1)
printcnt & 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 Counter

cnt = 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 Counter

cnt = 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})

printcnt > cnt1)
printcnt > cnt2)

执行效果

False
True

==

当 == 的左侧的 Counter 对象的键对应的计数值均等于该符号右侧的 Counter 对象中相同的键（对于 Counter 中不存在的键，其计数值为零）对应的计数值时，比较结果为 True。否则为 False。对此，请参考如下示例：

from collections import Counter

cnt = 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})

printcnt == cnt1)
printcnt == cnt2)

执行效果

False
True

到此这篇关于Python 中的 Counter 模块及使用详解搞定重复计数)的文章就介绍到这了,更多相关Python Counter 模块内容请搜索风君子博客以前的文章或继续浏览下面的相关文章希望大家以后多多支持风君子博客！