Nettoyage de données de base avec Pandas

Introduction

Bienvenue dans le laboratoire de nettoyage de données de base avec Pandas. Le nettoyage des données est une première étape cruciale dans tout projet d'analyse de données ou d'apprentissage automatique. Les données du monde réel sont souvent désordonnées, contenant des valeurs manquantes, des entrées dupliquées ou des types de données incorrects. L'utilisation de données brutes et non nettoyées peut conduire à des analyses inexactes et à des conclusions peu fiables.

Pandas est une bibliothèque Python puissante qui fournit des structures de données et des outils d'analyse de données performants et faciles à utiliser. C'est l'outil de référence pour le nettoyage et la manipulation de données en Python.

Dans ce laboratoire, vous apprendrez les techniques fondamentales pour nettoyer un ensemble de données à l'aide de Pandas. Vous pratiquerez :

• La suppression des lignes avec des valeurs manquantes à l'aide de dropna().
• Le remplissage des valeurs manquantes avec fillna().
• La suppression des lignes dupliquées avec drop_duplicates().
• Le renommage des colonnes avec rename().
• La conversion des types de données des colonnes avec astype().

À la fin de ce laboratoire, vous aurez une solide compréhension du flux de travail de nettoyage de données de base dans Pandas.

Supprimer les lignes avec la méthode dropna

Dans cette étape, vous apprendrez à gérer les données manquantes en supprimant les lignes qui contiennent des valeurs nulles. Dans Pandas, les données manquantes sont représentées par NaN (Not a Number). L'une des stratégies les plus simples pour traiter les valeurs NaN est de supprimer les lignes ou les colonnes qui les contiennent.

La méthode dropna() vous permet de le faire facilement. Par défaut, elle supprime toute ligne contenant au moins une valeur NaN.

Tout d'abord, exécutons le script initial pour voir notre DataFrame de départ. Le script de configuration a déjà créé un fichier nommé main.py dans le répertoire ~/project.

Ouvrez un terminal dans le WebIDE et exécutez la commande suivante :

python3 main.py

Vous devriez voir le DataFrame original, qui contient des valeurs NaN dans les colonnes age et city.

Original DataFrame:
      name   age         city SALARY_IN_USD
0    Alice  25.0     New York         50000
1      Bob  30.0  Los Angeles         60000
2  Charlie  35.0     New York         70000
3    David  40.0      Chicago         80000
4    Alice  25.0     New York         50000
5      Eva   NaN       Boston         90000
6    Frank  45.0          NaN        100000

Original DataFrame Info:
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 7 entries, 0 to 6
Data columns (total 4 columns):
 ##   Column         Non-Null Count  Dtype
---  ------         --------------  -----
 0   name           7 non-null      object
 1   age            6 non-null      float64
 2   city           6 non-null      object
 3   SALARY_IN_USD  7 non-null      object
dtypes: float64(1), object(3)
memory usage: 352.0+ bytes

Maintenant, utilisons dropna() pour voir comment cela fonctionne. Ouvrez le fichier main.py depuis l'explorateur de fichiers dans le panneau de gauche. Ajoutez le code suivant à la fin du fichier. Ce code créera un nouveau DataFrame df_dropped avec les lignes contenant des NaN supprimées et l'affichera. Nous ne modifions pas encore le df original, afin de pouvoir explorer d'autres méthodes dans les étapes suivantes.

## Add this to the end of main.py

print("\nDataFrame after dropping rows with any missing values:")
df_dropped = df.dropna()
print(df_dropped)

Enregistrez le fichier (Ctrl+S ou Cmd+S) et exécutez-le à nouveau depuis le terminal :

python3 main.py

La sortie inclura désormais une nouvelle section montrant le DataFrame après la suppression des lignes contenant des valeurs NaN (lignes pour Eva et Frank).

## ... (previous output) ...

DataFrame after dropping rows with any missing values:
      name   age         city SALARY_IN_USD
0    Alice  25.0     New York         50000
1      Bob  30.0  Los Angeles         60000
2  Charlie  35.0     New York         70000
3    David  40.0      Chicago         80000
4    Alice  25.0     New York         50000

Remplir les valeurs manquantes avec fillna

Dans cette étape, vous apprendrez une autre façon de gérer les données manquantes : remplir les valeurs manquantes avec une valeur spécifique à l'aide de la méthode fillna(). La suppression des lignes avec des données manquantes peut parfois entraîner une perte de données importante, surtout si de nombreuses lignes ont des valeurs manquantes. Les remplir est souvent une meilleure alternative.

Vous pouvez remplir les valeurs NaN avec une constante, comme 0 ou "Unknown", ou avec une valeur calculée, comme la moyenne ou la médiane de la colonne.

Modifions notre fichier main.py. Au lieu de simplement imprimer le DataFrame après suppression, nous allons maintenant nettoyer notre DataFrame principal df en remplissant les valeurs manquantes. Nous allons remplir l'âge manquant (age) avec la moyenne des âges existants et la ville manquante (city) avec la chaîne de caractères 'Unknown'.

Supprimez le code dropna() que vous avez ajouté à l'étape précédente et remplacez-le par le code suivant. Nous utilisons inplace=True pour modifier le DataFrame directement.

## Replace the dropna() code with this at the end of main.py

## Calculate the mean of the 'age' column
mean_age = df['age'].mean()

## Fill missing values using the recommended approach to avoid FutureWarnings
df.fillna({'age': mean_age, 'city': 'Unknown'}, inplace=True)

print("\nDataFrame after filling missing values:")
print(df)

L'argument inplace=True modifie le DataFrame sur place, ce qui signifie que vous n'avez pas besoin d'assigner le résultat à une variable (par exemple, df = df.fillna(...)).

Enregistrez le fichier et exécutez-le depuis le terminal :

python3 main.py

Vous verrez que les valeurs NaN ont été remplacées. L'âge d'Eva est maintenant la moyenne des autres âges, et la ville de Frank est 'Unknown'.

## ... (original DataFrame output) ...

DataFrame after filling missing values:
      name   age         city SALARY_IN_USD
0    Alice  25.0     New York         50000
1      Bob  30.0  Los Angeles         60000
2  Charlie  35.0     New York         70000
3    David  40.0      Chicago         80000
4    Alice  25.0     New York         50000
5      Eva  33.3       Boston         90000
6    Frank  45.0      Unknown        100000

Note : La moyenne d'âge est (25+30+35+40+25+45)/6 = 33.33.... Pandas remplira les NaN avec cette valeur. La sortie ci-dessus affiche 35.0 pour simplifier, votre sortie réelle pour l'âge d'Eva sera la moyenne calculée.

Supprimer les lignes dupliquées avec drop_duplicates

Dans cette étape, vous apprendrez à supprimer les lignes dupliquées de votre DataFrame. Les données dupliquées peuvent fausser l'analyse et conduire à des résultats incorrects. La méthode drop_duplicates() permet de les identifier et de les supprimer.

Dans notre jeu de données original, la ligne pour 'Alice' apparaît deux fois avec exactement les mêmes informations. Maintenant que nous avons traité les valeurs manquantes, notre prochaine tâche de nettoyage consiste à supprimer cette entrée dupliquée.

Par défaut, drop_duplicates() considère une ligne comme dupliquée si toutes les valeurs de ses colonnes sont identiques à celles d'une autre ligne.

Ajoutez le code suivant à la fin de votre script main.py. Nous continuerons à utiliser inplace=True pour modifier notre DataFrame.

## Add this to the end of main.py

df.drop_duplicates(inplace=True)

print("\nDataFrame after dropping duplicates:")
print(df)

Enregistrez le fichier et exécutez-le depuis le terminal :

python3 main.py

La sortie affichera maintenant un DataFrame avec seulement 6 lignes, car l'une des lignes 'Alice' a été supprimée.

## ... (previous output) ...

DataFrame after dropping duplicates:
      name   age         city SALARY_IN_USD
0    Alice  25.0     New York         50000
1      Bob  30.0  Los Angeles         60000
2  Charlie  35.0     New York         70000
3    David  40.0      Chicago         80000
5      Eva  33.3       Boston         90000
6    Frank  45.0      Unknown        100000

Notez que l'index 4 est maintenant manquant, ce qui correspond à la ligne dupliquée qui a été supprimée. Le DataFrame contient maintenant 6 lignes uniques.

Renommer les colonnes avec la méthode rename

Dans cette étape, vous apprendrez à renommer les colonnes. Des noms de colonnes cohérents et clairs sont essentiels pour la lisibilité et la maintenabilité du code. Il est courant d'utiliser une convention de nommage cohérente, telle que tout en minuscules avec des underscores.

Notre DataFrame a une colonne nommée SALARY_IN_USD. Renommons-la avec un nom plus simple et en minuscules : salary. La méthode rename() est parfaite pour cela. Vous passez un dictionnaire à l'argument columns où les clés sont les anciens noms et les valeurs sont les nouveaux noms.

Ajoutez le code suivant à la fin de votre script main.py :

## Add this to the end of main.py

df.rename(columns={'SALARY_IN_USD': 'salary'}, inplace=True)

print("\nDataFrame after renaming columns:")
print(df)

Enregistrez le fichier et exécutez-le depuis le terminal :

python3 main.py

Vous verrez que la colonne SALARY_IN_USD a été renommée avec succès en salary.

## ... (previous output) ...

DataFrame after renaming columns:
      name   age         city   salary
0    Alice  25.0     New York    50000
1      Bob  30.0  Los Angeles    60000
2  Charlie  35.0     New York    70000
3    David  40.0      Chicago    80000
5      Eva  33.3       Boston    90000
6    Frank  45.0      Unknown   100000

Ce simple changement rend le nom de la colonne plus facile à taper et suit un guide de style Python courant.

Convertir les types de colonnes avec astype

Dans cette dernière étape, vous apprendrez à convertir le type de données d'une colonne. Des types de données corrects sont cruciaux pour effectuer des calculs et pour l'efficacité de la mémoire.

Si vous regardez la sortie initiale de df.info(), vous remarquerez que la colonne SALARY_IN_USD avait un Dtype object, ce qui signifie qu'elle stockait les nombres sous forme de chaînes de caractères. Nous ne pouvons pas effectuer d'opérations mathématiques (comme calculer le salaire moyen) sur des chaînes de caractères. Nous devons convertir cette colonne en un type numérique, tel que int (entier).

La méthode astype() est utilisée à cette fin. Convertissons notre nouvelle colonne salary au type int.

Ajoutez le code suivant à la fin de main.py. Nous imprimerons également à nouveau les informations du DataFrame pour confirmer le changement.

## Add this to the end of main.py

df['salary'] = df['salary'].astype(int)

print("\nDataFrame after converting data types:")
print(df)

print("\nFinal DataFrame Info:")
df.info()

Enregistrez le fichier et exécutez-le une dernière fois :

python3 main.py

La sortie finale affichera le DataFrame nettoyé et ses nouvelles informations. Regardez attentivement le Dtype de la colonne salary dans la sortie d'informations. Il devrait maintenant être int64, et non object.

## ... (previous output) ...

DataFrame after converting data types:
      name   age         city  salary
0    Alice  25.0     New York   50000
1      Bob  30.0  Los Angeles   60000
2  Charlie  35.0     New York   70000
3    David  40.0      Chicago   80000
5      Eva  33.3       Boston   90000
6    Frank  45.0      Unknown  100000

Final DataFrame Info:
<class 'pandas.core.frame.DataFrame'>
Index: 6 entries, 0 to 6
Data columns (total 4 columns):
 ##   Column  Non-Null Count  Dtype
---  ------  --------------  -----
 0   name    6 non-null      object
 1   age     6 non-null      float64
 2   city    6 non-null      object
 3   salary  6 non-null      int64
dtypes: float64(1), int64(1), object(2)
memory usage: 240.0+ bytes

Avec la colonne salary de type entier, vous pouvez maintenant effectuer des calculs tels que df['salary'].mean().

Résumé

Félicitations pour avoir terminé le laboratoire de nettoyage de données de base avec Pandas ! Vous avez transformé avec succès un jeu de données brut et désordonné en un format propre et prêt pour l'analyse.

Dans ce laboratoire, vous avez appris et pratiqué plusieurs techniques essentielles de nettoyage de données dans Pandas :

• Gestion des valeurs manquantes : Vous avez vu comment supprimer les lignes contenant des NaN avec dropna() et comment les remplir avec des données significatives en utilisant fillna().
• Suppression des doublons : Vous avez utilisé drop_duplicates() pour éliminer les lignes redondantes de votre jeu de données.
• Renommage des colonnes : Vous avez appris à rendre les noms de colonnes plus cohérents et lisibles avec la méthode rename().
• Conversion des types de données : Vous avez utilisé astype() pour modifier le type de données d'une colonne au format correct, permettant ainsi une analyse plus poussée.

Ces compétences fondamentales sont les éléments constitutifs de tout travail sérieux sur les données. Les maîtriser vous permettra d'aborder avec confiance les défis des données du monde réel. Continuez à pratiquer ces techniques pour devenir compétent en manipulation de données avec Pandas.