So verwenden Sie das Counter-Modul in Python

Beschreibung

Projekt	Beschreibung
Python-Interpreter	3.10.6

Counter-Modul

Im Sammlungsmodul von Python ist Counter ein sehr häufig verwendetes Modul. Counter ist ein einfacher Zähler, der zum Zählen der Anzahl bestimmter Hash-Objekte verwendet wird. Es speichert Elemente und ihre Anzahl in Form eines Wörterbuchs.

Counter() class

classCounter() kann die an diese Klasse übergebenen Parameter nach bestimmten Regeln zählen und zählen Das Objekt und Zählergebnisse werden als Schlüssel-Wert-Paare in Form eines Wörterbuchs zurückgegeben.

Counter(iterable=None, /, **kwds)

Gib mir eine Kastanie举个栗子

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 Counter
cnt = 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
print(d['d'])
KeyError: 'd'
{'a': 1, 'b': 2, 'c': 3}

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

from collections import Counter
cnt = 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 对象中不存在的键 a
print(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)

执行效果

from collections import Counter
cnt = 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))

Hinrichtungseffekt

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() object#🎜🎜##🎜🎜#Dictionary#🎜🎜##🎜🎜#returned by #🎜🎜#Counter()#🎜🎜# Das Ergebnis ist ein Wörterbuch, das über die meisten Methoden eines normalen Wörterbuchs verfügt. In den meisten Fällen können Sie #🎜🎜#Counter#🎜🎜#-Objekte genau wie Wörterbücher bearbeiten. Beachten Sie dazu bitte das folgende Beispiel: #🎜🎜#

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

print()

print(list(cnt.elements()))

#🎜🎜#Ausführungsergebnis#🎜🎜##🎜🎜##🎜🎜#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#🎜🎜##🎜🎜#Ordering#🎜🎜##🎜🎜#Python in Das Wörterbuch ist ungeordnet. #🎜🎜#Ungeordnet#🎜🎜# bedeutet nicht, dass die Schlüssel-Wert-Paare im Wörterbuch keine Reihenfolge haben, sondern dass die Reihenfolge der Schlüssel-Wert-Paare im Wörterbuch unvorhersehbar ist. Sehen Sie sich hierfür bitte das folgende Beispiel an: #🎜🎜#

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

#🎜🎜#Die Ausgabe dieses Beispiels könnte sein: #🎜🎜##🎜🎜##🎜🎜#a#🎜🎜#b#🎜🎜#c#🎜🎜 #< /blockquote>#🎜🎜# kann auch sein: #🎜🎜##🎜🎜##🎜🎜#b#🎜🎜#c#🎜🎜#a#🎜🎜##🎜🎜#Natürlich gibt es noch andere Möglichkeiten, ich werde sie hier nicht einzeln auflisten. #🎜🎜##🎜🎜#Python hat das Wörterbuch in der Version #🎜🎜#Python 3.6#🎜🎜# offiziell optimiert, sodass es sich die Reihenfolge merken kann, in der Schlüssel-Wert-Paare eingefügt werden. Danach sieht das Wörterbuch weniger überladen aus (die Reihenfolge der Schlüssel-Wert-Paare im Wörterbuch wird vorhersehbar). #🎜🎜##🎜🎜#KeyError#🎜🎜##🎜🎜#Wenn Sie im integrierten Wörterbuch von Python versuchen, auf einen nicht vorhandenen Schlüssel zuzugreifen, löst Python eine #🎜🎜#KeyError#🎜🎜#-Ausnahme aus Fehler. Beachten Sie dazu bitte das folgende Beispiel: #🎜🎜#

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

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

#🎜🎜#Ausführungseffekt#🎜🎜##🎜🎜##🎜🎜#Traceback (letzter Aufruf zuletzt):#🎜 🎜# Datei „C:main.py“, Zeile 5, in #🎜🎜# print(d['d'])#🎜🎜#KeyError: 'd'#🎜🎜#{'a': 1, 'b': 2, 'c': 3}#🎜🎜##🎜🎜#Die gleiche Szene. Dieses Mal haben wir Counter als Protagonisten. #🎜🎜#

from collections import Counter

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

print(cnt)
print(cnt1)
print(cnt + cnt1)

#🎜🎜#Ausführungseffekt#🎜🎜##🎜🎜#Beim Zugriff auf Schlüssel, die nicht im Counter-Objekt vorhanden sind, wird #🎜🎜#KeyError nicht auftreten #🎜🎜# Ausnahme ausgelöst, stattdessen wird der Standardzählwert #🎜🎜#0#🎜🎜# zurückgegeben. #🎜🎜##🎜🎜##🎜🎜#Counter({'c': 3, 'b': 2, 'a': 1})#🎜🎜#0#🎜🎜##🎜🎜 #Magic method__missing__#🎜🎜##🎜🎜##🎜🎜#__missing__()#🎜🎜# ist eine spezielle Methode in Python, die die Situation behandelt, wenn der Schlüssel nicht vorhanden ist, wenn über den Schlüssel auf den Wert im Wörterbuch zugegriffen wird. #🎜🎜#Wenn wir einen Wörterbuchindex verwenden, um auf einen nicht vorhandenen Schlüssel zuzugreifen, ruft Python die spezielle Methode #🎜🎜#__missing__()#🎜🎜# auf, um zu versuchen, einen geeigneten Wert zurückzugeben. Wenn die Methode #🎜🎜#__missing__()#🎜🎜# nicht implementiert ist, löst Python eine #🎜🎜#KeyError#🎜🎜# Ausnahme aus. Bitte beachten Sie hierzu das folgende Beispiel: #🎜🎜#

from collections import Counter

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

print(cnt)
print(cnt1)
print(cnt - cnt1)

#🎜🎜#Ausführungseffekt#🎜🎜##🎜🎜##🎜🎜#0#🎜🎜## 🎜🎜 #update()-Methode #🎜🎜##🎜🎜##🎜🎜#Counter#🎜🎜# Objekt und #🎜🎜#dict#🎜🎜# Objekt implementieren auch #🎜🎜#update()#🎜🎜# Verfahren. Verwenden Sie die Methode #🎜🎜#update()#🎜🎜#, um das Wörterbuch als Parameter in das Objekt #🎜🎜#dict#🎜🎜# einzuführen, das die Methode aufruft. Der Unterschied besteht darin, dass die Methode #🎜🎜#update()#🎜🎜# des #🎜🎜#dict#🎜🎜#-Objekts auf denselben Schlüssel #🎜🎜# den dem Schlüssel #🎜🎜 entsprechenden Wert überschreibt # Betrieb. Wenn die #🎜🎜#update()#🎜🎜#-Methode des #🎜🎜#Counter#🎜🎜#-Objekts auf denselben Schlüssel trifft, führt sie eine #🎜🎜#Overlay#🎜🎜 für den dem Schlüssel entsprechenden Wert aus . Beachten Sie dazu bitte das folgende Beispiel: #🎜🎜#

from collections import Counter

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

print(cnt)
print(cnt1)
print(cnt | cnt1)

#🎜🎜#Ausführungseffekt#🎜🎜##🎜🎜##🎜🎜#{'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})
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 Counter
cnt = 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 Counter
cnt = 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 Counter
cnt = 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 Counter

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

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

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

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

print(cnt > cnt1)
print(cnt > 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})

print(cnt == cnt1)
print(cnt == cnt2)

执行效果

False
True

Das obige ist der detaillierte Inhalt vonSo verwenden Sie das Counter-Modul in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!