Pandas est un paquet Python très utilisé pour les données structurées. Il existe de nombreux tutoriels intéressants, mais j’aimerais tout de même présenter ici quelques astuces Pandas que vous ne connaissez peut-être pas encore et qui sont, à mon sens, très utiles.
Voici certaines méthodes Pandas que vous connaissez peut-être déjà mais dont vous ignorez sans doute qu’elles peuvent être utilisées de cette manière.
Mes 10 astuces Pandas
1. read_csv
Tout le monde connaît la méthode read_csv, elle permet de lire un fichier CSV dans un DataFrame. Mais les données que vous essayez de lire sont volumineuses, essayez d’ajouter cet argument : nrows = 5 pour ne lire qu’une infime partie de la table avant de charger réellement la table entière. Vous pourriez alors éviter l’erreur en choisissant un mauvais délimiteur (il n’est pas toujours séparé par une virgule).
import pandas as pd
df = pd.read_csv('fichier.csv', nrows = 5)(Vous pouvez aussi utiliser la commande head dans votre cmd ou terminal pour vérifier les 5 premières lignes dans n’importe quel fichier texte : head -n 5 data.txt)
Ensuite, vous pouvez extraire la liste des colonnes en utilisant df.columns.tolist() pour extraire toutes les colonnes, et ensuite ajouter l’argument usecols = [‘c1’, ‘c2’, …] pour charger les colonnes dont vous avez besoin.
De plus, si vous connaissez les types de données de quelques colonnes spécifiques, vous pouvez ajouter l’argument dtype = {‘c1’ : str, ‘c2’ : int, …} pour que le chargement soit plus rapide.
Autre avantage de cet argument : si vous avez une colonne qui contient à la fois des chaînes de caractères et des chiffres, il est bon de déclarer que son type est une chaîne de caractères, afin de ne pas obtenir d’erreurs en essayant de fusionner des tableaux en utilisant cette colonne comme clé.
df = pd.read_csv('fichier.csv', usecols = ['c1', 'c2'], dtype = {'c1' : str, 'c2' : float})2. select_dtypes
Si le pré-traitement des données doit être effectué en Python, la méthode select_dtypes vous fera gagner du temps. Après lecture dans un tableau, les types de données par défaut pour chaque colonne pourraient être bool, int64, float64, object, category, timedelta64, ou datetime64. Vous pouvez d’abord vérifier la répartition avec :
df.dtypes.value_counts()
Cela permet de connaître tous les types de données possibles de votre DataFrame, puis vous tapez :
df.select_dtypes(include=['float64', 'int64'])
afin de sélectionner un sous-DataFrame avec uniquement des caractéristiques numériques (avec float et int).
3. copy
C’est une méthode importante, si vous n’en avez pas encore entendu parler. Si vous tapez le code suivant :
import pandas as pd
df1 = pd.DataFrame({ 'a':[0,0,0], 'b': [1,1,1]})
df2 = df1
df2['a'] = df2['a'] + 1
df1.head()Vous constaterez que df1 est modifié. En effet, df2 = df1 ne fait pas une copie de df1 et l’affecte à df2, mais met en place un pointeur qui pointe vers df1. Toute modification de df2 entraîne donc une modification de df1. Pour remédier à cela, vous pouvez utilise :
df2 = df1.copy()
ou
from copy import deepcopy df2 = deepcopy(df1)
4. map
Il s’agit d’une commande sympa qui permet de faire des transformations de données faciles. Vous définissez d’abord un dictionnaire dont les ‘clés’ sont les anciennes valeurs et les ‘valeurs’ sont les nouvelles valeurs.
level_map = {1: 'high', 2: 'medium', 3: 'low'}
df['c_level'] = df['c'].map(level_map)Quelques exemples : True, False devient 1, 0 (pour la modélisation) ; définition de niveaux ; codages lexicaux définis par l’utilisateur.
5. apply ou non ?
Si nous souhaitons créer une nouvelle colonne avec quelques autres colonnes en entrée, la fonction apply peut parfois être très utile.
def rule(x, y):
if x == 'high' and y > 10:
return 1
else:
return 0
df = pd.DataFrame({ 'c1':[ 'high' ,'high', 'low', 'low'], 'c2': [0, 23, 17, 4]})
df['new'] = df.apply(lambda x: rule(x['c1'], x['c2']), axis = 1)
df.head()Dans le code ci-dessus, nous définissons une fonction avec deux variables d’entrée, et nous utilisons la fonction apply pour l’appliquer aux colonnes ‘c1’ et ‘c2’.
Mais le problème de la méthode apply c’est qu’elle est parfois trop lente. Si vous souhaitez calculer le maximum de deux colonnes ‘c1’ et ‘c2’, vous pouvez bien sûr utiliser apply de cette façon :
df['maximum'] = df.apply(lambda x: max(x['c1'], x['c2']), axis = 1)
Mais dans ce cas, ce sera plus rapide en utilisant directement la méthode max() comme cela :
df['maximum'] = df[['c1','c2']].max(axis =1)
Astuce : N’utilisez pas apply si vous pouvez faire le même travail avec d’autres fonctions intégrées (elles sont souvent plus rapides). Par exemple, si vous voulez arrondir la colonne ‘c’ en nombres entiers, faites round(df[‘c’], 0) ou df[‘c’].round(0) au lieu d’utiliser la fonction apply : df.apply(lambda x : round(x[‘c’], 0), axe = 1).
6. value_counts
Il s’agit d’une méthode permettant de vérifier les distributions de valeurs. Par exemple, si vous souhaitez vérifier quelles sont les valeurs possibles et la fréquence de chaque valeur individuelle de la colonne ‘c’, vous pouvez taper :
df['c'].value_counts()
Il y a quelques astuces et arguments utiles :
- normalize = True : si vous souhaitez vérifier la fréquence au lieu du nombre de valeurs d’une colonne.
- dropna = False : si vous souhaitez aussi inclure les valeurs manquantes dans les statistiques.
- df[‘c’].value_counts().reset_index() : si vous souhaitez convertir le tableau des statistiques en un DataFrame pandas et le manipuler.
- df[‘c’].value_counts().sort_index() : montre les statistiques triées par valeurs distinctes dans la colonne ‘c’ au lieu du nombre de valeurs.
7. Nombre de valeurs manquantes
Lorsque vous construisez des modèles, vous pouvez exclure la ligne comportant trop de valeurs manquantes ou encore les lignes comportant toutes les valeurs manquantes.
Vous pouvez utiliser .isull() et .sum() pour compter le nombre de valeurs manquantes dans les colonnes spécifiées.
import pandas as pd
import numpy as np
df = pd.DataFrame({ 'id': [1,2,3], 'c1':[0,0,np.nan], 'c2': [np.nan,1,1]})
df = df[['id', 'c1', 'c2']]
df['num_nulls'] = df[['c1', 'c2']].isnull().sum(axis=1)
df.head()8. Sélectionner des lignes avec des IDs spécifiques
En SQL, nous pouvons le faire en utilisant SELECT * FROM … WHERE ID in (‘A001’, ‘C022’, …) pour obtenir des enregistrements avec des IDs spécifiques. Si vous voulez faire la même chose avec pandas, vous pouvez taper :
df_filter = df['ID'].isin(['A001','C022',...]) df[df_filter]
9. Groupes de percentile
Vous avez une colonne numérique, et vous aimeriez classer les valeurs de cette colonne en groupes, disons les 5 % supérieurs dans le groupe 1, 5-20 % dans le groupe 2, 20-50 % dans le groupe 3, les 50 % inférieurs dans le groupe 4. Bien sûr, vous pouvez le faire avec pandas.cut, mais j’aimerais vous proposer une autre option ici :
import numpy as np
cut_points = [np.percentile(df['c'], i) for i in [50, 80, 95]]
df['group'] = 1
for i in range(3):
df['group'] = df['group'] + (df['c'] < cut_points[i])
# ou <= cut_points[i]Ce qui est rapide à exécuter (aucune fonction apply utilisée).
10. to_csv
Là encore, c’est une méthode que tout le monde utilise. Je voudrais souligner deux astuces ici. La première est :
print(df[:5].to_csv())
Vous pouvez utiliser cette commande pour imprimer les cinq premières lignes de ce qui va être écrit exactement dans le fichier.
Une autre astuce consiste à traiter les nombres entiers et les valeurs manquantes mélangés ensemble. Si une colonne contient à la fois des valeurs manquantes et des entiers, le type de données sera toujours float au lieu de int. Lorsque vous exportez le tableau, vous pouvez ajouter float_format=’%.0f’ pour arrondir tous les floats aux entiers.
Utilisez cette astuce si vous ne voulez que des sorties d’entiers pour toutes les colonnes – vous vous débarrasserez de tous les « .0 » gênants.
Si vous avez aimé ces 10 astuces très utiles sur Python avec la bibliothèque Pandas, vous aimerez lire 12 techniques de manipulation de données.
N’hésitez pas à partager un maximum sur les réseaux sociaux 🙂
