Nombre de Python : Modèles modernes, pièges et exemples pratiques

Compter des éléments peut sembler anodin jusqu'à ce que les résultats s'écartent légèrement, voire considérablement, de la réalité. J'ai observé des vérifications de fréquence effectuées à l'aide d'appels répétés à la fonction ` list.count() ` ou de méthodes pandas utilisées de manière inappropriée qui ignorent silencieusement les valeurs manquantes. Le résultat : un code lent et des chiffres erronés. La solution consiste à utiliser l'outil approprié pour la tâche à accomplir : collections.Counter pour les cartes de fréquence, count() intégré pour les requêtes rapides à valeur unique et value_counts() de pandas lorsque vous êtes dans un DataFrame.

Qu'est-ce que le compteur et comment fonctionne-t-il ?

collections.Counter est une sous-classe de dictionnaire permettant de compter les objets hachables (un ensemble multiple). Vous pouvez créer un objet « Counter » à partir d'un itérable ou d'un mappage. Les clés manquantes sont définies par défaut sur 0 ; les comptes peuvent être incrémentés ou décrémentés ; et plusieurs méthodes pratiques simplifient les tâches courantes.

from collections import Counter

# From an iterable (one pass over the data)
nyc_eatery_types = [
    "Mobile Food Truck", "Food Cart", "Snack Bar", "Restaurant", "Food Cart",
    "Restaurant", "Mobile Food Truck", "Snack Bar", "Mobile Food Truck"
]
eatery_type_counts = Counter(nyc_eatery_types)
print(eatery_type_counts)  # dict-like view
print(eatery_type_counts["Restaurant"])  # missing keys return 0 instead of KeyError
print(eatery_type_counts["Kiosk"])Propulsé par

Counter({'Mobile Food Truck': 3, 'Food Cart': 2, 'Snack Bar': 2, 'Restaurant': 2})
2
0Propulsé par

Veuillez ne pas vous fier à l'ordre d'itération d'une méthode ` Counter`. Si vous avez besoin d'un affichage classé, veuillez utiliser most_common().

Trouver les valeurs les plus courantes avec most_common()

Counter.most_common(n) Renvoie une liste de paires d'(item, count) s par ordre décroissant de nombre d'occurrences. Veuillez fournir l'n e pour limiter le résultat, ou omettez-la pour obtenir toutes les paires.

top_3 = eatery_type_counts.most_common(3)
print(top_3)Propulsé par

[('Mobile Food Truck', 3), ('Food Cart', 2), ('Snack Bar', 2)]Propulsé par

Veuillez utiliser cette option lorsque vous avez besoin d'analyses de fréquence, de classements ou de vérifications rapides de la cohérence des données catégorielles.

Faites davantage avec Counter

mettre à jour et soustraire les comptes

Les données commerciales ont été modifiées. update() augmente les chiffres, tandis que subtract() les diminue. Les deux acceptent des itérables ou des mappages.

new_permits = ["Restaurant", "Food Cart", "Restaurant"]
eatery_type_counts.update(new_permits)  # add 1 for each occurrence
print(eatery_type_counts)

closures = {"Snack Bar": 1}
eatery_type_counts.subtract(closures)   # reduce counts (can go negative)
print(eatery_type_counts)Propulsé par

Counter({'Mobile Food Truck': 3, 'Restaurant': 4, 'Food Cart': 3, 'Snack Bar': 2})
Counter({'Restaurant': 4, 'Mobile Food Truck': 3, 'Food Cart': 3, 'Snack Bar': 1})Propulsé par

Si un compte atteint 0 ou moins, les méthodes telles que elements() et most_common() ne le prennent pas en compte. Pour supprimer complètement une clé, veuillez utiliser del counter[key].

calculer les totaux et le top-N

À partir de Python 3.10, la fonction ` Counter.total() ` renvoie la somme de tous les comptes. Ceci est utile lorsque vous avez besoin de proportions ou de parts.

total_permits = eatery_type_counts.total()
for eatery, count in eatery_type_counts.most_common(3):
    share = count / total_permits
    print(f"{eatery}: {count} ({share:.1%})")Propulsé par

Reconstruire des séquences avec elements()

elements() renvoie chaque élément autant de fois que son nombre. L'ordre est arbitraire.

expanded = list(eatery_type_counts.elements())
print(len(expanded), "items reconstructed from counts")Propulsé par

utiliser les opérations mathématiques et de type ensemble

Il est possible de combiner les compteurs avec des opérations arithmétiques et des opérations de type min/max. Les résultats ne prennent pas en compte les valeurs nulles et négatives.

from collections import Counter

a = Counter({"Food Cart": 5, "Restaurant": 2})
b = Counter({"Food Cart": 3, "Snack Bar": 4})

print(a + b)   # add counts
print(a - b)   # subtract (keeps positives only)
print(a & b)   # intersection: min of counts
print(a | b)   # union: max of countsPropulsé par

Counter({'Food Cart': 8, 'Snack Bar': 4, 'Restaurant': 2})
Counter({'Food Cart': 2, 'Restaurant': 2})
Counter({'Food Cart': 3})
Counter({'Food Cart': 5, 'Snack Bar': 4, 'Restaurant': 2})Propulsé par

Quand utiliser list.count(), Counter ou pandas

Veuillez sélectionner l'outil le plus simple qui répond à vos exigences et contraintes de performance.

vérifications de valeur unique avec count()

Utilisez la fonction intégrée ` count() ` lorsque vous souhaitez uniquement connaître le nombre d'occurrences d'une valeur dans une séquence ou le nombre de sous-chaînes non chevauchantes dans une chaîne.

numbers = [1, 2, 2, 3, 2]
print(numbers.count(2))  # 3

word = "banana"
print(word.count("a"))   # 3

text = "aaa"
print(text.count("aa"))  # 1: non-overlapping matches only
print("cat".count(""))   # 4: empty string counts len(s)+1 positionsPropulsé par

Veuillez faire attention aux booléens et aux entiers : True == 1 et False == 0. Cela peut augmenter les comptes si vous mélangez les types.

mixed = [1, True, 0, False, True]
print(mixed.count(1))  # 3 (counts 1 and True)
print(mixed.count(0))  # 2 (counts 0 and False)Propulsé par

Veuillez éviter d'appeler count() de manière répétée dans des boucles sur des données volumineuses ; chaque appel analyse l'intégralité de la séquence.

# Inefficient: O(n^2) for large lists
# freq = {x: numbers.count(x) for x in numbers}

# Efficient: one pass
from collections import Counter
freq = Counter(numbers)Propulsé par

fréquences multiples avec compteur

Lorsque vous avez besoin de compter de nombreuses valeurs uniques, veuillez créer une fois pour toutes une table de comptage ( Counter ) et interrogez-la selon vos besoins. Il est clair, rapide et conçu pour ce type d'utilisation.

Données tabulaires avec pandas

Dans Pandas, les fonctions ` DataFrame.count() ` et ` Series.count() ` calculent les nombres non manquants. Pour obtenir un tableau des valeurs de fréquence, veuillez utiliser Series.value_counts().

import pandas as pd
df = pd.DataFrame({
    "line": ["A", "A", "B", None, "B", "B"],
    "ridership": [100, None, 120, 130, None, 150],
})

print(df["line"].count())         # 5 (non-missing)
print(df["line"].value_counts())  # value frequencies

# For full row count, use len(df), not df.count()
print(len(df))                    # 6Propulsé par

Valider et nettoyer les données avec Counter

Avant de procéder à l'analyse, je vérifie la cohérence des catégories, les valeurs inattendues et les doublons. Counter permet d'effectuer ces vérifications rapidement et de manière reproductible.

from collections import Counter

# Example: validate allowed categories
allowed_types = {"Mobile Food Truck", "Food Cart", "Snack Bar", "Restaurant"}
type_counts = Counter(nyc_eatery_types)

unexpected = {t: c for t, c in type_counts.items() if t not in allowed_types}
if unexpected:
    print("Unexpected categories found:", unexpected)

# Example: flag duplicates (e.g., station IDs appearing more than once)
station_ids = ["ST-001", "ST-002", "ST-003", "ST-002", "ST-004", "ST-002"]
dup_counts = Counter(station_ids)
duplicates = [sid for sid, c in dup_counts.items() if c > 1]
print("Duplicate station IDs:", duplicates)Propulsé par

Remarques pratiques et erreurs courantes

Ces détails permettent de gagner du temps et d'éviter des erreurs subtiles.

• Counter est similaire à un dictionnaire : les clés manquantes renvoient 0 ; veuillez utiliser del counter[key] pour supprimer des entrées. Veuillez éviter de stocker des zéros, sauf si vous en avez besoin temporairement.

• Veuillez ne pas vous fier à l'ordre d'itération. Veuillez utiliser most_common() pour obtenir un classement.

• str.count() compte les correspondances non superposées. Pour compter les sous-chaînes qui se chevauchent, veuillez utiliser re.finditer().

• Veuillez éviter d'effectuer des appels répétés à la fonction ` list.count() ` sur la même séquence volumineuse. Veuillez plutôt créer un Counter.

• Dans Pandas, la fonction ` .count() ` est utilisée pour les comptes sans valeurs manquantes ; veuillez utiliser ` .value_counts() ` pour les fréquences de valeurs.

Les modèles minimaux sur lesquels je m'appuie

Ce sont les extraits que j'utilise le plus souvent dans la production et l'enseignement.

• Carte de fréquence à passage unique : Counter(iterable)

• Catégories Top-N : Counter(data).most_common(n)

• Mises à jour incrémentielles : counter.update(batch) ou counter.subtract(batch)

• Vérification d'une seule valeur : sequence.count(x) (à éviter dans les boucles)

• Fréquences tabulaires : df["col"].value_counts() (non df.count())

Conclusion

collections.Counter est l'outil idéal pour compter rapidement et clairement plusieurs valeurs. Veuillez utiliser la fonction intégrée count() pour les vérifications ponctuelles, Counter pour les cartes de fréquence et l'analyse top-N, et Series.value_counts() lorsque vous travaillez dans pandas. Veuillez prêter attention aux cas limites de comptage de chaînes, à l'équivalence entre les valeurs booléennes et les entiers, ainsi qu'à la différence entre les comptages sans valeur manquante et les fréquences de valeurs. Grâce à ces modèles, vos calculs seront à la fois rapides et précis.