La façon pythonique de compter les objets – Real Python

Construire des compteurs

Il y a plusieurs façons pour vous de créer Compteur instances. Cependant, si votre objectif est de compter plusieurs objets à la fois, vous devez alors utiliser une séquence ou un itérable pour initialiser le compteur. Par exemple, voici comment vous pouvez réécrire l'exemple du Mississippi en utilisant Compteur:

>>> de collections importer Compteur

>>> # Utiliser une chaîne comme argument
>>> Compteur("Mississippi")
Compteur('i' : 4, 's' : 4, 'p' : 2, 'm' : 1)

>>> # Utiliser une liste comme argument
>>> Compteur(liste("Mississippi"))
Compteur('i' : 4, 's' : 4, 'p' : 2, 'm' : 1)

Compteur itère sur "Mississippi" et produit un dictionnaire avec les lettres comme clés et leur fréquence comme valeurs. Dans le premier exemple, vous utilisez une chaîne comme argument pour Compteur. Vous pouvez également utiliser des listes, des tuples ou tout itérable avec des objets répétés, comme vous le voyez dans le deuxième exemple.

Il existe d'autres façons de créer Compteur instances. Cependant, ils n'impliquent pas strictement le comptage. Par exemple, vous pouvez utiliser un dictionnaire contenant des clés et des décomptes comme celui-ci :

>>> de collections importer Compteur

>>> Compteur("je": 4, "s": 4, "p": 2, "m": 1)
Compteur('i' : 4, 's' : 4, 'p' : 2, 'm' : 1)

Le compteur a maintenant un groupe initial de paires clé-compte. Cette façon de créer un Compteur instance est utile lorsque vous devez fournir les décomptes initiaux d'un groupe d'objets existant.

Vous pouvez également produire des résultats similaires en utilisant des arguments de mot-clé lorsque vous appelez le constructeur de la classe :

>>> de collections importer Compteur

>>> Compteur(je=4, s=4, p=2, m=1)
Compteur('i' : 4, 's' : 4, 'p' : 2, 'm' : 1)

Encore une fois, vous pouvez utiliser cette approche pour créer un Compteur objet avec un état initial spécifique pour ses paires clés et compteurs.

En pratique, si vous utilisez Compteur pour compter les choses à partir de zéro, vous n'avez pas besoin d'initialiser les comptes car ils ont une valeur nulle par défaut. Une autre possibilité pourrait être d'initialiser les comptes à 1. Dans ce cas, vous pouvez faire quelque chose comme ceci :

>>> de collections importer Compteur

>>> Compteur(ensemble("Mississippi"))
Compteur('p' : 1, 's' : 1, 'm' : 1, 'i' : 1)

Les ensembles Python stockent des objets uniques, donc l'appel à ensemble() dans cet exemple jette les lettres répétées. Après cela, vous vous retrouvez avec une instance de chaque lettre dans l'itérable d'origine.

Compteur hérite de l'interface des dictionnaires classiques. Cependant, il ne fournit pas une implémentation fonctionnelle de .fromkeys() pour éviter les ambiguïtés, comme Counter.fromkeys("mississippi", 2). Dans cet exemple spécifique, chaque lettre aurait un nombre par défaut de 2 malgré son nombre actuel d'occurrences dans l'itérable d'entrée.

Il n'y a aucune restriction sur les objets que vous pouvez stocker dans les clés et les valeurs d'un compteur. Les clés peuvent stocker des objets pouvant être hachés, tandis que les valeurs peuvent stocker n'importe quel objet. Cependant, pour fonctionner comme des compteurs, les valeurs doivent être des nombres entiers représentant des nombres.

Voici un exemple de Compteur instance qui contient des comptes négatifs et zéro :

>>> de collections importer Compteur

>>> inventaire = Compteur(
...     Pomme=dix,
...     Orange=15,
...     banane=0,
...     tomate=-15
... )

Dans cet exemple, vous pouvez demander : « Pourquoi ai-je -15 tomates?" Eh bien, cela pourrait être une convention interne pour signaler que vous avez la commande d'un client pour 15 tomates, et vous n'en avez pas dans votre inventaire actuel. Qui sait? Compteur vous permet de le faire, et vous pouvez probablement trouver quelques cas d'utilisation pour la fonctionnalité.

Mise à jour du nombre d'objets

Une fois que vous avez un Compteur instance en place, vous pouvez utiliser .mettre à jour() pour le mettre à jour avec de nouveaux objets et comptes. Plutôt que de remplacer des valeurs comme sa dict contrepartie, le .mettre à jour() mise en œuvre assurée par Compteur ajoute les comptes existants ensemble. Il crée également de nouvelles paires de clés si nécessaire.

Vous pouvez utiliser .mettre à jour() avec à la fois des itérables et des mappages de comptes comme arguments. Si vous utilisez un itérable, la méthode compte ses éléments et met à jour le compteur en conséquence :

>>> de collections importer Compteur

>>> des lettres = Compteur("je": 4, "s": 4, "p": 2, "m": 1)

>>> des lettres.mettre à jour("Missouri")
>>> des lettres
Compteur('i' : 6, 's' : 6, 'p' : 2, 'm' : 2, 'o' : 1, 'u' : 1, 'r' : 1)

Maintenant vous avez 6 cas de je, 6 cas de s, etc. Vous avez également de nouvelles paires de clés, telles que 'o' : 1, 'u' : 1, et 'r' : 1. Notez que l'itérable doit être une séquence d'éléments plutôt qu'une séquence de (clé, compter) paires.

>>> de collections importer Compteur

>>> des lettres = Compteur("je": "4", "s": "4", "p": "2", "m": "1")

>>> des lettres.mettre à jour("Missouri")
Traceback (appel le plus récent en dernier) :
  ...
Erreur-type: ne peut concaténer que str (pas "int") en str

La deuxième façon d'utiliser .mettre à jour() est de fournir un autre compteur ou un mappage de comptes comme argument. Dans ce cas, vous pouvez faire quelque chose comme ceci :

>>> de collections importer Compteur
>>> Ventes = Compteur(Pomme=25, Orange=15, banane=12)

>>> # Utiliser un compteur
>>> lundi_ventes = Compteur(Pomme=dix, Orange=8, banane=3)
>>> Ventes.mettre à jour(lundi_ventes)
>>> Ventes
Compteur('pomme': 35, 'orange': 23, 'banane': 15)

>>> # Utilisez un dictionnaire de comptes
>>> mardi_ventes = "Pomme": 4, "Orange": 7, "tomate": 4
>>> Ventes.mettre à jour(mardi_ventes)
>>> Ventes
Compteur('pomme': 39, 'orange': 30, 'banane': 15, 'tomate': 4)

Dans le premier exemple, vous mettez à jour un compteur existant, Ventes, en utilisant un autre compteur, lundi_ventes. Notez comment .mettre à jour() ajoute le compte des deux compteurs.

Ensuite, vous utilisez un dictionnaire régulier contenant des éléments et des comptes. Dans ce cas, .mettre à jour() ajoute le nombre de clés existantes et crée les paires de clés manquantes.

Accéder au contenu du compteur

Comme tu le sais déjà, Compteur a presque la même interface que dict. Vous pouvez effectuer presque les mêmes actions avec les compteurs qu'avec les dictionnaires standard. Par exemple, vous pouvez accéder à leurs valeurs à l'aide d'une clé de type dictionnaire ([key]). Vous pouvez également parcourir les clés, les valeurs et les éléments en utilisant les techniques et méthodes habituelles :

>>> de collections importer Compteur

>>> des lettres = Compteur("Mississippi")
>>> des lettres[[[["p"]
2
>>> des lettres[[[["s"]
4

>>> pour lettre dans des lettres:
...     imprimer(lettre, des lettres[[[[lettre])
...
m 1
je 4
s 4
p 2

>>> pour lettre dans des lettres.clés():
...     imprimer(lettre, des lettres[[[[lettre])
...
m 1
je 4
s 4
p 2

>>> pour compter dans des lettres.valeurs():
...     imprimer(compter)
...
1
4
4
2

>>> pour lettre, compter dans des lettres.éléments():
...     imprimer(lettre, compter)
...
m 1
je 4
s 4
p 2

Dans ces exemples, vous accédez et parcourez les clés (lettres) et les valeurs (comptes) de votre compteur à l'aide de l'interface de dictionnaire familière, qui comprend des méthodes telles que .clés(), .valeurs(), et .éléments().

Un dernier point à noter sur Compteur est que si vous essayez d'accéder à une clé manquante, vous obtenez zéro au lieu d'un KeyError:

>>> de collections importer Compteur

>>> des lettres = Compteur("Mississippi")
>>> des lettres[[[["une"]
0

Depuis la lettre "une" n'apparaît pas dans la chaîne "Mississippi", le compteur retourne 0 lorsque vous essayez d'accéder au nombre de cette lettre.

Trouver les objets les plus courants

Si vous devez répertorier un groupe d'objets en fonction de leur fréquence ou du nombre de fois où ils apparaissent, vous pouvez utiliser .Le plus commun(). Cette méthode renvoie une liste de (objet, compte) triés par le nombre actuel d'objets. Les objets avec des nombres égaux viennent dans l'ordre où ils apparaissent pour la première fois.

Si vous fournissez un nombre entier m comme argument pour .Le plus commun(), alors vous obtenez le m objets les plus courants. Si vous omettez m ou réglez-le sur Rien, ensuite .Le plus commun() renvoie tous les objets du compteur :

>>> de collections importer Compteur
>>> Ventes = Compteur(banane=15, tomate=4, Pomme=39, Orange=30)

>>> # L'objet le plus courant
>>> Ventes.Le plus commun(1)
[('apple', 39)]

>>> # Les deux objets les plus courants
>>> Ventes.Le plus commun(2)
[('apple', 39), ('orange', 30)]

>>> # Tous les objets triés par nombre
>>> Ventes.Le plus commun()
[('apple', 39), ('orange', 30), ('banana', 15), ('tomato', 4)]

>>> Ventes.Le plus commun(Rien)
[('apple', 39), ('orange', 30), ('banana', 15), ('tomato', 4)]

>>> Ventes.Le plus commun(20)
[('apple', 39), ('orange', 30), ('banana', 15), ('tomato', 4)]

Dans ces exemples, vous utilisez .Le plus commun() pour récupérer les objets les plus fréquents dans Ventes. Sans argument ou avec Rien, la méthode renvoie tous les objets. Si l'argument de .Le plus commun() est supérieure à la longueur du compteur actuel, alors vous obtenez à nouveau tous les objets.

Vous pouvez également obtenir les objets les moins courants en découpant le résultat de .Le plus commun():

>>> de collections importer Compteur
>>> Ventes = Compteur(banane=15, tomate=4, Pomme=39, Orange=30)

>>> # Tous les objets dans l'ordre inverse
>>> Ventes.Le plus commun()[::[::[::[::-1]
[('tomato', 4), ('banana', 15), ('orange', 30), ('apple', 39)]

>>> # Les deux objets les moins communs
>>> Ventes.Le plus commun()[:[:[:[:-3:-1]
[('tomato', 4), ('banana', 15)]

La première tranche, [::-1], renvoie tous les objets dans Ventes dans l'ordre inverse selon leur nombre respectif. Le tranchage [:-3:-1] extrait les deux derniers objets du résultat de .Le plus commun(). Vous pouvez modifier le nombre d'objets les moins courants que vous obtenez en modifiant la deuxième valeur de décalage dans l'opérateur de découpage. Par exemple, pour obtenir les trois objets les moins fréquents, vous pouvez modifier -3 à -4, etc.

Si tu veux .Le plus commun() pour fonctionner correctement, alors assurez-vous que les valeurs de vos compteurs sont triables. C'est quelque chose à garder à l'esprit car, comme mentionné, vous pouvez stocker n'importe quel type de données dans un compteur.

Compter les lettres dans un fichier texte

Supposons que vous ayez un fichier contenant du texte. Vous devez compter le nombre de fois où chaque lettre apparaît dans le texte. Par exemple, supposons que vous ayez un fichier appelé pyzen.txt avec le contenu suivant :

Le Zen de Python, par Tim Peters

Beau vaut mieux que laid.
Explicite vaut mieux qu'implicite.
Simple vaut mieux que complexe.
Complexe vaut mieux que compliqué.
Plat est mieux que imbriqué.
Mieux vaut clairsemé que dense.
La lisibilité compte.
Les cas particuliers ne sont pas assez particuliers pour enfreindre les règles.
Bien que la praticité bat la pureté.
Les erreurs ne doivent jamais passer en silence.
À moins d'être explicitement réduit au silence.
Face à l'ambiguïté, refusez la tentation de deviner.
Il devrait y avoir une - et de préférence une seule - manière évidente de le faire.
Bien que cela ne soit pas évident au début, à moins que vous ne soyez néerlandais.
C'est mieux que jamais.
Bien que jamais ne soit souvent mieux que *en ce moment*.
Si la mise en œuvre est difficile à expliquer, c'est une mauvaise idée.
Si la mise en œuvre est facile à expliquer, cela peut être une bonne idée.
Les espaces de noms sont une excellente idée – faisons-en plus !

Oui, c'est The Zen of Python, une liste de principes directeurs qui définissent la philosophie de base derrière la conception de Python. Pour compter le nombre de fois où chaque lettre apparaît dans ce texte, vous pouvez profiter de Compteur et écrivez une fonction comme celle-ci :

    1# lettres.py
    2
    3de collections importer Compteur
    4
    5déf count_lettres(nom de fichier):
    6    compteur_lettres = Compteur()
    7    avec ouvert(nom de fichier) comme déposer:
    8        pour ligne dans déposer:
    9            lignes_lettres = [[[[
dix                carboniser pour carboniser dans ligne.plus bas() si carboniser.isalpha()
11            ]
12            compteur_lettres.mettre à jour(Compteur(lignes_lettres))
13    revenir compteur_lettres

Voici comment fonctionne ce code :

• Ligne 5 définit count_lettres(). Cette fonction prend un chemin de fichier basé sur une chaîne comme argument.
• Ligne 6 crée un compteur vide pour compter les lettres dans le texte cible.
• Ligne 7 ouvre le fichier d'entrée pour la lecture et crée un itérateur sur le contenu du fichier.
• Ligne 8 démarre une boucle qui parcourt le contenu du fichier ligne par ligne.
• Lignes 9 à 11 définir une compréhension de liste pour exclure les caractères non alphabétiques de la ligne actuelle en utilisant .isalpha(). La compréhension met les lettres en minuscules avant de les filtrer pour éviter d'avoir des décomptes séparés des minuscules et des majuscules.
• Ligne 12 appels .mettre à jour() sur le compteur de lettres pour mettre à jour le décompte de chaque lettre.

Utiliser count_lettres(), vous pouvez faire quelque chose comme ceci :

>>> de des lettres importer count_lettres
>>> compteur_lettres = count_lettres("pyzen.txt")

>>> pour lettre, compter dans compteur_lettres.éléments():
...     imprimer(lettre, "->", compter)
...
t -> 79
h -> 31
e -> 92
z -> 1
        ...
k -> 2
v -> 5
w -> 4

>>> pour lettre, compter dans compteur_lettres.Le plus commun(5):
...     imprimer(lettre, "->", compter)
...
e -> 92
t -> 79
je -> 53
un -> 53
s -> 46

Génial! Votre code compte la fréquence de chaque lettre dans un fichier texte donné. Les linguistes utilisent souvent la fréquence des lettres pour l'identification de la langue. En anglais, par exemple, des études sur la fréquence moyenne des lettres ont révélé que les cinq lettres les plus courantes sont « e », « t », « a », « o » et « i ». Wow! Cela correspond presque à vos résultats !

Tracer des données catégorielles avec des graphiques à barres ASCII

Les statistiques sont un autre domaine dans lequel vous pouvez utiliser Compteur. Par exemple, lorsque vous travaillez avec des données catégorielles, vous souhaiterez peut-être créer des graphiques à barres pour visualiser le nombre d'observations par catégorie. Les graphiques à barres sont particulièrement utiles pour tracer ce type de données.

Supposons maintenant que vous souhaitiez créer une fonction qui vous permette de créer un graphique à barres ASCII sur votre terminal. Pour ce faire, vous pouvez utiliser le code suivant :

# bar_chart.py

de collections importer Compteur

déf print_ascii_bar_chart(Les données, symbole="#"):
    compteur = Compteur(Les données).Le plus commun()
    graphique = Catégorie: symbole * la fréquence pour Catégorie, la fréquence dans compteur
    max_len = max(longueur(Catégorie) pour Catégorie dans graphique)
    pour Catégorie, la fréquence dans graphique.éléments():
        rembourrage = (max_len - longueur(Catégorie)) * " "
        imprimer(F"Catégorierembourrage    |la fréquence")

Dans cet exemple, print_ascii_bar_chart() prend un certain catégorique Les données, compte le nombre de fois où chaque catégorie unique apparaît dans les données (la fréquence) et génère un graphique à barres ASCII qui reflète cette fréquence.

Voici comment vous pouvez utiliser cette fonction :

>>> de diagramme à bandes importer print_ascii_bar_chart

>>> des lettres = "mississippimississippimississippimississippi"
>>> print_ascii_bar_chart(des lettres)
je |################
s |##################
p |########
m |####

>>> de collections importer Compteur
>>> Ventes = Compteur(banane=15, tomate=4, Pomme=39, Orange=30)

>>> print_ascii_bar_chart(Ventes, symbole="+")
pomme |++++++++++++++++++++++++++++++++++++++
orange |++++++++++++++++++++++++++++++++
banane |++++++++++++++++
tomate |++++

Le premier appel à print_ascii_bar_chart() trace la fréquence de chaque lettre dans la chaîne d'entrée. Le deuxième appel trace les ventes par fruit. Dans ce cas, vous utilisez un compteur comme entrée. Notez également que vous pouvez utiliser symbole pour changer le caractère des barres.

Lorsque vous créez des graphiques à barres, l'utilisation de barres horizontales vous permet d'avoir suffisamment de place pour les étiquettes de catégorie. Une autre caractéristique utile des graphiques à barres est la possibilité de trier les données en fonction de leur fréquence. Dans cet exemple, vous triez les données en utilisant .Le plus commun().

Tracer des données catégorielles avec Matplotlib

C'est bien de savoir comment créer des graphiques à barres ASCII à partir de zéro en utilisant Python. Cependant, dans l'écosystème Python, vous pouvez trouver plusieurs outils pour tracer des données. L'un de ces outils est Matplotlib.

Matplotlib est une bibliothèque tierce permettant de créer des visualisations statiques, animées et interactives en Python. Vous pouvez installer la bibliothèque à partir de PyPI en utilisant pépin comme d'habitude:

$ python -m pip installer matplotlib

Cette commande installe Matplotlib dans votre environnement Python. Une fois que vous avez installé la bibliothèque, vous pouvez l'utiliser pour créer vos graphiques à barres et plus encore. Voici comment créer un graphique à barres minimal avec Matplotlib :

>>> de collections importer Compteur
>>> importer matplotlib.pyplot comme plt

>>> Ventes = Compteur(banane=15, tomate=4, Pomme=39, Orange=30).Le plus commun()
>>> X, oui = Zip *: français(*Ventes)
>>> X
("pomme", "orange", "banane", "tomate")
>>> oui
(39, 30, 15, 4)

>>> plt.bar(X, oui)

>>> plt.spectacle()

Ici, vous effectuez d'abord les importations requises. Ensuite, vous créez un compteur avec des données initiales sur les ventes et l'utilisation des fruits .Le plus commun() pour trier les données.

Tu utilises Zip *: français() pour décompresser le contenu de Ventes en deux variables :

1. X détient une liste de fruits.
2. oui détient les unités correspondantes vendues par fruit.

Ensuite, vous créez un graphique à barres en utilisant plt.bar(). Quand tu cours plt.show(), vous obtenez une fenêtre comme la suivante sur votre écran :

Dans ce graphique, l'axe horizontal montre le nom de chaque fruit unique. Pendant ce temps, l'axe vertical indique le nombre d'unités vendues par fruit.

Trouver le mode d'un échantillon

En statistique, le mode est la valeur (ou les valeurs) la plus fréquente dans un échantillon de données. Par exemple, si vous avez l'échantillon [2, 1, 2, 2, 3, 5, 3], alors le mode est 2 car il apparaît le plus souvent.

Dans certains cas, le mode n'est pas une valeur unique. Considérez l'échantillon [2, 1, 2, 2, 3, 5, 3, 3]. Ici vous avez deux modes, 2 et 3, car les deux apparaissent le même nombre de fois.

Vous utiliserez souvent le mode pour décrire des données catégorielles. Par exemple, le mode est utile lorsque vous avez besoin de savoir quelle catégorie est la plus courante dans vos données.

Pour trouver le mode avec Python, vous devez compter le nombre d'occurrences de chaque valeur dans votre échantillon. Ensuite, vous devez trouver la valeur (ou les valeurs) la plus fréquente. En d'autres termes, la valeur avec le plus grand nombre d'occurrences. Cela ressemble à quelque chose que vous pouvez faire en utilisant Compteur et .Le plus commun().

Voici une fonction qui calcule le mode d'un échantillon :

# mode.py

de collections importer Compteur

déf mode(Les données):
    compteur = Compteur(Les données)
    _, top_count = compteur.Le plus commun(1)[[[[0]
    revenir [[[[point pour point, compter dans compteur.éléments() si compter == top_count]

À l'intérieur mode(), vous comptez d'abord le nombre de fois où chaque observation apparaît dans l'entrée Les données. Ensuite, vous utilisez .most_common(1) pour obtenir la fréquence de l'observation la plus courante. Depuis .Le plus commun() renvoie une liste de tuples sous la forme (pointer, compter), vous devez récupérer le tuple à l'index 0, qui est le plus courant dans la liste. Ensuite, vous décompressez le tuple en deux variables :

1. _ détient l'objet le plus commun. L'utilisation d'un trait de soulignement pour nommer une variable suggère que vous n'avez pas besoin d'utiliser cette variable dans votre code, mais vous en avez besoin comme espace réservé.
2. top_count détient la fréquence de l'objet le plus commun dans Les données.

La compréhension de liste compare les compter de chaque objet avec le décompte du plus commun, top_count. Cela vous permet d'identifier plusieurs modes dans un échantillon donné.

Pour utiliser cette fonction, vous pouvez faire quelque chose comme ceci :

>>> de collections importer Compteur
>>> de mode importer mode

>>> # Mode unique, données numériques
>>> mode([[[[2, 1, 2, 2, 3, 5, 3])
[2]

>>> # Modes multiples, données numériques
>>> mode([[[[2, 1, 2, 2, 3, 5, 3, 3])
[2, 3]

>>> # Mode unique, données catégorielles
>>> Les données = [[[[
...     "Pomme",
...     "Orange",
...     "Pomme",
...     "Pomme",
...     "Orange",
...     "banane",
...     "banane",
...     "banane",
...     "Pomme",
... ]

>>> mode(Les données)
['apple']

>>> # Modes multiples, données catégorielles
>>> mode(Compteur(Pomme=4, Orange=4, banane=2))
['apple', 'orange']

Votre mode() travaux! Il trouve le mode des données numériques et catégorielles. Il fonctionne également avec des échantillons monomodes et multimodes. La plupart du temps, vos données viendront dans une séquence de valeurs. Cependant, le dernier exemple montre que vous pouvez également utiliser un compteur pour fournir les données d'entrée.

Comptage de fichiers par type

Un autre exemple intéressant concernant Compteur consiste à compter les fichiers dans un répertoire donné, en les regroupant par extension de fichier ou type de fichier. Pour ce faire, vous pouvez profiter de pathlib:

>>> importer pathlib
>>> de collections importer Compteur

>>> entrées = pathlib.Chemin("Des photos/").iterdir()
>>> rallonges = [[[[entrée.suffixe pour entrée dans entrées si entrée.est_fichier()]
['.gif', '.png', '.jpeg', '.png', '.png', ..., '.png']

>>> Compteur(rallonges)
Compteur('.png': 50, '.jpg': 11, '.gif': 10, '.jpeg': 9, '.mp4': 9)

Dans cet exemple, vous créez d'abord un itérateur sur les entrées d'un répertoire donné en utilisant Chemin.iterdir(). Ensuite, vous utilisez une compréhension de liste pour construire une liste contenant les extensions (.suffixe) de tous les fichiers du répertoire cible. Enfin, vous comptez le nombre de fichiers en utilisant l'extension de fichier comme critère de regroupement.

Si vous exécutez ce code sur votre ordinateur, vous obtiendrez une sortie différente en fonction du contenu de votre Des photos/ répertoire, s'il existe. Ainsi, vous devrez probablement utiliser un autre répertoire d'entrée pour que ce code fonctionne.

Restoring Elements From a Counter

The first multiset feature of Counter that you’re going to learn about is .elements(). This method returns an iterator over the elements in a multiset (Counter instance), repeating each of them as many times as its count says:

>>> de collections importer Counter

>>> for letter dans Counter("mississippi").elements():
...     imprimer(letter)
...
m
je
je
je
je
s
s
s
s
p
p

The net effect of calling .elements() on a counter is to restore the original data you used to create the counter itself. The method returns the elements—letters in this example—in the same order they first appear in the underlying counter. Since Python 3.7, Counter remembers the insertion order of its keys as a feature inherited from dict.

The docstring of .elements() in the source code file provides an interesting example of using this method to compute a number from its prime factors. Since a given prime factor may occur more than once, you might end up with a multiset. For example, you can express the number 1836 as the product of its prime factors like this:

1836 = 2 × 2 × 3 × 3 × 3 × 17 = 2² × 3³ × 17¹

You can write this expression as a multiset like 2, 2, 3, 3, 3, 17. Using a Python’s Counter, you’ll have Counter(2: 2, 3: 3, 17: 1). Once you have this counter in place, you can compute the original number using its prime factors:

>>> de collections importer Counter

>>> # Prime factors of 1836
>>> prime_factors = Counter(2: 2, 3: 3, 17: 1)
>>> product = 1

>>> for factor dans prime_factors.elements():
...     product *= factor
...

>>> product
1836

The loop iterates over the elements in prime_factors and multiplies them to compute the original number, 1836. If you’re using Python 3.8 or beyond, then you can use prod() de math to get a similar result. This function calculates the product of all elements in the input iterable:

>>> importer math
>>> de collections importer Counter

>>> prime_factors = Counter(2: 2, 3: 3, 17: 1)
>>> math.prod(prime_factors.elements())
1836

In this example, the call to .elements() restores the prime factors. Puis math.prod() computes 1836 from them in one go, which saves you from writing a loop and from having a few intermediate variables.

Using .elements() provides a way to restore the original input data. Its only drawback is that, in most cases, the order of items in the input won’t match the order in the output:

>>> de collections importer Counter

>>> "".rejoindre(Counter("mississippi").elements())
'miiiisssspp'

In this example, the resulting string doesn’t spell the original word, mississippi. However, it has the same content in terms of letters.

Subtracting the Elements’ Multiplicity

Sometimes you need to subtract the multiplicity (count) of the elements in a multiset or counter. In that case, you can use .subtract(). As its name implies, this method subtracts the counts supplied in an iterable or mapping from the counts in the target counter.

Say you have a multiset with your current fruit inventory and you need to keep it up to date. Then you can run some of the following operations:

>>> de collections importer Counter

>>> inventory = Counter(apple=39, Orange=30, banana=15)

>>> # Use a counter
>>> wastage = Counter(apple=6, Orange=5, banana=8)
>>> inventory.subtract(wastage)
>>> inventory
Counter('apple': 33, 'orange': 25, 'banana': 7)

>>> # Use a mapping of counts
>>> order_1 = "apple": 12, "orange": 12
>>> inventory.subtract(order_1)
>>> inventory
Counter('apple': 21, 'orange': 13, 'banana': 7)

>>> # Use an iterable
>>> order_2 = [[[["apple", "apple", "apple", "apple", "banana", "banana"]
>>> inventory.subtract(order_2)
>>> inventory
Counter('apple': 17, 'orange': 13, 'banana': 5)

Here, you use several ways to provide the input data to .subtract(). In all cases, you update the counts of each unique object by subtracting the counts provided in the input data. You can think of .subtract() as the counterpart of .update().

Doing Arithmetic With Elements’ Multiplicity

With .subtract() et .update(), you can combine counters by subtracting and adding corresponding element counts. Alternatively, Python provides handy operators for addition (+) and subtraction (-) of element counts, as well as operators for intersection (&) and union (|). le intersection operator returns the minimum of corresponding counts, while the union operator returns the maximum of counts.

Here are a few examples of how all these operators work:

>>> de collections importer Counter

>>> # Fruit sold per day
>>> sales_day1 = Counter(apple=4, Orange=9, banana=4)
>>> sales_day2 = Counter(apple=dix, Orange=8, banana=6)

>>> # Total sales
>>> sales_day1 + sales_day2
Counter('orange': 17, 'apple': 14, 'banana': 10)

>>> # Sales increment
>>> sales_day2 - sales_day1
Counter('apple': 6, 'banana': 2)

>>> # Minimum sales
>>> sales_day1 & sales_day2
Counter('orange': 8, 'apple': 4, 'banana': 4)

>>> # Maximum sales
>>> sales_day1 | sales_day2
Counter('apple': 10, 'orange': 9, 'banana': 6)

Here, you first add two counters together using the addition operator (+). The resulting counter contains the same keys (elements), while their respective values (multiplicities) hold the sum of counts from both involved counters.

The second example shows how the subtraction operator (-) works. Note that negative and zero counts result in not including the key-count pair in the resulting counter. So, you don’t see Orange in the output because 8 – 9 = -1.

The intersection operator (&) extracts the objects with lower counts from both counters, whereas the union operator (|) returns the objects with higher counts from both involved counters.

Counter also supports some unary operations. For example, you can get the items with positive and negative counts using the plus (+) and minus (-) signs, respectively:

>>> de collections importer Counter

>>> compteur = Counter(une=2, b=-4, c=0)

>>> +compteur
Counter('a': 2)

>>> -compteur
Counter('b': 4)

When you use the plus sign (+) as a unary operator on an existing counter, you get all the objects whose counts are greater than zero. On the other hand, if you use the minus sign (-), you get the objects with negative counts. Note that the result excludes objects whose counts are equal to zero in both cases.