Apprenez comment accélérer de façon surprenante vos Analyses Exploratoires de Données (EDA en anglais pour Exploratory Data Analysis). Pour l’occasion, je vous présente 4 méthodes Pandas pour accélérer vos analyses de Data !
En utilisant les méthodes intégrées de Pandas, il est super facile et très direct d’analyser un ensemble de données et de résumer ses caractéristiques importantes.
Les méthodes Pandas sur DataFrame les plus utilisées sont .head(), .tail(), .info(), .describe(), .plot() et .value_counts().
Je vous présente ici 4 autres méthodes que j’utilise pour accélérer encore plus mes analyses de données (EDA). ⚡
Et ma promesse, c’est que dans les 5 prochaines minutes à partir de maintenant, vous allez certainement maîtriser ces 4 méthodes !
Prenons un exemple de résultats d’examens de quelques étudiants. Vous pouvez créer un DataFrame comme indiqué ci-dessous et suivre le processus :
import pandas as pd
import numpy as np
df = pd.DataFrame( {
"student" : ["Vincent", "Emilie", "Alba", "Charles", "Alex", "Charles", "Anthony", "Emilie"],
"city" : ["Paris", "Paris", "Lisbonne", "Paris", "Paris", "Lisbonne", "Paris", "Lisbonne"],
"age" : [20, 34, 18, 24, 29, 28, 23, 20],
"maths_score" : [84, 80, 50, 36, 44, 24, 41, 35],
"science_score" : [66, 83, 51, 35, 43, 58, 71, 65]} )
dfAllez c’est parti pour les 4 méthodes Pandas !
4 méthodes Pandas pour accélérer vos analyses de Data
1/ Groupby sans agrégation dans Pandas
Dans de nombreuses situations, nous voulons diviser l’ensemble des données en groupes et faire quelque chose avec ces groupes. La méthode Pandas groupby() est utilisée pour diviser les données du DataFrame en groupes.
Au lieu d’utiliser conjointement les méthodes groupby() et d’agrégation, créez un objet GroupBy. Idéalement, cet objet pourra être utilisé directement en cas de besoin.
Divisons le DataFrame donné en groupes basés sur la colonne « city » :
df_city_group = df.groupby("city")Cela crée un objet df_city_group qui peut être combiné avec différentes agrégations telles que min(), max(), mean(), describe(), et count().
Un exemple est présenté ci-dessous :
df_city_group.mean()
Pour obtenir le sous-ensemble de DataFrame df_city_group où la ville est Lisbonne, il suffit d’utiliser la méthode .get_group() :
df_city_group.get_group("Lisbonne")
Cela ne nécessite pas la création d’une copie de chaque sous-DataFrame pour chaque groupe, ce qui permet d’économiser de la mémoire. En effet, elle utilise des structures de données déjà disponibles dans l’objet.
Le découpage (slicing) avec .groupby() est 2.5X plus rapide qu’avec la comparaison logique !
Regardons les résultats de temps d’exécution :
%%timeit df[df["city"]=="Lisbonne"]
The slowest run took 9.98 times longer than the fastest. This could mean that an intermediate result is being cached. 1000 loops, best of 5: 344 µs per loop
%%timeit
df_city_group.get_group("Lisbonne")The slowest run took 4.33 times longer than the fastest. This could mean that an intermediate result is being cached. 10000 loops, best of 5: 129 µs per loop
129 µs pour get_group() Versus 344 µs pour la comparaison logique.
.groupby() et .get_group() sont des game changers lorsqu’il s’agit de découper un DataFrame. ⏳
2/ Le plus grand en utilisant .nlargest()
Souvent, nous souhaitons connaître les 3 ou 5 meilleures entrées d’un DataFrame en fonction des valeurs d’une colonne spécifique.
Par exemple, pour obtenir les trois meilleurs résultats à un examen ou les cinq films les plus regardés dans un ensemble de données.
.nlargest() de Pandas est la réponse la plus simple avec sa syntaxe.df.nlargest(N, nom_colonne, keep = 'first' )
La méthode .nlargest() permet d’extraire les lignes du DataFrame contenant les ‘N’ valeurs les plus élevées d’une colonne spécifiée.
Dans l’exemple ci-dessus, récupérons les lignes du DataFrame df contenant les 3 premières valeurs « maths_score » :
df_top3_maths = df.nlargest(3, "maths_score") df_top3_maths
S’il y a une égalité entre deux valeurs, les paramètres supplémentaires (et facultatifs) peuvent être modifiés. Par exemple, le paramètre keep prend les valeurs « first », « last » et « all » pour récupérer la première, la dernière et toutes les valeurs de l’égalité…
Un des avantages de cette méthode est que vous n’avez pas besoin de trier spécifiquement le DataFrame. La méthode .nlargest() le fait à votre place.
3/ Le plus petit en utilisant .nsmallest()
Comme pour les 3 ou 5 premiers, nous avons parfois besoin des 5 derniers enregistrements du DataFrame.
Par exemple, obtenir les 5 films ayant la note la plus basse ou les 5 étudiants ayant obtenu les notes les plus basses à un examen.
.nsmallest() peut être la réponse la plus simple avec sa syntaxe.df.nsmallestst(N, nom_colonne, keep = 'first' )
La méthode .nsmallest() permet d’extraire les lignes du DataFrame contenant les ‘N’ dernières valeurs d’une colonne spécifiée.
Dans le même exemple, récupérons les lignes du DataFrame df contenant les 3 valeurs les plus basses de « maths_score » :
df_bottom3_maths = df.nsmallest(3, "maths_score") df_bottom3_maths
Cependant, tout ceci concernait les méthodes les plus simples. Mais, du point de vue du temps d’exécution ⏳, les méthodes .nlargest() et .nsmallest() sont de mauvais choix :/
Sort_values() est 4X plus rapide que nlargest() !
Regardons les différents temps d’exécution pour conclure…
%%timeit df1 = df.sort_values(by=["maths_score"], ascending=False).head(3)
The slowest run took 11.40 times longer than the fastest. This could mean that an intermediate result is being cached. 1000 loops, best of 5: 169 µs per loop
%%timeit df1 = df.nlargest(3, "maths_score")
The slowest run took 6.18 times longer than the fastest. This could mean that an intermediate result is being cached. 1000 loops, best of 5: 701 µs per loop
D’après mon expérience, je vous recommande d’utiliser la méthode .sort_values() pour accélérer vos analyses de données (EDA).
Comparaisons logiques
Les opérateurs de comparaison <, >, <=, >=, ==, != et leurs wrappers .lt(), .gt(), .le(), .ge(), .eq() et .ne() respectivement, sont très pratiques dans des cas tels que :
- Comparer le DataFrame à une valeur de base.
Une telle comparaison donne lieu à une série de valeurs booléennes qui peuvent être utilisées comme indicateurs à des fins ultérieures. - Découpage (slicing) du DataFrame en fonction de la comparaison
Un sous-ensemble peut être extrait du DataFrame sur la base d’une comparaison avec une valeur. - Création d’une nouvelle colonne dans le DataFrame existant sur la base d’une comparaison de deux colonnes.
Tous ces scénarios sont expliqués dans l’exemple ci-dessous :
# 1. Comparaison du DataFrame à une valeur de base # Sélection des colonnes contenant uniquement des valeurs numériques df.iloc[:,2:5].gt(50) df.iloc[:,2:5].lt(50) # 2. Découpage (slicing) du DataFrame en fonction de la comparaison # df1 est un sous-ensemble de df lorsque les valeurs de la colonne "maths_score" sont différentes ou égales à '35' df1 = df[df["maths_score"].ne(35)] df2 = df[df["maths_score"].eq(35)] # 3. Création d'une nouvelle colonne de valeurs booléennes True-Falase en comparant deux colonnes df["maths_student"] = df["maths_score"].ge(df["science_score"]) df["maths_student_1"] = df["science_score"].le(df["maths_score"])
Vous trouverez plus de documentation sur les wrappers pour les opérateurs de comparaison ici.
Conclusion
J’ai trouvé ces méthodes très pratiques lorsque j’utilisais Python pour l’analyse de données. Et elles rendent vraiment l’analyse plus rapide. Vous pouvez les essayer et me faire part des autres méthodes que vous utilisez pour accélérer vos analyses de données (EDA) !
Retrouvez le notebook de l’article ici si besoin.
Vous pouvez également consulter 3 méthodes NumPy que je recommande pour faciliter vos analyses de données avec Pandas.
