En Python, la librairie Pandas est incontournable pour les ingénieurs en données. Cette librairie offre un cadre simple et efficace pour transformer, manipuler et traiter les données.

Parmi les opérations usuelles, celle de compter les valeurs uniques dans une Series Pandas et de déterminer leur fréquence. La librairie Pandas offre la fonction value_counts() pour faire ce comptage de valeurs uniques dans une Series. Le comptage peut retourner le nombre de chaque valeur de façon absolue, de façon relative ou encore par intervalle. La prise en compte des valeurs Null est contrôlable ainsi que le tri par valeurs du résultats de ces comptages.

Nous allons aborder et illustrer les différentes options offertes par cette méthode dans cet article.

Cet article fait parti d’un ensemble d’article sur les utilisations avancées en Pandas.

Syntaxe générale

La syntaxe générale de la méthode value_counts() appliquée sur une Series Pandas se présente sous la forme :

Series.value_counts(normalize=False, 
                    sort=True, 
                    ascending=False, 
                    bins=None, 
                    dropna=True)

La description des paramètres est la suivante :

Paramètre	Description	Valeur par défaut
normalize	Retourne la valeur relative de chaque valeur unique	False
sort	Tri selon la fréquence de la valeur	True
ascending	Tri selon l’ordre croissant	False
bins	Calcul la fréquence de valeur par intervalle	optionnel
dropna	Permet d’exclure les valeurs NaN	True

Données Tests

Pour illustrer cette article, nous allons construire un DataFrame. Ce DataFrame est constitué des notes de 1 à 5 données pour certaines villes. Voici comment construire ce DataFrame utilisé pour montrer l’utilisation des différentes options de la méthode value_counts() :

import random
import pandas as pd

villes = ['Paris']*3 + ['New York']*5 + ['Montreal']*10 + [pd.NA]*4 + ['Milan']*1

notes = [random.randint(1, 5) for i in range(villes.size)]

df = pd.DataFrame({'Ville': villes, 'Note': notes})

Ce DataFrame est constitué de 23 lignes dont voici les 5 premières lignes :

| Ville    |   Note |
|----------|--------|
| Paris    |      4 |
| Paris    |      5 |
| Paris    |      1 |
| New York |      3 |
| New York |      2 |

Utilisation des valeurs par défaut

Dans cet exemple, nous allons compter la fréquence d’apparition de chaque élément unique dans la colonne ‘Ville’. Utilisons la méthode value_counts() sans préciser de paramètres et donc utiliser leur valeur par défauts :

print(df['Ville'].value_counts())

Le résultat de la méthode value_counts() est une Series Pandas avec comme index les éléments uniques de la Series sur laquelle la méthode a été appliquée :

Montreal    10
New York     5
Paris        3
Milan        1
dtype: int64

Ainsi en utilisant l’index, il est possible d’accéder à la fréquence d’un élément de la façon suivante :

# Fréquence de la valeur 'Montreal'
print(f"Fréquence de la ville de Montréal : {df['Ville'].value_counts()['Montreal']}")

Dans ce cas, la fréquence de la ville de « Montréal » est renvoyée :

Fréquence de la ville de Montréal : 10

Tri sur les fréquences et l’index

Il est possible de trier le résultat en utilisant les paramètres sort et ascending qui par défaut ont les valeurs True et False. Il suffit de jouer avec ces deux paramètres pour changer la façon dont le résultat sera trié. Par exemple, pour trier dans l’ordre croissant des fréquences des éléments dans la Series, il faut mettre le paramètre ascending à True de la façon suivante :

print(df['Ville'].value_counts(ascending=True))

Milan        1
Paris        3
New York     5
Montreal    10
Name: Ville, dtype: int64

Nous voyons que dorénavant les villes sont triées dans l’ordre croissant de leur fréquences.

Nous avons vu que la méthode value_counts() permet de trier le résultat du comptage sur une Series. Il est également intéressant de vouloir trier le résultat selon l’ordre de l’index du résultat de la méthode value_counts(). Pour cela, il faut appliquer la méthode sort_index() sur le résultat. Par exemple, si nous souhaitons trier le résultat par ordre croissant du nom de la ville :

print(df['Ville'].value_counts().sort_index(ascending=True))

Milan        1
Montreal    10
New York     5
Paris        3
Name: Ville, dtype: int64

Nous voyons que cette fois le résultat est bien trié selon l’ordre alphabétique croissant de l’index du résultat.

Calcul des fréquences en pourcentage

Jusqu’à présent, nous avons vu comment il est possible de calculer les fréquences de chaque élément d’une Series. Avec le paramètre normalize, il est également possible d’obtenir les fréquences en pourcentage. Pour cela, il faut mettre la valeur de ce paramètre à True comme ceci :

print(villes.value_counts(normalize=True))

Montreal    0.526316
New York    0.263158
Paris       0.157895
Milan       0.052632
Name: Ville, dtype: float64

Nous obtenons donc la proportion de chaque élément de la Series. Ainsi la ville de « Montreal » apparaît 52.6% fois dans la colonne ‘Ville’.

Gestion des valeurs manquantes

Dans la colonne ‘Ville’, il y a quatre valeurs manquantes (valeur NaN). Par défaut, la méthode value_counts() exclue les valeurs manquantes du résultat (paramètre dropna=True par défaut). Ainsi pour tenir compte de ces valeurs manquantes, il faudra modifier le paramètre dropna à False :

print(df['Ville'].value_counts(dropna=False))

Montreal    10
New York     5
<NA>         4
Paris        3
Milan        1
dtype: int64

Cette fois-ci, le résultat contient comme attendu le nombre de valeurs manquantes (<NA>) : 4 dans le cas présent.

Calcul de fréquence par intervalles

Enfin, il est possible de calculer les fréquences par intervalles en utilisant le paramètre bins pour préciser le nombre d’intervalle souhaité. L’utilisation de ce paramètre est limitée au Series numérique. Donc pour illustrer ce point, nous allons utiliser la colonne ‘Note’ et la subdiviser en cinq intervalles de la façon suivante :

print(df['Note'].value_counts(bins=5))

(1.8, 2.6]      6
(0.995, 1.8]    5
(3.4, 4.2]      5
(4.2, 5.0]      4
(2.6, 3.4]      3
Name: Note, dtype: int64

Nous avons ici les fréquences des valeurs sur les intervalles donnés en index.

Représentation graphique

Un dernier point concerne la représentation graphique des fréquences d’une Series. La libraire Pandas permet d’avoir rapidement un aperçu sous forme graphique du résultat de la méthode value_counts() en appliquant la méthode plot() sur le résultat. Voici un exemple d’une représentation sous forme de bar de la fréquence de chaque ville :

df['Ville'].value_counts().plot(kind='barh', 
                                title='Fréquence par ville') ; 

Conclusion

Nous avons vu dans cet article l’ensemble des possibilités offertes par la méthode value_counts() de la librairie Pandas pour :

• Calculer des fréquences en valeur absolue ou en pourcentage,
• Trier par fréquence ou par valeur unique,
• Gérer les valeurs manquantes,
• Calculer le nombre de valeur par intervalles,
• Représenter les résultats sous forme graphique.

Référence

• Documentation Pandas officielle de la méthode value_counts()
• Domentation Pandas officielle sur la création de graphique à partir de Series ou de DataFrame