| Projet | Description |
|---|---|
| Interpréteur Python | 3.10.6 |
Dans le module de collections de Python, un module très couramment utilisé est Counter. Counter est un simple compteur utilisé pour compter le nombre de certains objets hachables. Il stocke les éléments et leurs comptes sous la forme d'un dictionnaire.
classe Counter() peut compter les paramètres transmis à cette classe selon certaines règles, et renvoyer l'objet de comptage et les résultats de comptage sous forme de paires clé-valeur sous la forme d'un dictionnaire.
Counter(iterable=None, /, **kwds)
Donnez-moi un exemple举个栗子
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 对象。对此，请参考如下示例：
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))Effet d'exécution🎜Objet Counter() 🎜🎜Dictionary🎜🎜Le résultat renvoyé par 🎜Counter()🎜 est un dictionnaire, qui a la plupart des méthodes d'un dictionnaire normal. Dans la plupart des cas, vous pouvez manipuler les objets 🎜Counter🎜 tout comme les dictionnaires. Pour cela, veuillez vous référer à l'exemple suivant : 🎜Counter({'l': 3, 'o': 2, 'H ' : 1, 'e' : 1, ' ' : 1, 'W' : 1, 'r' : 1, 'd' : 1})
Counter()Compteur({'a' : 2, 'd' : 2, 'b' : 1, 'c' : 1})
Compteur({'d' : 3 , 'b' : 2, 'c' : 2, 'a' : 1})🎜
Compteur({'d' : 3, 'b' : 2, 'c' : 2, 'a' : 1})
from collections import Counter
cnt = Counter({'a': 1, 'b': 2, 'c': 3, 'd': -4})
print(cnt)
print()
print(list(cnt.elements()))Execution Result🎜🎜🎜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) 🎜Compteur({'l' : 3, 'o' : 2, 'H' : 1, 'e' : 1, ' ' : 1, 'W' : 1, 'r' : 1})🎜3 🎜< /blockquote>🎜Ordering🎜🎜Le dictionnaire en Python n'est pas ordonné. La signification de 🎜Unordered🎜 ne signifie pas que les paires clé-valeur dans le dictionnaire n'ont pas d'ordre, mais que l'ordre des paires clé-valeur dans le dictionnaire. Le dictionnaire est irréversible. Pour cela, veuillez vous référer à l'exemple suivant : 🎜from collections import Counter
cnt = Counter({'a': 1, 'b': 2, 'c': 3, 'd': -4})
cnt1 = Counter('Hello World')
print(cnt.total())
print(cnt1.total())from collections import Counter
cnt = Counter({'a': 1, 'b': 2, 'c': 3, 'd': -4})
cnt.subtract({'a': 0, 'b': 1, 'd': -11})
print(cnt)Effet d'exécution🎜🎜🎜Traceback (dernier appel le plus récent) :🎜 Fichier "C:main.py", ligne 5, dans Même scénario. Cette fois, nous avons Counter comme protagoniste. 🎜from collections import Counter cnt = Counter('Hello') cnt1 = Counter('World') print(cnt) print(cnt1) print(cnt + cnt1)
Effet d'exécution🎜🎜Lors de l'accès à une clé qui n'existe pas dans l'objet Counter, l'exception 🎜KeyError🎜 ne sera pas levée, mais la valeur de comptage par défaut 🎜0🎜 le sera être restitué. 🎜🎜🎜Counter({'c': 3, 'b': 2, 'a': 1})🎜0🎜🎜Méthode magique __missing__🎜🎜🎜__missing__()🎜 est une méthode spéciale dans la méthode Python pour gérer la situation où une valeur dans un dictionnaire est accessible par clé et que la clé n'existe pas. 🎜Lorsque nous utilisons un index de dictionnaire pour accéder à une clé qui n'existe pas, Python appellera la méthode spéciale 🎜__missing__()🎜 pour essayer de renvoyer une valeur appropriée. Si la méthode 🎜__missing__()🎜 n'est pas implémentée, Python lancera une exception 🎜KeyError🎜. Pour cela, veuillez vous référer à l'exemple suivant : 🎜from collections import Counter cnt = Counter('cook') cnt1 = Counter('coder') print(cnt) print(cnt1) print(cnt - cnt1)
Execution Effect🎜🎜🎜0🎜🎜update() l'objet 🎜🎜🎜Counter🎜 et l'objet 🎜dict🎜 implémentent également 🎜 méthode update ()🎜. Utilisez la méthode 🎜update()🎜 pour fusionner le dictionnaire comme argument dans l'objet 🎜dict🎜 qui appelle la méthode. La différence est que lorsque la méthode 🎜update()🎜 de l'objet 🎜dict🎜 rencontre la même clé, elle effectuera l'opération 🎜overwrite🎜 sur la valeur correspondant à la clé. Lorsque la méthode 🎜update()🎜 de l'objet 🎜Counter🎜 rencontre la même clé, elle effectuera l'opération 🎜overlay🎜 sur la valeur correspondant à la clé. Pour cela, merci de vous référer à l'exemple suivant : 🎜from collections import Counter cnt = Counter('Hello') cnt1 = Counter('World') print(cnt) print(cnt1) print(cnt | cnt1)
Effet d'exécution🎜🎜🎜{'a' : 1, 'b' : 2, 'c' : 3}🎜{'a' : 4, 'b' : 2, 'c' : 3}🎜🎜Compteur({'c' : 3, 'b' : 2, 'a' : 1})🎜Compteur({'a' : 5, 'c ': 3, 'b': 2})🎜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() 方法将返回一个以 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() 方法将返回 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
该方法的效果与 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})
注：
本部分内容中讲解到的运算符仅能在 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})
从 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
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
