Skip to content

Python Counter : Compter et Dénombrer les Éléments avec collections.Counter

Soren Atelier
Name
Soren Atelier

Updated on

Compter les occurrences d'éléments dans une liste, de caractères dans une chaîne ou de mots dans un document est l'une des tâches les plus courantes en programmation. Le faire manuellement implique d'écrire des boucles, d'initialiser des dictionnaires et de gérer les clés manquantes avec des conditions ou des appels .get(). Ce code standard obscurcit votre intention réelle, introduit des bugs et vous ralentit chaque fois que vous avez besoin d'un comptage de fréquence.

collections.Counter de Python élimine entièrement cette friction. Il compte les objets hashables en une seule ligne, fournit des méthodes intégrées pour trouver les éléments les plus courants et supporte les opérations arithmétiques pour comparer les distributions de fréquence. Ce guide couvre tout ce dont vous avez besoin pour utiliser Counter efficacement, du comptage basique aux opérations avancées de multiensembles.

📚

    Qu'est-ce que collections.Counter ?

    Counter est une sous-classe de dictionnaire dans le module collections de Python conçue spécifiquement pour compter les objets hashables. Chaque élément est stocké comme clé de dictionnaire et son compte est stocké comme valeur correspondante.

    from collections import Counter
 
fruits = ['apple', 'banana', 'apple', 'cherry', 'banana', 'apple']
count = Counter(fruits)
print(count)
# Counter({'apple': 3, 'banana': 2, 'cherry': 1})

    Créer un Counter

    Counter accepte plusieurs types d'entrée, ce qui le rend flexible pour différentes sources de données.

    from collections import Counter
 
# À partir d'une liste
colors = Counter(['red', 'blue', 'red', 'green', 'blue', 'red'])
print(colors)  # Counter({'red': 3, 'blue': 2, 'green': 1})
 
# À partir d'une chaîne (compte chaque caractère)
letters = Counter('mississippi')
print(letters)  # Counter({'s': 4, 'i': 4, 'p': 2, 'm': 1})
 
# À partir d'un dictionnaire
inventory = Counter({'apples': 15, 'oranges': 10, 'bananas': 7})
 
# À partir d'arguments nommés
stock = Counter(laptops=5, monitors=12, keyboards=30)

    Accéder aux Comptes

    Indexation Basique

    Accédez aux comptes comme un dictionnaire régulier, mais les clés manquantes renvoient 0 au lieu de lever KeyError :

    from collections import Counter
 
c = Counter(['a', 'b', 'a'])
print(c['a'])  # 2
print(c['z'])  # 0 (pas de KeyError !)
 
# Comparer avec le comportement de dict régulier
d = {'a': 2, 'b': 1}
# d['z']  # Lèverait KeyError

    Ce comportement de zéro par défaut élimine le besoin de .get(key, 0) ou defaultdict(int) dans de nombreux scénarios de comptage.

    Obtenir Tous les Éléments

    La méthode elements() renvoie un itérateur sur les éléments, répétant chacun autant de fois que son compte :

    from collections import Counter
 
c = Counter(a=3, b=2, c=1)
print(list(c.elements()))
# ['a', 'a', 'a', 'b', 'b', 'c']

    La Méthode most_common()

    La méthode most_common() renvoie les éléments triés par fréquence.

    from collections import Counter
 
text = "to be or not to be that is the question"
word_freq = Counter(text.split())
 
# Tous les éléments triés par fréquence
print(word_freq.most_common())
# [('to', 2), ('be', 2), ('or', 1), ('not', 1), ...]
 
# Seulement les Top N éléments
log_levels = Counter(['INFO', 'WARNING', 'INFO', 'ERROR', 'INFO', 'DEBUG',
                      'WARNING', 'INFO', 'ERROR', 'INFO'])
print(log_levels.most_common(2))
# [('INFO', 5), ('WARNING', 2)]
 
# Les moins courants (slice inversé)
print(log_levels.most_common()[-2:])
# [('DEBUG', 1), ('ERROR', 2)]

    Opérations Arithmétiques sur Counter

    Counter supporte les opérations arithmétiques et ensemblistes pour combiner et comparer les distributions de fréquence.

    from collections import Counter
 
morning = Counter(coffee=10, tea=5, juice=3)
afternoon = Counter(coffee=8, tea=7, water=4)
 
# Addition : combine les comptes
total = morning + afternoon
print(total)  # Counter({'coffee': 18, 'tea': 12, 'water': 4, 'juice': 3})
 
# Soustraction : garde seulement les comptes positifs
stock = Counter(apples=20, oranges=15, bananas=10)
sold = Counter(apples=8, oranges=15, bananas=12)
remaining = stock - sold
print(remaining)  # Counter({'apples': 12})
 
# Intersection (&) : minimum des comptes correspondants
a = Counter(apple=3, banana=2, cherry=5)
b = Counter(apple=1, banana=4, cherry=2)
print(a & b)  # Counter({'cherry': 2, 'banana': 2, 'apple': 1})
 
# Union (|) : maximum des comptes correspondants
print(a | b)  # Counter({'cherry': 5, 'banana': 4, 'apple': 3})
 
# + unaire : supprime les comptes zéro et négatifs
c = Counter(a=3, b=0, c=-2)
print(+c)  # Counter({'a': 3})

    Mise à Jour et Soustraction

    from collections import Counter
 
# update() AJOUTE aux comptes (contrairement à dict.update qui remplace)
c = Counter(a=3, b=1)
c.update(['a', 'b', 'b', 'c'])
print(c)  # Counter({'a': 4, 'b': 3, 'c': 1})
 
# subtract() soustrait les comptes (garde zéro et négatifs)
c = Counter(a=4, b=2, c=0)
c.subtract(Counter(a=1, b=3, c=2))
print(c)  # Counter({'a': 3, 'b': -1, 'c': -2})
 
# total() renvoie la somme de tous les comptes (Python 3.10+)
inventory = Counter(widgets=50, gadgets=30, gizmos=20)
print(inventory.total())  # 100

    Cas d'Utilisation Pratiques

    Analyse de Fréquence de Mots

    from collections import Counter
import re
 
text = """
Python is a versatile programming language. Python is used for web development,
data science, machine learning, and automation. Python's simplicity makes it
a favorite among developers.
"""
 
words = re.findall(r'\b[a-z]+\b', text.lower())
word_freq = Counter(words)
 
print("Top 5 most frequent words:")
for word, count in word_freq.most_common(5):
    print(f"  {word}: {count}")

    Détection d'Anagrammes

    from collections import Counter
 
def are_anagrams(word1, word2):
    return Counter(word1.lower()) == Counter(word2.lower())
 
print(are_anagrams("listen", "silent"))  # True
print(are_anagrams("hello", "world"))    # False

    Système de Dépouillement de Votes

    from collections import Counter
 
votes = ['Alice', 'Bob', 'Alice', 'Charlie', 'Bob', 'Alice',
         'Charlie', 'Alice', 'Bob', 'Alice']
 
results = Counter(votes)
winner, winning_votes = results.most_common(1)[0]
total_votes = sum(results.values())
 
print(f"Election Results (Total votes: {total_votes}):")
for candidate, count in results.most_common():
    percentage = (count / total_votes) * 100
    print(f"  {candidate}: {count} votes ({percentage:.1f}%)")
print(f"\nWinner: {winner} with {winning_votes} votes")

    Analyse de Fichiers de Log

    from collections import Counter
import re
 
log_entries = [
    "2026-02-10 08:15:00 ERROR Database connection failed",
    "2026-02-10 08:15:01 INFO Retrying connection",
    "2026-02-10 08:15:02 ERROR Database connection failed",
    "2026-02-10 08:16:00 WARNING Disk usage at 85%",
    "2026-02-10 08:17:00 INFO Request processed",
    "2026-02-10 08:18:00 ERROR API timeout",
]
 
levels = Counter(
    re.search(r'(INFO|WARNING|ERROR)', line).group()
    for line in log_entries
)
print("Log Level Distribution:")
for level, count in levels.most_common():
    print(f"  {level}: {count}")

    Counter vs defaultdict(int) : Quand Utiliser Lequel

    CaractéristiqueCounterdefaultdict(int)
    ObjectifConçu spécifiquement pour compterDictionnaire avec valeur par défaut généraliste
    InitialisationCounter(iterable) compte en une étapeNécessite une boucle manuelle
    Clés manquantesRenvoie 0Renvoie 0
    most_common()Méthode intégréeTri manuel nécessaire
    Arithmétique (+, -)SupportéeNon supportée
    Opérations ensemblistes (&, |)SupportéesNon supportées
    elements()Renvoie un itérateur étenduNon disponible
    Comportement de update()Ajoute aux comptesRemplace les valeurs
    PerformanceImplémentation C optimiséeLégèrement plus lent
    Meilleur pourAnalyse de fréquence, ops multiensemblesLogique de valeur par défaut personnalisée

    Utilisez Counter quand votre objectif principal est de compter des éléments ou de comparer des distributions de fréquence. Utilisez defaultdict(int) quand le comptage est secondaire à un patron de structure de données plus large.

    Visualiser les Distributions de Fréquence

    Après avoir compté les éléments avec Counter, vous voudrez souvent visualiser la distribution. Pour l'exploration interactive des distributions de fréquence, PyGWalker (opens in a new tab) transforme un DataFrame pandas en une interface interactive de type Tableau directement dans Jupyter :

    from collections import Counter
import pandas as pd
import pygwalker as pyg
 
# Convertir Counter en DataFrame
data = Counter("abracadabra")
df = pd.DataFrame(data.items(), columns=['Character', 'Count'])
 
# Lancer la visualisation interactive
walker = pyg.walk(df)

    C'est particulièrement utile quand vous avez de grands compteurs et que vous voulez filtrer, trier et explorer les distributions de fréquence interactivement.

    FAQ

    Que fait collections.Counter en Python ?

    collections.Counter est une sous-classe de dictionnaire qui compte les objets hashables. Vous lui passez n'importe quel itérable et il renvoie un objet de type dictionnaire où les clés sont les éléments et les valeurs sont leurs comptes. Il fournit des méthodes comme most_common() pour l'analyse de fréquence, des opérateurs arithmétiques pour combiner les comptes et renvoie zéro pour les clés manquantes au lieu de lever un KeyError.

    Comment compter les occurrences d'éléments dans une liste avec Python Counter ?

    Importez Counter depuis collections et passez votre liste directement : Counter(['a', 'b', 'a', 'c']) renvoie Counter({'a': 2, 'b': 1, 'c': 1}). Pour obtenir des comptes spécifiques, indexez avec l'élément : counter['a'] renvoie 2. Pour les éléments les plus fréquents, utilisez counter.most_common(n).

    Quelle est la différence entre Counter et un dictionnaire régulier pour compter ?

    Counter est conçu spécifiquement pour compter : il compte un itérable entier en un seul appel, renvoie 0 pour les clés manquantes au lieu de KeyError, dispose de most_common() pour les fréquences triées, supporte les opérations arithmétiques (+, -, &, |) et inclut update() qui ajoute aux comptes plutôt que de les remplacer. Un dictionnaire régulier nécessite une construction manuelle de boucles et ne possède pas ces fonctionnalités.

    Peut-on soustraire ou additionner deux objets Counter ?

    Oui. L'opérateur + combine les comptes : Counter(a=3) + Counter(a=1) donne Counter({'a': 4}). L'opérateur - soustrait les comptes et supprime les résultats nuls ou négatifs. L'opérateur & donne le minimum (intersection) et | donne le maximum (union) des comptes correspondants. Pour une soustraction qui préserve les comptes négatifs, utilisez plutôt la méthode subtract().

    Python Counter est-il efficace pour les grands ensembles de données ?

    Oui. Counter est implémenté en code C optimisé dans CPython, ce qui le rend plus rapide que les boucles manuelles Python pour compter. Créer un Counter à partir d'un itérable est O(n). Accéder aux comptes individuels est O(1). L'opération most_common(k) utilise un tas internement pour une efficacité O(n log k) quand vous n'avez besoin que des top-k éléments.

    Conclusion

    collections.Counter de Python est l'outil standard pour compter les éléments et effectuer des analyses de fréquence. Il remplace le comptage manuel par dictionnaire par un seul appel au constructeur, fournit most_common() pour un classement instantané et supporte les opérations arithmétiques qui rendent les comparaisons de multiensembles triviales. Que vous analysiez des fréquences de mots, comptiez des votes, gériez un inventaire ou analysiez des fichiers de log, Counter gère le comptage pour que vous puissiez vous concentrer sur la logique qui compte.

    📚