Nettoyage et prétraitement des données brutes

Dans cet article de blog, nous allons explorer les différents défis auxquels vous pouvez être confronté avec les données scrappées et offrir un guide détaillé sur la façon de les nettoyer et de les prétraiter pour obtenir des résultats optimaux. Que vous soyez un analyste de données chevronné ou un scrapeur web en herbe utilisant Python, ce guide a pour but de vous fournir des conseils pratiques et des techniques pour nettoyer efficacement vos ensembles de données.

Des pièges les plus courants aux meilleures pratiques en passant par des exemples concrets, restez à l'écoute pour apprendre comment rendre vos données récupérées aussi propres et exploitables que possible.

Défis courants liés aux données récupérées

Les données extraites s'accompagnent souvent d'une série de problèmes. Les irrégularités, les incohérences et les valeurs manquantes comptent parmi les problèmes les plus courants. Ces problèmes peuvent considérablement entraver votre capacité à analyser efficacement les données.

Exemples d'irrégularités et d'incohérences

Les irrégularités peuvent prendre de nombreuses formes. Imaginez, par exemple, que vous récupériez les prix des produits sur plusieurs sites de commerce électronique. Un site peut afficher des prix TTC, tandis qu'un autre peut les exclure. Les unités de mesure peuvent également différer - pensez aux kilogrammes par rapport aux livres. De telles incohérences nécessitent un nettoyage et un prétraitement approfondis pour garantir l'exactitude et la comparabilité des données.

Impact d'une mauvaise qualité des données

Des données de mauvaise qualité ne faussent pas seulement vos résultats, mais peuvent également conduire à des décisions commerciales erronées. Pour les analystes de données, la phase de nettoyage n'est donc pas négociable. Des données correctement nettoyées garantissent que les analyses ultérieures sont à la fois fiables et pertinentes.

Outils et techniques de nettoyage des données

Guide pas à pas pour l'utilisation des Pandas

Voyons un exemple basique de nettoyage d'un ensemble de données à l'aide de Pandas. Supposons que vous ayez récupéré des données sur les films, mais que ces données contiennent des valeurs manquantes et un formatage incohérent.

Étape 1 - Chargement des données :

   import pandas as pd
   df = pd.read_csv('films.csv')

Étape 2 - Traitement des valeurs manquantes :

   df.fillna(method='ffill', inplace=True)

Étape 3 - Normalisation des formats :

df['release_date'] = pd.to_datetime(df['release_date'])

Étape 4 - Suppression des doublons :

df.drop_duplicates(inplace=True)

Tirer parti de NumPy pour le nettoyage des données

NumPy complète Pandas en fournissant des fonctions mathématiques de haute performance. Par exemple, pour traiter les valeurs aberrantes, vous pouvez utiliser la fonction `np.where` de NumPy pour plafonner les valeurs extrêmes.

import pandas as pd
import numpy as np
# Sample data
data = {
   'A': [1, 2, 3, 1000, 5],
   'B': [10, 20, 30, 40, 5000]
}
# Create a DataFrame
df = pd.DataFrame(data)
# Define a threshold to cap the values
threshold_A = 100
threshold_B = 100
# Use np.where to cap the extreme values
df['A'] = np.where(df['A'] > threshold_A, threshold_A, df['A'])
df['B'] = np.where(df['B'] > threshold_B, threshold_B, df['B'])
print("DataFrame after handling outliers:")
print(df)

Voici le résultat du script ci-dessus :

DataFrame après traitement des valeurs aberrantes :
   A B
0 1 10
1 2 20
2 3 30
3 100 40
4 5 100

Bonnes pratiques de prétraitement des données scrapées

Normalisation des formats et des structures de données

La normalisation est cruciale lorsqu'il s'agit de sources de données multiples. Veillez à ce que les points de données similaires provenant de différentes sources respectent le même format. Par exemple, les dates doivent être présentées dans un format standard comme ISO 8601 afin d'éviter toute ambiguïté.

Traitement des données manquantes ou incorrectes

Les données manquantes doivent être traitées de manière appropriée. Des techniques telles que l'imputation permettent de compléter les valeurs manquantes sur la base d'autres données disponibles. Les données incorrectes, en revanche, nécessitent souvent une inspection manuelle ou des algorithmes de validation pour être corrigées.

Assurer la cohérence des données

Les contrôles de cohérence sont essentiels. Utilisez des scripts pour vous assurer que vos données répondent à des règles prédéfinies. Par exemple, si une colonne ne doit contenir que des nombres positifs, écrivez un script de validation pour signaler toute anomalie.

Étude de cas : Application dans le monde réel

Nous allons nous plonger dans un exemple pratique pour voir comment nous pouvons relever certains des défis courants que posent les données récupérées. Nous allons passer en revue le processus de récupération, de nettoyage et d'analyse des données d'un hypothétique site web d'offres d'emploi, en nous concentrant sur les problèmes concrets que vous pourriez rencontrer.

Étape 1 : Récupération de données

Imaginez que vous récupériez des données sur un site web d'offres d'emploi. L'objectif est de collecter les titres des postes, les noms des entreprises et les fourchettes de salaires. Voici un exemple de script Python utilisant BeautifulSoup pour extraire ces données :

from bs4 import BeautifulSoup
import requests
import pandas as pd

url = "https://example-jobsite.com"
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')

jobs = []
for job_post in soup.find_all('div', class_='job'):
    title = job_post.find('h2').text
    company = job_post.find('p', class_='company').text
    salary = job_post.find('span', class_='salary').text
    jobs.append({'title': title, 'company': company, 'salary': salary})

df = pd.DataFrame(jobs)

À ce stade, les données pourraient ressembler à ceci :

Remarquez les incohérences : majuscules différentes, symboles monétaires différents et formatage incohérent des valeurs salariales.

Étape 2 : Nettoyage des données

Il est essentiel de nettoyer ces données avant de pouvoir procéder à une analyse significative. Voyons les différentes étapes :

1. Normaliser les données textuelles : Les titres d'emploi et les noms d'entreprise souffrent souvent d'un formatage incohérent. Nous pouvons les normaliser en les mettant en majuscules de manière uniforme.

df['title'] = df['title'].str.strip().str.title()
df['company'] = df['company'].str.strip().str.title()

Après cette étape, les données seront plus uniformes :

2 : Normaliser les données numériques: Les valeurs salariales peuvent contenir des symboles et des formats différents, ce qui rend les comparaisons directes difficiles. Nous allons supprimer le signe du dollar et les virgules, puis convertir ces chaînes en valeurs numériques.

df['salary'] = df['salary'].str.replace('[\$,]', '').str.replace('USD', '').astype(float)

Désormais, votre colonne des salaires aura des valeurs numériques cohérentes :

3 : Traitement des données manquantes : Supposons qu'il manque des informations sur le salaire dans certaines offres d'emploi. Au lieu de supprimer ces lignes, vous pouvez choisir de compléter les valeurs manquantes sur la base d'une certaine logique, telle que le salaire médian pour ce poste :

df['salary'].fillna(df.groupby('title')['salary'].transform('median'), inplace=True)

Étape 3 : Analyse des données nettoyées

Avec les données nettoyées, vous pouvez maintenant effectuer des analyses significatives. Par exemple, vous pourriez vouloir comprendre la répartition des salaires entre les différents titres de poste :

print(df.groupby('title')['salary'].describe())

Cette commande vous fournira un résumé statistique pour chaque titre d'emploi, vous donnant un aperçu des tendances salariales.

Exemple : Traitement des valeurs aberrantes avec NumPy

Dans certains cas, vos données peuvent contenir des valeurs aberrantes, c'est-à-dire des salaires extrêmement élevés ou bas qui peuvent fausser votre analyse. NumPy peut être utilisé pour éliminer ces valeurs aberrantes :

import numpy as np

# Plafonner les salaires à un seuil (par exemple, 200 000)
salaire_seuil = 200000
df['salary'] = np.where(df['salary'] > threshold_salary, threshold_salary, df['salary'])

print(df)

Après le plafonnement, votre ensemble de données pourrait ressembler à ceci :

Impact sur la compréhension et la prise de décision

En nettoyant et en prétraitant vos données, vous avez transformé un ensemble de données désordonné en une ressource précieuse. Vous pouvez désormais tirer des conclusions en toute confiance, par exemple en identifiant les entreprises les mieux rémunérées ou en analysant les tendances salariales dans les différents secteurs d'activité. Ces informations éclairent directement les stratégies de l'entreprise, telles que l'étalonnage des salaires ou les plans d'acquisition de talents.

Conclusion et prochaines étapes

Dans cet article de blog, nous avons abordé l'importance du nettoyage et du prétraitement des données récupérées. De la compréhension des défis courants à l'exploitation de puissantes bibliothèques Python telles que Pandas et NumPy, votre boîte à outils est maintenant remplie des éléments essentiels.

Rappelez-vous que des données propres ne sont pas un luxe, mais une nécessité pour prendre des décisions précises et fiables. En suivant les meilleures pratiques décrites ici, vous pouvez vous assurer que votre analyse de données est à la fois efficace et efficiente.

Prêt à faire passer votre analyse de données au niveau supérieur ? Commencez à mettre en œuvre ces stratégies dès aujourd'hui et consultez nos autres ressources pour approfondir votre compréhension du nettoyage et du prétraitement des données. Bon grattage !