# 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](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/python-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](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/tuples-en-python/), les dictionnaires et les [strings Python](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/python-string/). Sa syntaxe est la suivante :

```python
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 :

```python
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 :

```python
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 :

```python
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 :

```python
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 :

```python
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 :

```python
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 :

```python
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 :

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

Conseil Atteindre votre objectif en trois étapes seulement : avec [Deploy Now](https://www.ionos.fr/hebergement/deploy-now "Deploy Now » Déployez vos projets via GitHub | IONOS") de IONOS, vous connectez facilement votre dépôt, profitez de la configuration automatique du workflow et accédez ensuite à une infrastructure fiable. Profitez de nos tarifs adaptés et de notre expertise.

## 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 :

```python
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 :

```python
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 :

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

Notre sortie est alors celle-ci :

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

Si nous appliquons maintenant `.update()`, le code ressemble à ceci :

```python
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 :

```python
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*).

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

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

Voici à quoi ressemblerait un exemple avec la méthode `.keys()` :

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

Ceci est un exemple avec `.values()` :

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

Ceci est la méthode `.items()` :

```python
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` :

```python
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 :

```python
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 :

```python
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 :

```python
[('blue' : 2)]
```

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

```python
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 :

```python
[('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 :

```python
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)
```

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

Voici à quoi ressemble la soustraction :

```python
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)
```

```python
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 :

```python
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 :

```python
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 :

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

Conseil Dans notre Digital Guide, vous trouverez de nombreux autres articles sur ce langage de programmation populaire. Nous y expliquons par exemple quels sont les [opérateurs Python](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/operateurs-python/), nous vous guidons à travers l’[installation de Python](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/installer-python/) et nous vous montrons les principales [bases de Python et de précieux conseils](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/tutoriel-python/).


This is a markdown version of: [https://www.ionos.fr/digitalguide/sites-internet/developpement-web/python-counter/](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/python-counter/) for AI/LLM consumption.