Bienvenue dans l'univers passionnant de la data science ! Si tu es en BUT ou que tu t'intéresses de près à ce domaine, tu sais que l'un des premiers défis est de savoir quoi faire avec toutes ces données. C'est là qu'intervient l'Analyse Exploratoire de Données (AED, ou EDA en anglais). Et pour mener à bien cette mission, deux outils sont absolument incontournables : Python et la bibliothèque pandas.
Dans cet article, nous allons te guider à travers les étapes fondamentales de l'AED en utilisant Python et pandas. Tu vas apprendre à charger des données, à les inspecter, à les nettoyer et à commencer à en tirer tes premières conclusions. Prépare-toi à transformer des fichiers bruts en informations précieuses !
Pourquoi Python et Pandas pour l'AED ?
Python est un langage de programmation polyvalent, très apprécié pour sa lisibilité et sa richesse en bibliothèques spécialisées. En data science, il est devenu la norme de facto grâce à des outils comme pandas, NumPy, Matplotlib et bien d'autres.
Pandas, en particulier, est une bibliothèque Python qui fournit des structures de données performantes et faciles à utiliser, comme le DataFrame. Un DataFrame, c'est un peu comme une feuille de calcul ou une table de base de données, mais avec toute la puissance de Python pour la manipuler. Il te permet de charger des données depuis divers formats (CSV, Excel, SQL.), de les filtrer, de les trier, de les regrouper, de gérer les valeurs manquantes et de calculer des statistiques descriptives en un clin d'œil.
Le saviez-vous : Le nom "pandas" vient du terme "panel data", une expression statistique désignant des ensembles de données contenant des observations pour plusieurs sujets mesurées sur plusieurs périodes de temps. Il fait aussi un clin d'œil au panda géant, l'animal emblème.
Étape 1 : Préparer ton Environnement et Charger les Données
Avant de te lancer, assure-toi d'avoir Python installé sur ta machine. Si tu utilises un environnement comme Anaconda, pandas est généralement inclus. Sinon, tu peux l'installer via pip :
pip install pandas matplotlib seaborn jupyter
Pour cet article, nous utiliserons Jupyter Notebook (ou JupyterLab), un environnement interactif idéal pour l'analyse de données. Lance-le en tapant `jupyter notebook` dans ton terminal.
Chargement d'un Fichier CSV
Les fichiers CSV (Comma Separated Values) sont l'un des formats les plus courants pour stocker des données. Pandas offre une fonction simple pour les charger.
Supposons que tu aies un fichier nommé `donnees_ventes.csv` dans le même répertoire que ton notebook. Voici comment le charger :
Code :
import pandas as pd
# Charge le fichier CSV dans un DataFrame nommé df
df = pd.read_csv('donnees_ventes.csv')
# Affiche les 5 premières lignes du DataFrame
print(df.head())La méthode `read_csv()` est très puissante et possède nombreux paramètres pour gérer différents types de fichiers CSV (séparateurs différents, encodages, etc.).
Chargement d'autres Formats
Pandas peut aussi charger d'autres types de fichiers :
pd.read_excel('fichier.xlsx')pour les fichiers Excel.pd.read_sql('SELECT * FROM ma_table', ma_connexion_sql)pour lire depuis une base de données SQL.
Étape 2 : Inspecter tes Données
Une fois tes données chargées, il est crucial de comprendre leur structure et leur contenu. C'est le début de l'exploration.
Aperçu Général : `.info()`
La méthode `.info()` te donne un résumé concis de ton DataFrame : le nombre d'entrées, le nombre de colonnes, le nom de chaque colonne, le type de données de chaque colonne (objet, int64, float64, etc.) et le nombre de valeurs non nulles.
Code :
print(df.info())Cela te permet de repérer rapidement les colonnes qui pourraient contenir des valeurs manquantes.
Statistiques Descriptives : `.describe()`
La méthode `.describe()` génère des statistiques descriptives pour les colonnes numériques : nombre d'éléments, moyenne, écart-type, minimum, quartiles (25%, 50% - la médiane, 75%) et maximum.
Code :
print(df.describe())Si tu veux inclure les colonnes non numériques (comme les chaînes de caractères), utilise :
Code :
print(df.describe(include='all'))Pour les colonnes catégorielles, `.describe(include='all')` te donnera le nombre d'entrées uniques, la valeur la plus fréquente (top) et sa fréquence (freq).
Dimensions du DataFrame : `.shape`
L'attribut `.shape` te renvoie un tuple indiquant le nombre de lignes et le nombre de colonnes de ton DataFrame. C'est utile pour avoir une idée de la taille de ton jeu de données.
Code :
print(df.shape)Afficher les Valeurs Uniques : `.unique()` et `.nunique()`
Pour les colonnes catégorielles, il est souvent utile de savoir quelles sont les valeurs possibles.
- `.unique()` renvoie un tableau des valeurs uniques dans une colonne (une Series pandas).
- `.nunique()` renvoie le nombre de valeurs uniques.
Code :
# Pour une colonne spécifique, par exemple 'categorie_produit'
print(df['categorie_produit'].unique())
print(df['categorie_produit'].nunique())Exemple Concret : Tu charges un jeu de données sur les étudiants d'une université. En utilisant `df.info()`, tu pourrais découvrir que la colonne 'moyenne' est de type 'object' (chaîne de caractères) au lieu de 'float64' (nombre décimal). Cela t'indique qu'il y a probablement des caractères non numériques (comme des virgules mal placées ou des symboles) qu'il faudra nettoyer avant de pouvoir calculer la moyenne de toutes les moyennes.
Étape 3 : Nettoyer les Données
C'est souvent la partie la plus longue mais la plus cruciale de l'AED. Des données "sales" mènent à des analyses erronées.
Gestion des Valeurs Manquantes
Pandas offre plusieurs façons de gérer les valeurs manquantes (souvent représentées par `NaN` - Not a Number).
- Détection : `df.isnull().sum()` te donne le nombre de valeurs manquantes pour chaque colonne.
- Suppression : `df.dropna()` supprime les lignes (ou colonnes, avec `axis=1`) contenant des valeurs manquantes. Sois prudent avec cette méthode, elle peut réduire drastiquement la taille de ton jeu de données.
- Imputation : Remplacer les valeurs manquantes par une valeur calculée (moyenne, médiane, mode). Par exemple, pour remplacer les valeurs manquantes de la colonne 'age' par la moyenne de cette colonne :
Code :
moyenne_age = df['age'].mean()
df['age'].fillna(moyenne_age, inplace=True)L'option `inplace=True` modifie le DataFrame directement.
Correction des Types de Données
Comme vu dans l'exemple, il peut être nécessaire de convertir des colonnes dans le bon type de données.
Code :
# Convertir la colonne 'prix' de type 'object' à 'float64'
df['prix'] = pd.to_numeric(df['prix'], errors='coerce')
# 'errors='coerce'' transformera les valeurs non convertibles en NaNSuppression des Doublons
Des entrées dupliquées peuvent fausser tes analyses.
Code :
# Supprime les lignes entièrement dupliquées
df.drop_duplicates(inplace=True)Piège : La méthode `dropna()` supprime toutes les lignes qui contiennent au moins une valeur manquante. Si tu as beaucoup de colonnes, cela peut te laisser avec très peu de données. Il est souvent préférable d'imputer les valeurs manquantes lorsque c'est possible et judicieux, ou de ne supprimer que les lignes où la valeur manquante est dans une colonne cruciale pour ton analyse.
Étape 4 : Explorer et Analyser les Données
Maintenant que tes données sont plus propres, tu peux commencer à les explorer en profondeur.
Filtrage et Sélection de Données
Pandas te permet de sélectionner des sous-ensembles de tes données très facilement.
- Sélection par colonne : `df['nom_colonne']` ou `df[['colonne1', 'colonne2']]`.
- Filtrage par condition : Utilise des opérateurs logiques (`==`, `!=`, `>`, `<`, `>=`, `<=`, `&` pour ET, `|` pour OU).
Code :
# Sélectionner toutes les ventes du produit 'Ordinateur'
ordinateurs_ventes = df[df['produit'] == 'Ordinateur']
# Sélectionner les ventes de plus de 1000 euros
ventes_elevees = df[df['prix'] > 1000]
# Sélectionner les ventes de 'Ordinateur' avec un prix > 1000
ordinateur_cher = df[(df['produit'] == 'Ordinateur') & (df['prix'] > 1000)]Groupement et Agrégation : `.groupby()`
C'est une fonctionnalité extrêmement puissante pour résumer tes données par catégories.
Code :
# Calculer le chiffre d'affaires total par catégorie de produit
ventes_par_categorie = df.groupby('categorie_produit')['prix'].sum()
# Calculer le nombre de ventes par région et la moyenne des prix
stats_par_region = df.groupby('region').agg({
'id_vente': 'count', # Compte le nombre de ventes
'prix': 'mean' # Calcule le prix moyen
})
print(stats_par_region)Visualisation des Données
L'AED n'est pas complète sans visualisation. Pandas s'intègre bien avec Matplotlib et Seaborn.
Code (avec Seaborn pour plus de simplicité) :
import matplotlib.pyplot as plt
import seaborn as sns
# Histogramme de la distribution des prix
sns.histplot(df['prix'], kde=True) # kde=True ajoute une courbe de densité
plt.title('Distribution des Prix des Produits')
plt.xlabel('Prix (€)')
plt.ylabel('Fréquence')
plt.show()
# Diagramme en barres du chiffre d'affaires par catégorie
ventes_par_categorie.plot(kind='bar')
plt.title('Chiffre d\'Affaires par Catégorie')
plt.xlabel('Catégorie')
plt.ylabel('Chiffre d\'Affaires (€)')
plt.xticks(rotation=45) # Rotation des étiquettes pour meilleure lisibilité
plt.tight_layout() # Ajuste la mise en page
plt.show()
# Nuage de points : relation entre prix et quantité vendue
sns.scatterplot(x='quantite', y='prix', data=df)
plt.title('Relation entre Prix et Quantité Vendue')
plt.show()Comment ORBITECH Peut T'aider
Comprendre les bases de Python et pandas est essentiel pour tout étudiant en data science. Chez ORBITECH AI Academy, nous avons conçu des modules d'apprentissage interactifs spécialement pour toi. Tu y trouveras des tutoriels guidés, des exercices pratiques sur des jeux de données réels et des projets pour te permettre de maîtriser ces outils. Nos formateurs, experts en data science, sont là pour répondre à tes questions et t'accompagner dans ton apprentissage, afin que tu puisses mener tes propres analyses exploratoires en toute confiance.
Conclusion
L'Analyse Exploratoire de Données avec Python et pandas est une compétence fondamentale pour quiconque souhaite se lancer dans la data science. Tu as vu comment charger des données, les inspecter avec `.info()` et `.describe()`, les nettoyer en gérant les valeurs manquantes et les types de données, et enfin, comment les explorer en utilisant le filtrage, le regroupement et la visualisation.
Ces premières étapes sont la base sur laquelle tu bâtiras toutes tes analyses futures. N'aie pas peur d'expérimenter, de tester différentes approches et surtout, de visualiser tes données. C'est en pratiquant que tu deviendras un maître de l'AED. Alors, lance-toi, prends un jeu de données et commence ton exploration dès aujourd'hui !