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 dictionnaire (Dictionary) dict qui, en combinaison avec différentes méthodes, a de nombreuses utilisations 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 différents éléments dans une liste et d’afficher la fréquence d’apparition de ces éléments. Il s’agit d’une sous-classe de Dictionary, la structure de données implémentée par la classe dict. Alors que cette tâche peut facilement être effectuée manuellement pour une courte succession de valeurs, elle est nettement plus compliqué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 particulier. Si vous souhaitez suivre la fréquence de plusieurs objets différents, utilisez un compteur distinct pour chaque objet.

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

Counter(list)

Dans les paragraphes 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 diffé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 différents : 'a', 'b' et 'c'. Pour savoir combien de fois chacun de ces éléments est contenu, nous appliquons Python Counter. La sortie ressemblerait 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 regroupement ordonné d’objets, l’ordre est pris en compte. Les objets sont placés entre parenthèses et séparés par des virgules. En consé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})

Utilisation dans un dictionnaire

Dans un dictionnaire, 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 Dictionary, ce dernier est transformé en un objet de type Hashtable. Les clés du Dictionary original deviennent les éléments, et leurs valeurs deviennent leurs fréquences. Pour notre exemple ci-dessus, cela pourrait ressembler à 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 combinaison avec une simple chaîne de caractères

Vous pouvez vous faire une idée du gain de temps et de la simplification du travail que peut offrir Python Counter en appliquant cette classe à une chaîne de caractères (string en anglais). Une chaîne de caractères est une suite de caractères marqués par des guillemets. Les espaces sont également pris en compte. Nous choisissons la chaîne de caractères suivante pour notre exemple :

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

Maintenant, chaque caractère est compté comme une sous-chaîne. La sortie pourrait donc ressembler à 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})

Extensions avec .update()

Python offre de nombreuses 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édemment, mais cette fois, nous n’isolons pas les chaînes de caractères séparé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 appliquons maintenant .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 actualisé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 possibilité d’accéder aux valeurs de Python Counter, car cette classe fonctionne de manière similaire à Dictionary. Dans l’exemple de code suivant, nous vous montrons quelques variations et les sorties correspondantes. Ici, les lettres (letters) fonctionnent 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 ressemblerait 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éterminer la plus grande accumulation avec most_common(n)

Avec most_common(n) pour Python Counter, vous pouvez déterminer quels éléments sont le plus et le moins souvent représentés. Prenons un exemple : un produit est listé dans différentes couleurs. À côté des couleurs est indiquée la fréquence à laquelle le produit se trouve encore en stock dans la variante correspondante. Une valeur négative signifie qu’il n’y a plus d’article correspondant en stock, mais que cette variante a tout de même été précommandé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 correspondante :

[('gray' : -1)]

Calcul arithmétique avec Python Counter

Les calculs arithmé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 soustraction :

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 maintenant 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 énumération de types de données dans un dossier. Imaginons par exemple un dossier appelé « Images » qui contient de nombreux fichiers différents avec différents types de données. Pour une énumération, 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 correspondante est alors celle-ci :

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