Comment utiliser le compteur de Python à partir du module Collections

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 le articles qui apparaissent dans la séquence et le nombre de fois 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 articles les plus fréquents dans le comptoir en utilisant le most_common() méthode

Commençons!

Python Collections Module and Counter Class

Vous utiliserez souvent un dictionnaire Python est de 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.

le Counter class fait partie du module de collections intégré de Python, vous pouvez l'importer dans votre script Python comme suit :

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 un itérable Python valide tel qu'une liste Python, une chaîne ou un tuple.
Les éléments de l'itérable doivent être hachable.

Maintenant que nous savons 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 tutoriel se trouvent dans cet essentiel GitHub.

How to Create a Counter Object from Python Iterables

Créer un compteur d'objets à partir de Python Iterables

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

>>> word = "renaissance"

Notre but est de créer un dictionnaire où chaque lettre du word chaîne est mappé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 à un dictionnaire Python vide.
Boucle à travers le word chaîne.
Vérifie si letter est présent dans le letter_count dictionnaire.
If letter n'est pas présent, il l'ajoute avec une valeur de 0 puis incrémente la valeur de 1.
Pour chaque occurrence de letter in word, la valeur correspondant àletter est incrémenté de 1.
Cela continue jusqu'à ce que nous parcourions toute la chaîne.

Nous avons construit le letter_count dictionnaire — par nous-mêmes — en utilisant pour la boucle faire une boucle dans la chaîne word.

Utilisons maintenant la classe Counter du module collections. Nous n'avons qu'à passer dans le word chaîne à Counter() 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() fonction pour vérifier ceci:

>>> isinstance(letter_count,dict)
True

Comme vu, isinstance(letter_count, dict) Retours True indiquant que l'objet compteur letter_count est une instance de Python dict classe.

Modifying the Counter Object

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 le letter_count contre-objet avec les éléments de another_word chaîne.

Nous pouvons utiliser le update() méthode 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 de another_word.

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

Soustrayons maintenant la valeur de another_word à partir de letter_count objet. Pour ce faire, nous pouvons utiliser le subtract() méthode. En utilisant <counter-object>.subtract(<some-iterable>) soustrait les valeurs correspondant aux éléments de <some-iterable> du <counter-object>.

soustrayons another_word à partir 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})

On voit 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.

Notes: Ici, nous sommes passés another_word, une chaîne Python, au subtract() appel de méthode. Nous pouvons également transmettre un objet compteur Python ou un autre objet itérable.

Intersection Between Two Counter Objects in Python

Intersection-Entre-Deux-Compteurs-Objets-en-Python

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

Créons un objet compteur, disons, letter_count_2, du another_word chaîne '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 commun aux deux mots. 'renaissance' et 'effervescence' contiennent deux occurrences de 'e', et une occurrence de 'r', 'n', 's' et 'c' en commun.

Find the Most Frequent Items Using 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 le most_common() méthode sur l'objet compteur. Ici, on appelle most_common() on 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 le Le plus commun clés.

Conclusion

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

Les Counter La classe 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 objet itérable à l'aide de la update() méthode 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 commande subtract() méthode: counter1.subtract(counter2).
Pour trouver les éléments communs entre deux objets compteur, vous pouvez utiliser la & opérateur. Étant donné deux compteurs counter1 et counter2, counter1 & counter2 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 most_common() méthode. counter.most_common(k) donne les k éléments les plus courants et les décomptes respectifs.

Ensuite, apprenez comment 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.