Comment utiliser le module Compteur en Python

Description

Projet	Description
Interpréteur Python	3.10.6

Module Counter

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()

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() 返回的结果为一个字典，它拥有普通字典的大部分方法。在大多数情况下，你可以像操作字典一样操作 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 4225fa317875f3e92281a7b1a5733569
    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

Counter()

Counter({'l': 3, 'o': 2, 'H ' : 1, 'e' : 1, ' ' : 1, 'W' : 1, 'r' : 1, 'd' : 1})

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})🎜

🎜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 : 🎜

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 🎜🎜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())

🎜Le résultat de cet exemple peut être : 🎜🎜🎜a🎜b🎜c🎜🎜 Il peut également être : 🎜🎜🎜b🎜c🎜a🎜 🎜Bien sûr, il existe d'autres possibilités, je ne les énumérerai donc pas toutes ici. 🎜🎜Python a officiellement optimisé le dictionnaire dans la version 🎜Python 3.6🎜 afin qu'il puisse mémoriser l'ordre dans lequel les paires clé-valeur sont insérées. Après cela, le dictionnaire semble moins encombré (l'ordre des paires clé-valeur dans le dictionnaire devient prévisible). 🎜🎜KeyError🎜🎜Dans le dictionnaire intégré de Python, si vous essayez d'accéder à une clé inexistante, Python générera une erreur d'exception 🎜KeyError🎜. Pour cela, référez-vous à l'exemple suivant : 🎜

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 d477e24f94f754ae8a1833aeb9235c51

>=

==

!=

这里以 > 及 == 为例进行讲解。

>

当 > 的左侧的 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!