Python Counter : compter des éléments avec la sous-classe

La classe Python Counter est utilisée pour compter des éléments dans un conteneur. Il s’agit d’une sous-classe de la classe dic­tion­naire (Dic­tio­nary) dict qui, en com­bi­nai­son avec dif­fé­rentes méthodes, a de nom­breuses uti­li­sa­tions possibles. Découvrez-les dans la suite de cet article.

Qu’est-ce que Python Counter ?

Python Counter est un outil utile qui permet de compter dif­fé­rents éléments dans une liste et d’afficher la fréquence d’ap­pa­ri­tion de ces éléments. Il s’agit d’une sous-classe de Dic­tio­nary, la structure de données im­plé­men­tée par la classe dict. Alors que cette tâche peut fa­ci­le­ment être effectuée ma­nuel­le­ment pour une courte suc­ces­sion de valeurs, elle est nettement plus com­pli­quée pour les longs ensembles de données. Python Counter est un objet qui commence avec une valeur initiale de zéro. Un seul compteur indique la fréquence d’un objet par­ti­cu­lier. Si vous souhaitez suivre la fréquence de plusieurs objets dif­fé­rents, utilisez un compteur distinct pour chaque objet.

La classe Counter peut être utilisée pour les listes, les tuples Python, les dic­tion­naires et les strings Python. Sa syntaxe est la suivante :

Counter(list)

Dans les pa­ra­graphes suivants, nous vous montrons à l’aide de quelques exemples simples comment utiliser Python Counter.

Python Counter avec une liste

Dans le premier exemple, nous créons une liste simple avec dif­fé­rentes valeurs. Celle-ci ressemble à ceci :

list = ['a', 'a', 'b', 'a', 'c', 'b', 'b', 'c', 'a', 'c', 'b', 'c']

La liste comporte trois éléments dif­fé­rents : 'a', 'b' et 'c'. Pour savoir combien de fois chacun de ces éléments est contenu, nous ap­pli­quons Python Counter. La sortie res­sem­ble­rait alors à ceci :

Counter({'c' : 5, 'a' : 4, 'b' : 4})

Pour utiliser Python Counter, il faut d’abord importer la classe. Le résultat est affiché avec print. Le code complet pour cet exemple serait alors celui-ci :

from collections import Counter
list = ['a', 'a', 'b', 'a', 'c', 'b', 'b', 'c', 'a', 'c', 'b', 'c', 'c']
counter_list = Counter(list)
print(Counter(list))

La sortie qui en résulte ressemble à ceci :

Counter({'c' : 5, 'a' : 4, 'b' : 4})

Python Counter avec un tuple

Dans le deuxième exemple, nous procédons de manière très similaire. Cette fois-ci, Python Counter doit être appliqué à un tuple. Les tuples sont utilisés en Python pour stocker plusieurs valeurs dans une variable. Comme il s’agit d’un re­grou­pe­ment ordonné d’objets, l’ordre est pris en compte. Les objets sont placés entre pa­ren­thèses et séparés par des virgules. En con­sé­quence, le code se présente sous la forme suivante :

from collections import Counter
tuple = ('a', 'a', 'b', 'a', 'c', 'b', 'b', 'c', 'a', 'c', 'b', 'c', 'c')
print(Counter(tuple))

La sortie est identique à l’exemple précédent :

Counter({'c' : 5, 'a' : 4, 'b' : 4})

Uti­li­sa­tion dans un dic­tion­naire

Dans un dic­tion­naire, les éléments sont stockés sous forme de paires clé-valeur et placés entre accolades. Si vous utilisez le Counter de Python avec un Dic­tio­nary, ce dernier est trans­formé en un objet de type Hashtable. Les clés du Dic­tio­nary original de­vien­nent les éléments, et leurs valeurs de­vien­nent leurs fré­quences. Pour notre exemple ci-dessus, cela pourrait res­sem­bler à ceci :

from collections import Counter
dictionary = {'a' : 4, 'b' : 4, 'c' : 5}
counter_dictionary = Counter(dictionary)
print(Counter(dictionary))

La sortie est alors à nouveau celle-ci :

Counter({'c' : 5, 'a' : 4, 'b' : 4})

Python Counter en com­bi­nai­son avec une simple chaîne de ca­rac­tères

Vous pouvez vous faire une idée du gain de temps et de la sim­pli­fi­ca­tion du travail que peut offrir Python Counter en ap­pli­quant cette classe à une chaîne de ca­rac­tères (string en anglais). Une chaîne de ca­rac­tères est une suite de ca­rac­tères marqués par des guil­le­mets. Les espaces sont également pris en compte. Nous choi­sis­sons la chaîne de ca­rac­tères suivante pour notre exemple :

from collections import Counter
string = "This is an example"
counter_string = Counter(string)
print(Counter(string))

Main­te­nant, chaque caractère est compté comme une sous-chaîne. La sortie pourrait donc res­sem­bler à ceci :

Counter({' ' : 3, 'i' : 2, 's' : 2, 'T' : 1, 'h' : 1, 'a' : 1, 'n' : 1, 'e' : 1, 'x' : 1, 'm' : 1, 'p' : 1, 'l' : 1})

Ex­ten­sions avec .update()

Python offre de nom­breuses options pour Counter. Par exemple, il est aussi possible d’étendre un comptage existant en utilisant .update(). Pour ce faire, nous créons d’abord un simple code basé sur le principe mentionné pré­cé­dem­ment, mais cette fois, nous n’isolons pas les chaînes de ca­rac­tères sé­pa­ré­ment :

from collections import Counter
Counter("blue")
print(Counter(string))

Notre sortie est alors celle-ci :

Counter({'b' : 1, 'l' : 1, 'u' : 1, 'e' : 1})

Si nous ap­pli­quons main­te­nant .update(), le code ressemble à ceci :

from collections import Counter
colors = Counter({'b' : 1, 'l' : 1, 'a' : 1, 'u' : 1})
colors.update("gray")
print(colors)

Cela nous permet également d’obtenir une sortie ac­tua­li­sée :

Counter({'b' : 1, 'l' : 1, 'u' : 1, 'e' : 1, 'g' : 1, 'r' : 1, 'a' : 1, 'y' : 1})

Accéder aux valeurs de Python Counter

Vous avez la pos­si­bi­lité d’accéder aux valeurs de Python Counter, car cette classe fonc­tionne de manière similaire à Dic­tio­nary. Dans l’exemple de code suivant, nous vous montrons quelques va­ria­tions et les sorties cor­res­pon­dantes. Ici, les lettres (letters) fonc­tion­nent comme des clés (keys) et les fré­quences des éléments comptés (counts) comme des valeurs (values).

from collections import Counter
letters = Counter("roof")
letters["o"]
2
letters["f"]
1

for letter in letters:
	print(letter, letters[letter])
r 1
o 2
f 1

Voici à quoi res­sem­ble­rait un exemple avec la méthode .keys() :

for letter in letters.keys():
	print(letter, letters[letter])
r 1
o 2
f 1

Ceci est un exemple avec .values() :

for count in letters.values():
	print(count)
1
2
1

Ceci est la méthode .items() :

for letter, count in letters.items():
	print(letter, count)
r 1
o 2
f 1

Supprimer des éléments de la classe

Si vous souhaitez supprimer un élément de Python Counter, utilisez del :

from collections import Counter
example = {'b' : 1, 'l' : 1, 'u' : 1, 'e' : 1}
del example["b"]
print(Counter(example))

Votre nouvelle sortie se présente alors comme suit :

Counter({'l' : 1, 'u' : 1, 'e' : 1})

Dé­ter­mi­ner la plus grande ac­cu­mu­la­tion avec most_common(n)

Avec most_common(n) pour Python Counter, vous pouvez dé­ter­mi­ner quels éléments sont le plus et le moins souvent re­pré­sen­tés. Prenons un exemple : un produit est listé dans dif­fé­rentes couleurs. À côté des couleurs est indiquée la fréquence à laquelle le produit se trouve encore en stock dans la variante cor­res­pon­dante. Une valeur négative signifie qu’il n’y a plus d’article cor­res­pon­dant en stock, mais que cette variante a tout de même été pré­com­man­dée. Si nous voulons vérifier quelle variante a le plus d’articles, nous utilisons ce code :

from collections import Counter
color_variations = Counter({'blue' : 2, 'gray' : -1, 'black' : 0})
most_articles = color_variations.most_common(1)
print(most_articles)

La sortie est alors celle-ci :

[('blue' : 2)]

Nous pouvons également afficher le plus petit nombre d’articles. Pour cela, nous modifions le code comme suit :

from collections import Counter
color_variations = Counter({'blue' : 2, 'gray' : -1, 'black' : 0})
fewest_items = color_variations.most_common ()[:-2:-1]
print(fewest_items)

La sortie cor­res­pon­dante :

[('gray' : -1)]

Calcul arith­mé­tique avec Python Counter

Les calculs arith­mé­tiques sont également possibles avec l’aide de Python Counter. Il est toutefois important de noter que seules les valeurs positives sont affichées. Nous essayons quelques types de calcul.

Une simple addition :

from collections import Counter
x = Counter(a=4, b=2, c=1)
y = Counter(a=2, b=1, c=2)
z = x + y
print(z)

Counter({'a' : 6, 'b' : 3, 'c' : 3})

Voici à quoi ressemble la sous­trac­tion :

from collections import Counter
x = Counter(a=4, b=2, c=1)
y = Counter(a=2, b=1, c=2)
z = x - y
print(z)

Counter({'a' : 2, 'b' : 1})

Comme la valeur de 'c' serait main­te­nant négative, elle n’est pas affichée.

Trier les types de données par fréquence

Une autre option que vous offre la classe est une énu­mé­ra­tion de types de données dans un dossier. Imaginons par exemple un dossier appelé « Images » qui contient de nombreux fichiers dif­fé­rents avec dif­fé­rents types de données. Pour une énu­mé­ra­tion, nous utilisons le code suivant :

import pathlib
from collections import Counter
folder_path = pathlib.Path("Images/")
extensions = [entry.suffix for entry in folder_path.iterdir() if entry.is_file()]]
extension_counter = Counter(extensions)
print(extension_counter)

Exclure les valeurs négatives et nulles

Pour éliminer les valeurs nulles ou négatives avec Python Counter, utilisez ce code :

from collections import Counter
valeurs = Counter(a=6, b=0, c=1, d=-4)
valeur = +values
print(values)

La sortie cor­res­pon­dante est alors celle-ci :

Counter({'a' : 6, 'c' : 1})