filtrer un dataframe pandas

Pandas est une bibliothèque populaire d’analyse et de manipulation de données pour Python. La structure de données de base de Pandas est le DataFrame qui stocke les données sous forme de tableau avec des lignes et des colonnes étiquetées. Voici un guide pratique pour effectuer des analyses de données efficaces contenant 8 façons de filtrer un DataFrame Pandas.

Une opération courante dans l’analyse de données consiste à filtrer les valeurs en fonction d’une ou de plusieurs conditions. Pandas propose plusieurs façons de filtrer les points de données (c’est-à-dire les lignes). Dans cet article, nous allons aborder 8 façons différentes de filtrer un DataFrame Pandas.

Nous commençons par importer les bibliothèques :

import numpy as np
import pandas as pd

Créons un DataFrame pour voir nos différents exemples :

df = pd.DataFrame({
'prénom':['Alba','Noah','Jon','Tom','Emilie','Coco','Anna'],
'catégorie':['A','A','C','B','B','C','B'],
'valeur1':np.random.random(7).round(2),
'valeur2':np.random.randint(1,10, size=7)
})
DataFrame exemple : filtrer un dataframe pandas

Top 8 des façons de filtrer un DataFrame Pandas

1. Opérateurs logiques

Nous pouvons utiliser les opérateurs logiques sur les valeurs des colonnes pour filtrer les lignes.

df[df.val1 > 0.5]
        name       cat      val1      val2       
-------------------------------------------                
1       Noah        A       0.58       2                 
2       Jon         C       0.76       1                 
3       Tom         B       0.96       3                 

Nous avons sélectionné les lignes dans lesquelles la valeur de la colonne « val1 » est supérieure à 0,5.

Les opérateurs logiques fonctionnent également sur les chaînes de caractères (strings).

df[df.name > 'Jon']
        name       cat      val1      val2       
-------------------------------------------                
1       Noah        A       0.28       6                 
3       Tom         B       0.07       5 

Seuls les prénoms qui suivent « Jon » dans l’ordre alphabétique sont sélectionnés.

2. Opérateurs logiques multiples

Pandas permet de combiner plusieurs opérateurs logiques. Par exemple, nous pouvons appliquer des conditions sur les colonnes val1 et val2 comme ci-dessous.

df[(df.val1 > 0.5) & (df.val2 == 1)]
        name       cat      val1      val2       
-------------------------------------------                
2       Jon         C       0.76       1    

Le signe « & » signifie « et » et le signe « | » signifie « ou ».

df[(df.val1 < 0.5) | (df.val2 == 3)]
         name      cat      val1      val2       
-------------------------------------------                
0        Alba        A       0.09       6                 
3        Tom         B       0.96       3                 
4        Emilie      B       0.27       4
5        Coco        C       0.45       4                 
6        Anna        B       0.17       2

3. isin

La méthode isin est une autre façon d’appliquer des conditions multiples pour le filtrage. Par exemple, nous pouvons filtrer les prénoms qui existent dans une liste donnée.

names = ['Jon','Noah','Emilie']

df[df.name.isin(names)]
        name      cat      val1      val2       
-------------------------------------------                
1       Noah       A       0.58       2                 
2       Jon        C       0.76       1                 
4       Emilie     B       0.27       4

4. Accesseur Str

Pandas est également une bibliothèque très efficace pour les données textuelles. Les fonctions et méthodes de l’accesseur str offrent des moyens flexibles de filtrer les lignes sur la base de chaînes de caractères string.

Par exemple, nous pouvons sélectionner les prénoms qui commencent par la lettre « A ».

df[df.name.str.startswith('A')]
        name      cat      val1      val2       
-------------------------------------------                
0       Alba       A       0.09       6                 
6       Anna       B       0.17       2                 

La fonction contains de l’accesseur str renvoie les valeurs qui contiennent un ensemble donné de caractères.

df[df.name.str.contains('a')]
         name      cat      val1      val2       
-------------------------------------------                
0        Alba       A       0.09       6                 
1        Noah       A       0.58       2
6        Anna       B       0.17       2

Nous pouvons également transmettre un ensemble plus long de caractères à la fonction contains en fonction des chaînes de caractères présentes dans les données.

5. Tilde (~)

L’opérateur tilde est utilisé pour la logique « not » dans le filtrage. Si nous ajoutons l’opérateur tilde avant l’expression du filtre, les lignes qui ne correspondent pas à la condition sont renvoyées.

df[~df.name.str.startswith('A')]
        name      cat      val1      val2       
-------------------------------------------                
1       Noah       A       0.58       2                 
2       Jon        C       0.76       1                 
3       Tom        B       0.96       3                 
4       Emilie     B       0.27       4
5       Coco       C       0.45       4

On prend les noms qui ne commencent pas par la lettre « A ».

6. Query

La fonction query offre un peu plus de flexibilité pour écrire les conditions de filtrage. Nous pouvons transmettre les conditions sous forme de chaîne de caractères string.

Par exemple, le code suivant renvoie les lignes qui appartiennent à la catégorie B et dont la valeur est supérieure à 0,5 dans la colonne val1.

df.query('cat == "B" and val1 > 0.5')
        name      cat      val1     val2       
-------------------------------------------                
3       Tom        B       0.96       3                 

7. nlargest ou nsmallest

Dans certains cas, nous ne disposons pas d’une plage spécifique pour le filtrage mais avons simplement besoin des valeurs les plus grandes ou les plus petites. Les fonctions nlargest et nsmallest permettent de sélectionner les lignes qui ont les plus grandes ou les plus petites valeurs dans une colonne, respectivement.

df.nlargest(3, 'val1')
        name      cat      val1      val2       
-------------------------------------------                
3       Tom        B       0.96       3                 
2       Jon        C       0.76       1                 
1       Noah       A       0.58       2                 

Nous spécifions le nombre de valeurs les plus grandes ou les plus petites à sélectionner et le nom de la colonne.

df.nsmallest(2, 'val2')
        name      cat      val1      val2       
-------------------------------------------                                 
2       Jon        C       0.76       1                 
1       Noah       A       0.58       2

8. loc et iloc

Les méthodes loc et iloc sont utilisées pour sélectionner des lignes ou des colonnes sur la base d’un index ou d’un label / étiquette.

  • loc : sélectionne les lignes ou les colonnes à l’aide des labels / étiquettes
  • iloc : sélectionne des lignes ou des colonnes à l’aide de l’index

Elles peuvent donc être utilisées pour le filtrage. Cependant, nous ne pouvons sélectionner qu’une partie particulière du DataFrame sans spécifier de condition.

df.iloc[3:5, :] # lignes 3 et 4, toutes les colonnes
        name      cat      val1      val2       
-------------------------------------------                
3       Tom        B       0.96       3                 
4       Emilie     B       0.27       4                 

Si le DataFrame a un index constitué d’entiers, les index et les labels des lignes seront les mêmes. Ainsi, loc et iloc s’utiliseront de la même manière sur les lignes (iloc prend tous les labels).

df.loc[3:5, :] # lignes 3 à 5, toutes les colonnes
        name      cat      val1      val2       
-------------------------------------------                
3       Tom        B       0.96       3                 
4       Emilie     B       0.27       4
5       Coco       C       0.45       4

Mettons à jour l’index du DataFrame pour mieux souligner la différence entre loc et iloc.

df.index = ['a','b','c','d','e','f','g']
DataFrame ré-indexé : filtrer un dataframe pandas

Nous ne pouvons plus passer des entiers à la méthode loc maintenant car les labels de l’index sont maintenant des lettres (string).

df.loc['b':'d', :]
        name      cat      val1      val2       
-------------------------------------------                
b       Noah       B       0.58       2                 
c       Jon        C       0.76       1
d       Tom        B       0.96       3

b	Noah	A	0.58	2
c	Jon	C	0.76	1
d	Tom	B	0.96	3

Conclusion

Nous avons abordé 8 façons différentes de filtrer les lignes d’un DataFrame Pandas. Toutes sont utiles et se révèlent très pratiques dans des cas particuliers.

Pandas est une bibliothèque puissante pour l’analyse et la manipulation des données. Elle fournit de nombreuses fonctions et méthodes pour manipuler les données sous forme de tableaux. Comme pour tout autre outil, la meilleure façon d’apprendre Pandas, c’est de s’exercer. Pour en lire plus sur des cas concrets et pratiques sur Pandas, je vous recommande aussi de lire : 10 astuces Pandas et 12 fonctions Pandas et NumPy à ne pas manquer !

Merci de votre lecture. N’hésitez pas à me faire part de vos commentaires.

A lire également