Dans ce guide, vous allez découvrir comment exploiter l’objet `Counter` du module `collections` en Python.
Lorsque vous manipulez de longues séquences en Python, comme des listes ou des chaînes, il est parfois nécessaire de recenser les éléments présents et leur fréquence d’apparition.
Bien qu’un dictionnaire Python soit une structure de données appropriée pour cela, la classe `Counter` du module `collections` simplifie cette tâche en créant un compteur, c’est-à-dire un dictionnaire qui associe chaque élément à son nombre d’occurrences dans la séquence.
Au cours de cet article, vous apprendrez à :
- Utiliser l’objet `Counter` de Python
- Créer un dictionnaire Python pour enregistrer les fréquences des éléments dans un itérable
- Remplacer le dictionnaire par un `Counter` en utilisant une syntaxe plus simple
- Effectuer des opérations telles que la mise à jour, la soustraction et la recherche d’intersection entre deux objets `Counter`
- Obtenir les éléments les plus fréquents d’un compteur avec la méthode `most_common()`
C’est parti !
Module `collections` de Python et classe `Counter`
On utilise souvent un dictionnaire Python pour stocker les éléments d’un itérable et leur nombre d’occurrences. Les éléments sont les clés du dictionnaire, et leur nombre d’occurrences les valeurs associées.
Comme la classe `Counter` fait partie du module intégré `collections`, vous pouvez l’importer dans votre script Python comme ceci :
from collections import Counter
Une fois la classe `Counter` importée, vous pouvez créer un objet compteur de cette manière :
<objet_compteur> = Counter(itérable)
Où :
- `itérable` est n’importe quel itérable Python valide, comme une liste, 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 compteurs à partir de n’importe quel itérable Python, commençons à coder.
Les exemples de ce tutoriel sont disponibles dans ce gist GitHub.
Comment créer un objet `Counter` à partir d’itérables Python
Créons une chaîne Python, par exemple, ‘renaissance’, que nous appellerons `word`.
>>> word = "renaissance"
Notre but est de créer un dictionnaire où chaque lettre de la chaîne est associée à sa fréquence d’apparition dans la chaîne. Une approche consiste à utiliser une boucle comme ceci :
>>> 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}
Voyons ce que fait ce code :
- Il initialise `letter_count` avec un dictionnaire Python vide.
- Il parcourt la chaîne `word`.
- Il vérifie si la lettre est déjà présente dans le dictionnaire `letter_count`.
- Si la lettre n’est pas présente, il l’ajoute avec une valeur de 0, puis incrémente sa valeur de 1.
- Pour chaque occurrence de lettre dans `word`, la valeur associée à cette lettre est incrémentée de 1.
- Ce processus continue jusqu’à ce que toute la chaîne ait été parcourue.
Nous avons construit le dictionnaire `letter_count` en utilisant une boucle `for` pour parcourir chaque lettre du mot.
Utilisons maintenant la classe `Counter` du module `collections`. Il suffit de passer la chaîne `word` à `Counter()` pour obtenir `letter_count` sans avoir à itérer manuellement.
>>> 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})
Un objet `Counter` est également un dictionnaire Python. On peut le vérifier avec la fonction intégrée `isinstance()` :
>>> isinstance(letter_count,dict) True
Comme on peut le voir, `isinstance(letter_count, dict)` retourne `True`, ce qui confirme que l’objet `letter_count` est une instance de la classe `dict`.
Modification de l’objet `Counter`
Jusqu’à présent, nous avons appris à créer des objets `Counter` à partir de chaînes Python.
Vous pouvez aussi modifier un objet `Counter` en y ajoutant ou en y soustrayant des éléments provenant d’un autre itérable.
Mettre à jour un compteur avec les éléments d’un autre itérable
Initialisons une autre chaîne, `another_word` :
>>> another_word = "effervescence"
Supposons que nous voulions mettre à jour l’objet compteur `letter_count` avec les éléments de la chaîne `another_word`.
On peut 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})
Le résultat montre que l’objet compteur a été mis à jour pour inclure également les lettres et leur nombre d’occurrences dans `another_word`.
Soustraire des éléments d’un autre itérable
Soustrayons maintenant les valeurs de `another_word` de l’objet `letter_count`. Pour ce faire, utilisons la méthode `subtract()`. L’opération `
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})
On observe que les valeurs correspondant aux lettres dans `another_word` ont été soustraites, mais les clés ajoutées `’f’` et `’v’` n’ont pas été supprimées. Elles ont maintenant une valeur de 0.
Note : Ici, nous avons passé une chaîne Python `another_word` à l’appel de la méthode `subtract()`. On peut également y passer un autre objet `Counter` ou tout autre itérable.
Intersection entre deux objets `Counter` en Python
Il peut être utile de déterminer l’intersection entre deux objets `Counter` afin d’identifier les clés qu’ils ont en commun.
Créons un autre objet `Counter`, par exemple `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})
On utilise l’opérateur `&` 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})
Vous voyez que le résultat contient les clés et le nombre d’occurrences que les deux mots ont en commun. ‘renaissance’ et ‘effervescence’ partagent deux occurrences de ‘e’, et une occurrence de ‘r’, ‘n’, ‘s’ et ‘c’.
Trouver les éléments les plus fréquents avec `most_common`
Une autre opération courante sur un objet `Counter` est la recherche des éléments les plus fréquents.
Pour obtenir les `k` éléments les plus courants d’un compteur, on utilise la méthode `most_common()`. 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 lorsque le compteur contient un grand nombre d’entrées et que l’on souhaite travailler avec les clés les plus courantes.
Conclusion
Voici un résumé de ce que nous avons appris dans ce tutoriel :
- La classe `Counter` du module `collections` de Python permet de créer un dictionnaire des fréquences d’apparition de tous les éléments d’un itérable. Assurez-vous que tous les éléments de l’itérable sont hachables.
- Vous pouvez mettre à jour le contenu d’un objet compteur avec le contenu d’un autre objet compteur ou de tout autre itérable en utilisant la méthode `update()` avec la syntaxe : `counter1.update(counter2)`. Notez que `counter2` peut être remplacé par n’importe quel itérable.
- Si vous voulez soustraire le contenu d’un itérable du compteur, vous pouvez utiliser la méthode `subtract()` : `counter1.subtract(counter2)`.
- Pour trouver les éléments communs entre deux objets compteur, utilisez l’opérateur `&`. Avec deux compteurs `compteur1` et `compteur2`, `compteur1 & compteur2` renvoie l’intersection de ces deux objets.
- Pour obtenir les `k` éléments les plus fréquents d’un compteur, utilisez la méthode `most_common()`. `counter.most_common(k)` retourne les `k` éléments les plus fréquents et leurs nombres d’occurrences.
Ensuite, découvrez comment utiliser `defaultdict`, une autre classe du module `collections`. `defaultdict` peut remplacer un dictionnaire Python standard pour gérer les clés manquantes.