Comment utiliser le compteur de Python à partir du module Collections

0 Partages

Dans ce didacticiel, vous apprendrez à utiliser l’objet compteur du module de collection de Python.

Lorsque vous travaillez avec de longues séquences en Python, par exemple des listes ou des chaînes Python, vous devrez parfois stocker les éléments qui apparaissent dans la séquence et le nombre de fois qu’ils apparaissent.

Un dictionnaire Python est une structure de données intégrée appropriée pour de telles applications. Cependant, la classe Counter de Python du module collections peut simplifier cela, en construisant un compteur, qui est un dictionnaire d’éléments et leur nombre dans la séquence.

Au cours des prochaines minutes, vous apprendrez ce qui suit :

Utiliser l’objet compteur de Python
Créer un dictionnaire Python pour stocker les valeurs de comptage des éléments dans un itérable
Réécrire le dictionnaire en utilisant le compteur de Python avec une syntaxe simplifiée
Effectuer des opérations telles que la mise à jour et la soustraction d’éléments, la recherche d’intersection entre deux objets de compteur
Obtenez les éléments les plus fréquents du compteur à l’aide de la méthode most_common()

Commençons!

Table des matières

Module de collections Python et classe Counter

Vous utiliserez souvent un dictionnaire Python pour stocker les éléments et leur nombre dans un itérable. Les éléments et le nombre sont stockés sous forme de clés et de valeurs, respectivement.

Comme la classe Counter fait partie du module de collections intégré de Python, vous pouvez l’importer dans votre script Python comme ceci :

from collections import Counter

Après avoir importé la classe Counter comme mentionné, vous pouvez instancier un objet compteur comme indiqué :

<counter_object> = Counter(iterable)

Ici:

iterable est n’importe quel itérable Python valide tel qu’une liste Python, une chaîne ou un tuple.
Les éléments de l’itérable doivent être hachables.

Maintenant que nous savons comment utiliser Counter pour créer des objets compteur à partir de n’importe quel itérable Python, commençons à coder.

Les exemples utilisés dans ce didacticiel se trouvent dans ce gist GitHub.

Comment créer un objet compteur à partir d’itérables Python

Créons une chaîne Python, disons, ‘renaissance’ et appelons-la word.

>>> word = "renaissance"

Notre objectif est de créer un dictionnaire dans lequel chaque lettre de la chaîne de mots est associée au nombre de fois qu’elle apparaît dans la chaîne. Une approche consiste à utiliser des boucles comme indiqué :

>>> letter_count = {}
>>> for letter in word:
...     if letter not in letter_count:
...         letter_count[letter] = 0
...     letter_count[letter] += 1
...
>>> letter_count
{'r': 1, 'e': 2, 'n': 2, 'a': 2, 'i': 1, 's': 2, 'c': 1}

Analysons ce que fait l’extrait de code ci-dessus :

Initialise letter_count dans un dictionnaire Python vide.
Boucle sur la chaîne de mots.
Vérifie si la lettre est présente dans le dictionnaire letter_count.
Si la lettre n’est pas présente, il l’ajoute avec une valeur de 0 et incrémente ensuite la valeur de 1.
Pour chaque occurrence de lettre dans mot, la valeur correspondant à lettre est incrémentée de 1.
Cela continue jusqu’à ce que nous parcourions toute la chaîne.

Nous avons construit le dictionnaire letter_count – par nous-mêmes – en utilisant la boucle for pour parcourir le mot de la chaîne.

Utilisons maintenant la classe Counter du module collections. Nous n’avons qu’à transmettre la chaîne de mots à Counter() pour obtenir letter_count sans avoir à parcourir les itérables.

>>> from collections import Counter
>>> letter_count = Counter(word)
>>> letter_count
Counter({'e': 2, 'n': 2, 'a': 2, 's': 2, 'r': 1, 'i': 1, 'c': 1})

L’objet compteur est également un dictionnaire Python. Nous pouvons utiliser la fonction intégrée isinstance() pour vérifier ceci :

>>> isinstance(letter_count,dict)
True

Comme on le voit, isinstance(letter_count, dict) renvoie True indiquant que l’objet compteur letter_count est une instance de la classe Python dict.

Modification de l’objet compteur

Jusqu’à présent, nous avons appris à créer des objets compteur à partir de chaînes Python.

Vous pouvez également modifier les objets compteur en les mettant à jour avec des éléments d’un autre itérable ou en leur soustrayant un autre itérable.

Mettre à jour un compteur avec des éléments d’un autre itérable

Initialisons une autre chaîne another_word :

>>> another_word = "effervescence"

Supposons que nous souhaitions mettre à jour l’objet compteur letter_count avec les éléments de la chaîne another_word.

Nous pouvons utiliser la méthode update() sur l’objet compteur letter_count.

>>> letter_count.update(another_word)
>>> letter_count
Counter({'e': 7, 'n': 3, 's': 3, 'c': 3, 'r': 2, 'a': 2, 'f': 2, 'i': 1, 'v': 1})

Dans la sortie, nous voyons que l’objet compteur a été mis à jour pour inclure également les lettres et leur nombre d’occurrences d’un autre_mot.

Soustraire des éléments d’un autre itérable

Soustrayons maintenant la valeur de another_word de l’objet letter_count. Pour ce faire, nous pouvons utiliser la méthode subtract(). L’utilisation de .subtract() soustrait les valeurs correspondant aux éléments de du .

Soustrayons another_word de letter_count.

>>> letter_count.subtract(another_word)
>>> letter_count
Counter({'e': 2, 'n': 2, 'a': 2, 's': 2, 'r': 1, 'i': 1, 'c': 1, 'f': 0, 'v': 0})

Nous voyons que les valeurs correspondant aux lettres dans another_word ont été soustraites, mais les clés ajoutées ‘f’ et ‘v’ ne sont pas supprimées. Ils correspondent maintenant à une valeur de 0.

Remarque : Ici, nous avons passé un autre_mot, une chaîne Python, à l’appel de la méthode subtract(). Nous pouvons également transmettre un objet compteur Python ou un autre objet itérable.

Intersection entre deux objets compteur en Python

Vous voudrez peut-être parfois trouver l’intersection entre deux objets de compteur Python pour identifier les clés communes aux deux.

Créons un objet compteur, disons, letter_count_2, à partir de la chaîne another_word ‘effervescence’.

>>> another_word = "effervescence"
>>> letter_count_2 = Counter(another_word)
>>> letter_count_2
Counter({'e': 5, 'f': 2, 'c': 2, 'r': 1, 'v': 1, 's': 1, 'n': 1})

Nous pouvons utiliser l’opérateur simple & pour trouver l’intersection entre letter_count et letter_count_2.

>>> letter_count & letter_count_2
Counter({'e': 2, 'r': 1, 'n': 1, 's': 1, 'c': 1})

Remarquez comment vous obtenez les clés et le nombre d’occurrences communes aux deux mots. ‘renaissance’ et ‘effervescence’ contiennent deux occurrences de ‘e’, et une occurrence de ‘r’, ‘n’, ‘s’ et ‘c’ en commun.

Trouvez les éléments les plus fréquents à l’aide de most_common

Une autre opération courante sur l’objet compteur Python consiste à rechercher les éléments les plus fréquents.

Pour obtenir les k éléments les plus courants du compteur, vous pouvez utiliser la méthode most_common() sur l’objet compteur. Ici, nous appelons most_common() sur letter_count pour trouver les trois lettres les plus fréquentes.

>>> letter_count.most_common(3)
[('e', 2), ('n', 2), ('a', 2)]

Nous voyons que les lettres ‘e’, ’n’ et ‘a’ apparaissent deux fois dans le mot ‘renaissance’.

Ceci est particulièrement utile si le compteur contient un grand nombre d’entrées et que vous souhaitez travailler avec les clés les plus courantes.

Conclusion

Voici un bref aperçu de ce que nous avons appris dans le didacticiel :

La classe Counter du module de collections intégré de Python peut être utilisée pour obtenir un dictionnaire des valeurs de comptage de tous les éléments dans n’importe quel itérable. Vous devez vous assurer que tous les éléments de l’itérable sont hachables.
Vous pouvez mettre à jour le contenu d’un objet compteur Python avec le contenu d’un autre objet compteur ou de tout autre itérable à l’aide de la méthode update() avec la syntaxe : counter1.update(counter2). Notez que vous pouvez utiliser n’importe quel itérable à la place de counter2.
Si vous souhaitez supprimer le contenu de l’un des itérables du compteur mis à jour, vous pouvez utiliser la méthode subtract() : counter1.subtract(counter2).
Pour trouver les éléments communs entre deux objets compteur, vous pouvez utiliser l’opérateur &. Étant donné deux compteurs compteur1 et compteur2, compteur1 & compteur2 renvoie l’intersection de ces deux objets compteur.
Pour obtenir les k éléments les plus fréquents dans un compteur, vous pouvez utiliser la méthode most_common(). counter.most_common(k) donne les k éléments les plus courants et les nombres respectifs.

Ensuite, apprenez à utiliser le dict par défaut, une autre classe du module collections. Vous pouvez utiliser dict par défaut au lieu d’un dictionnaire Python standard pour gérer les clés manquantes.