fonctions pandas data scientists

Selon Forbes, les data scientists passent 60 % de leur temps à nettoyer et organiser les données. Cela montre l’importance du nettoyage et du traitement des données dans un projet de Data Science. Pour l’occasion, je te présente 14 fonctions Pandas que les Data Scientists utilisent 60% de leur temps.

Le nettoyage des données consiste à nettoyer les données que nous allons utiliser, afin de ne pas avoir de données incorrectes, corrompues, dupliquées ou incomplètes. Les données du monde réel ne sont pas aussi propres que la plupart des ensembles de données avec lesquels tu pourrais travailler dans un cours en ligne. C’est pourquoi le nettoyage des données est essentiel dans les projets du monde réel.

Une autre étape importante d’un projet consiste à transformer (ou wrangle en anglais) nos données brutes dans un autre format, afin qu’elles soient prêtes à être analysées.

Dans ce guide, nous allons apprendre à utiliser 14 fonctions pandas pour nettoyer et transformer un ensemble de données qui sera utilisé ultérieurement pour un projet de Data Science.

Lecture des ensembles de données

Pour suivre ce tutoriel, tu dois avoir installé Python et pandas. Pour installer pandas, exécutez la commande ci-dessous dans le terminal :

pip install pandas

Maintenant que pandas est installé, jetons un coup d’œil aux données avec lesquelles nous allons travailler. Il s’agit d’un jeu de données sur le football qui contient des informations historiques sur les Coupes du monde de la FIFA de 1930 à 2022. Tu peux télécharger tous les jeux de données sur mon Google Drive.

Pour avoir une idée de la façon dont ces ensembles de données ont été récoltés, tu peux consulter cet article de Web Scraping de tous les matchs de Coupe du Monde de 1930 à 2022.

Pour lire ces trois fichiers CSV, nous utilisons la méthode .read_csv.

df_historical_data = pd.read_csv('fifa_worldcup_matches.csv')
df_fixture = pd.read_csv('fifa_worldcup_fixture.csv')
df_missing_data = pd.read_csv('fifa_worldcup_missing_data.csv')

df_historical_data : matches joués de 1930 à 2018
df_missing_data : matchs manquants à ajouter à df_historical_data
df_fixture : matchs de la prochaine Coupe du Monde Qatar 2022.

Nettoyons ces 3 jeux de données !

Suppression des espaces avant et arrière avec .strip

Commençons par nettoyer le DataFrame df_fixture. Jetons un coup d’oeil à ce cadre de données.

Fonctions Pandas : strip

Apparemment, tout va bien, non ?

Mais non ! Il y a quelque chose qui ne va pas : il y a des espaces avant et après les chaînes de caractères dans les colonnes home et away. Ils ne sont pas faciles à repérer.

Au lieu de n’avoir que les noms des pays, nous avons quelque chose comme ceci dans nos colonnes : Qatar, United States. Ces espaces blancs pourraient gâcher notre analyse ultérieure, nous devons donc les supprimer à l’aide de .strip.

df_fixture['home'] = df_fixture['home'].str.strip()
df_fixture['away'] = df_fixture['away'].str.strip()

C’est tout pour le DataFrame df_fixture. Maintenant, continuons avec un autre DataFrame.

Identifier les données NaN avec .isnull et les supprimer avec .dropna

Maintenant, nettoyons le DataFrame df_missing_data. Le problème de ce DataFrame c’est qu’il contient des données NaN.

Nous pouvons vérifier cela en utilisant .isnull.

df_missing_data[df_missing_data['home'].isnull()]
Fonctions Pandas : isnull

Maintenant, nous devons supprimer toutes les lignes qui ont des valeurs NaN. Pour ce faire, nous utilisons .dropna.

df_missing_data.dropna(inplace=True)

Concaténation de 2 DataFrames avec .concat et suppression des doublons avec .drop_duplicates

Maintenant que df_missing_data est nettoyé, nous pouvons l’ajouter aux données historiques dans df_historical_data en utilisant .concat.

df_historical_data = pd.concat([df_historical_data, df_missing_data], ignore_index=True)

Le problème de la fusion de deux Dataframes c’est que nous pouvons avoir les mêmes données dans les deux DataFrames, donc lorsque nous les combinons, nous pouvons obtenir des doublons. C’est pourquoi nous utilisons la fonction drop_duplicates pour supprimer les doublons potentiels que nous pouvons obtenir. En plus de cela, nous allons trier le DataFrame par année.

df_historical_data.drop_duplicates(inplace=True)
df_historical_data.sort_values('year', inplace=True)

Voici à quoi ressemble maintenant df_historical_data.

Fonctions Pandas : drop_duplicates

Cet ensemble de données final comporte 901 lignes, qui représentent les 901 matchs joués dans toutes les Coupes du monde.

Repérer les anomalies avec .contains et les supprimer avec .drop

Il est maintenant temps de nettoyer le DataFrame df_historical_data. Nous allons commencer par supprimer les anomalies que nous ne souhaitons pas inclure dans nos ensembles de données finaux.

En fonction de l’objectif du projet, nous pouvons soit supprimer, soit conserver un enregistrement. Je prévois d’utiliser ce jeu de données pour prédire le vainqueur de la Coupe du monde 2022 en fonction des buts marqués par chaque équipe nationale. En gardant cela à l’esprit, je ne veux pas inclure les matchs qui se terminent par des « walkovers » (w/o), car cela attribue une équipe, si l’autre équipe n’a pas de joueurs disponibles, ou si elle a été disqualifiée.

Dans l’histoire de la Coupe du monde, il y a eu un match qui s’est terminé par un walkover – Suède contre Autriche. Pour rechercher les walkovers, nous pouvons utiliser .contains avec la chaîne « w/o » dans la colonne score. Nous pouvons également rechercher “Sweden”/“Austria” dans les colonnes home / away.

delete_index = df_historical_data[df_historical_data['home'].str.contains('Sweden') &
                                  df_historical_data['away'].str.contains('Austria')].index

Après avoir repéré l’anomalie, nous la supprimons avec .drop.

df_historical_data.drop(index=delete_index, inplace=True)

Utilisation de regex pour repérer les incohérences et les remplacer par .replace

Les données du monde réel sont incohérentes. Certaines colonnes peuvent suivre un modèle dans l’aperçu du DataFrame mais si tu l’explores ligne par ligne, tu peux rencontrer des incohérences qui peuvent gâcher ton projet.

Dans notre ensemble de données, la colonne score suit apparemment le format « HomeGoals-AwayGoals », mais certaines lignes contiennent des informations supplémentaires. Pour repérer ces lignes, nous pouvons utiliser des expressions régulières (regex).

Si nous utilisons l’expression régulière [^\d-], nous pouvons trouver des caractères qui ne sont pas des chiffres ou -.

df_historical_data[df_historical_data['score'].str.contains('[^\d–]')]
Fonctions Pandas : contains

Maintenant, pour remplacer tout ce qui n’est pas un chiffre ou un - par une chaîne vide, nous utilisons .replace.

df_historical_data['score'] = df_historical_data['score'].str.replace('[^\d–]', '', regex=True)

Enfin, nous nous assurons que les colonnes home / away ne comportent pas d’espaces blancs.

df_historical_data['home'] = df_historical_data['home'].str.strip()
df_historical_data['away'] = df_historical_data['away'].str.strip()

Avec cela, le nettoyage est fait ! Il est maintenant temps de transformer nos données pour qu’elles soient prêtes à être utilisées dans un projet.

Séparation des chaînes de caractères dans une colonne avec .split

En général, nous voulons que les colonnes contiennent uniquement des données numériques et non des symboles comme le -. Pour se débarrasser du trait d’union, nous utiliserons .split et activerons le paramètre expand pour placer la sortie dans deux nouvelles colonnes « HomeGoals » et « AwayGoals ».

Ensuite, nous supprimons la colonne des scores avec .drop.

df_historical_data[['HomeGoals', 'AwayGoals']] = df_historical_data['score'].str.split('–', expand=True)
df_historical_data.drop('score', axis=1, inplace=True)

Renommer des colonnes avec .rename et changer les types de données avec .astype

Renommons les noms de nos colonnes pour qu’ils aient une meilleure apparence.

df_historical_data.rename(columns={'home': 'HomeTeam', 'away': 'AwayTeam', 
                                   'year':'Year'}, inplace=True)

De plus, voyons les types de données actuels en utilisant .dtypes et vérifions qu’ils ont le bon type de données.

df_historical_data.dtypes
HomeTeam     object
AwayTeam     object
Year          int64
HomeGoals    object
AwayGoals    object
dtype: object

Comme nous pouvons le voir, les colonnes HomeGoals et AwayGoals ont un type de données object. Pour convertir ce type de données en int, nous devons utiliser .astype.

Exportation de DataFrames

Enfin, nous pouvons exporter nos ensembles de données propres vers CSV en utilisant la méthode .to_csv. Exportons les DataFrames df_historical_data et df_fixture.

df_historical_data.to_csv('clean_fifa_worldcup_matches.csv',index=False)
df_fixture.to_csv('clean_fifa_worldcup_fixture.csv',index=False)

Voilà, c’est fait ! Nos données sont maintenant prêtes à être utilisées dans notre projet de prédiction du vainqueur de la coupe du monde 2022.

A lire également