En tant que data scientist, je consacre environ un tiers de mon temps à analyser les données pour en tirer des informations utiles. Dans cet article, je te présente les outils que j’utilise le plus pour mener une analyse exploratoire de données.
Tu débutes dans la data science ? Des mots comme « analyse exploratoire » te font peur ? Pas d’inquiétude, on avance pas à pas, avec du code à exécuter.
Tu vas découvrir deux outils que j’utilise tous les jours : Jupyter Notebook et la célèbre bibliothèque d’analyse de données Pandas.
En bref : l’analyse exploratoire de données (EDA) est la première étape d’un projet de data science : avant de construire un modèle, tu cherches à comprendre la structure, la qualité et la distribution de tes données. Avec Jupyter Notebook et Pandas, quelques lignes suffisent : read_csv() pour lire le fichier, head(), shape, info() et describe() pour l’inspecter, value_counts() et groupby() pour agréger, puis un filtre avec une série de booléens ou .loc.
Tu peux aussi exécuter tous ces exemples dans ce notebook Google Colab : chaque extrait de code est dans sa propre cellule, prêt à être modifié.
Qu’est-ce que l’analyse exploratoire de données ?
L’analyse exploratoire de données (en anglais EDA, pour Exploratory Data Analysis) est la première étape de tout projet de data science. Avant de construire un modèle, tu cherches à comprendre tes données : leur structure, leur qualité, leur distribution et les relations entre les variables.
Concrètement, tu te poses des questions simples. Combien de lignes et de colonnes ? Quels types de données ? Des valeurs manquantes ? Quelles valeurs reviennent le plus souvent ? Pandas permet d’y répondre en quelques lignes.
Qu’est-ce que Jupyter Notebook et comment l’installer ?
Jupyter Notebook est un environnement interactif où tu écris du code Python accompagné d’explications et où tu l’exécutes cellule par cellule. Parlons d’abord de Jupyter Notebook. Si tu as déjà utilisé la console Python, tu connais son utilité : vérifier qu’une fonction renvoie bien ce que tu attends (ça ne remplace pas un vrai test, mais qui ne l’a jamais fait ?) ou exécuter un traitement coûteux en mémoire. Un environnement interactif a de nombreux avantages.
Jupyter Notebook reprend ce principe : c’est comme la console Python (boucle lecture-évaluation-affichage), mais avec une interface agréable et la possibilité de documenter et d’enregistrer ce que tu as testé.
C’est très pratique : tu rédiges ton analyse avec du code, accompagné d’explications. Pour aller plus loin, découvre aussi les 10 fonctionnalités de Jupyter Notebook à connaître.
Comment installer Jupyter Notebook ?
Pour installer Jupyter, exécute cette commande pip dans ton terminal :
python -m pip install notebookSi tu es sous Linux et que tu n’as pas les droits d’administrateur, installe-le pour ton utilisateur uniquement :
pip3 install --user notebookComment ouvrir Jupyter Notebook ?
Ouvre ensuite ton terminal dans le dossier où tu veux ranger tes notebooks, puis lance :
jupyter notebookC’est aussi simple que ça. Cette commande démarre un serveur sur ton ordinateur et ouvre ton navigateur.
Utilise l’interface pour créer un nouveau notebook et ouvre-le. Le bouton + ajoute une cellule de code, et le bouton « ciseaux » en supprime une.
Chaque cellule s’exécute indépendamment (mais pas simultanément) : place ton curseur dedans et appuie sur Maj + Entrée.
Qu’est-ce que la bibliothèque Pandas ?
Passons à la partie amusante. Pandas est une bibliothèque Python open source, maintenue par la communauté PyData. Elle sert principalement à analyser et traiter des données, notamment les fichiers CSV.

Pour approfondir Pandas, consulte notre guide des 10 astuces Pandas.
Comment générer un jeu de données fictif au format CSV ?
Qu’est-ce qu’un fichier CSV ?
Au cas où tu ne le saurais pas, un fichier CSV (Comma Separated Values) stocke des données sous forme de tableau : chaque ligne du fichier est une ligne du tableau, et les valeurs sont séparées par des virgules.
La première ligne est réservée à l’en-tête, avec le nom de chaque colonne.
Créer un jeu de données
Pour s’entraîner, on commence par générer un jeu de données fictif : des « données d’employés » d’une entreprise qui ne stocke que le prénom, le nom et le salaire de chaque employé. Il sera enregistré dans un fichier CSV.
Générer des dictionnaires de personnes
On utilise d’abord du Python standard pour générer des dictionnaires, chacun représentant une personne. Si tu connais JavaScript, un dictionnaire ressemble à un objet JSON, avec les clés firstname, lastname et salary.
On fixe aussi une graine aléatoire avec random.seed() : tu obtiens ainsi les mêmes résultats que dans cet article.
import random
random.seed(42)
first_names = ["Vincent", "Jessica", "Ivan", "Maria", "Elodie"]
last_names = ["Pernaud", "Evian", "Seri", "Pasta", "Bolivar"]
salaries = [500 * random.randint(10, 30) for _ in range(10)]
def generate_random_person(first_names, last_names, salaries):
return {"firstname": random.choice(first_names),
"lastname": random.choice(last_names),
"salary": random.choice(salaries)}
def generate_people(k):
return [generate_random_person(first_names, last_names, salaries) for _ in range(k)]PythonGénérer un DataFrame Pandas
On génère ensuite un DataFrame Pandas de 50 personnes avec la fonction generate_people(). Chaque colonne du DataFrame est une série Pandas :
import pandas as pd
df = pd.DataFrame(generate_people(50),
columns=["firstname", "lastname", "salary"])
df.to_csv("random_people.csv", index=False)PythonUn DataFrame se crée donc à partir d’une liste de dictionnaires, avec en option (argument columns) les noms de colonnes.
On l’exporte dans un fichier CSV avec la méthode to_csv(). Ici, index=False évite d’écrire l’index dans le fichier.
Résultat : un fichier de 50 personnes, avec des prénoms, noms et salaires tirés au hasard parmi 5 prénoms, 5 noms et 10 salaires.
Comment faire une analyse exploratoire de données avec Pandas ?
Passons à la lecture et à l’exploration des données.
Comment lire un fichier CSV avec Pandas ?
On importe d’abord le fichier CSV dans un DataFrame avec pd.read_csv() :
import pandas as pd
df = pd.read_csv("random_people.csv")PythonComment avoir un aperçu rapide des données ?
Aperçu avec head()
Pour te faire une première idée de tes données, affiche les premières lignes du DataFrame :
df.head(4)Python firstname lastname salary
0 Elodie Pasta 15000
1 Vincent Pernaud 9000
2 Jessica Bolivar 6000
3 Vincent Bolivar 9000df.head(k) affiche les k premières lignes du DataFrame. C’est le moyen le plus simple d’obtenir un aperçu des données.
Dimensions et types avec shape et info()
Deux réflexes à avoir ensuite : connaître la taille du jeu de données avec df.shape, puis consulter les types de colonnes et les valeurs manquantes avec df.info().
print(df.shape)
df.info()Python(50, 3)
<class 'pandas.DataFrame'>
RangeIndex: 50 entries, 0 to 49
Data columns (total 3 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 firstname 50 non-null str
1 lastname 50 non-null str
2 salary 50 non-null int64
dtypes: int64(1), str(2)
memory usage: 1.3 KBSelon ta version de Pandas, les colonnes de texte s’affichent avec le type object ou str. Ici, les 3 colonnes contiennent 50 valeurs non nulles : aucune valeur manquante.
Statistiques avec describe()
La méthode describe() résume les colonnes numériques : moyenne, écart type, minimum, quartiles et maximum.
df.describe()Python salary
count 50.000000
mean 8520.000000
std 3035.436962
min 5000.000000
25% 6500.000000
50% 7000.000000
75% 8875.000000
max 15000.000000Quelles méthodes d’agrégation utiliser ?
Pour afficher une seule série du DataFrame, indexe-la comme un champ de dictionnaire :
df['nom_de_la_colonne']PythonTu peux ensuite appeler sur cette série n’importe quelle méthode d’agrégation habituelle.
Ma méthode préférée est value_counts() : elle affiche chaque valeur et son nombre d’apparitions, par ordre décroissant. Elle donne rapidement une intuition sur la série.
df['salary'].value_counts()Pythonsalary
8500 11
6500 11
6000 6
7000 6
13500 6
15000 4
9000 3
5000 3
Name: count, dtype: int64Les autres méthodes utiles sont mean(), sum(), count() et median() :
print(df['salary'].median())
print(df['salary'].mean())Python7000.0
8520.0Pour comparer des groupes, utilise groupby(). Par exemple, le salaire moyen par nom de famille :
df.groupby('lastname')['salary'].mean()Pythonlastname
Bolivar 8791.666667
Evian 8625.000000
Pasta 8777.777778
Pernaud 8111.111111
Seri 8291.666667
Name: salary, dtype: float64Comment appliquer une fonction personnalisée avec apply() ?
Parfois, tu voudras appliquer à une série une fonction plus complexe, qui n’existe pas dans Pandas. Définis alors ta propre fonction et applique-la avec la méthode apply(). C’est un peu plus lent, mais ça fonctionne très bien pour des fonctions simples et ça ajoute de la flexibilité à ton traitement.
Créer une nouvelle colonne
On crée d’abord une colonne calculée à partir d’une autre colonne :
df["salary_after_tax"] = df["salary"] * .8PythonUtiliser apply()
On définit ensuite une fonction de taxe, et on l’applique directement à la série avec apply() :
def tax(s):
if s >= 6000:
return s * .7
else:
return s * .85
df["salary_after_tax"] = df["salary"].apply(tax)
print(df.head())Python firstname lastname salary salary_after_tax
0 Elodie Pasta 15000 10500.0
1 Vincent Pernaud 9000 6300.0
2 Jessica Bolivar 6000 4200.0
3 Vincent Bolivar 9000 6300.0
4 Elodie Pasta 9000 6300.0Comment filtrer un DataFrame ?
Série de booléens
Pour ne garder que les lignes qui respectent une condition, utilise une série de booléens :
df_low = df[df["salary"] < 6000]
df_high = df[df["salary"] >= 6000]PythonLa condition df["salary"] >= 6000 peut être remplacée par tout ce qui renvoie une série de booléens, par exemple df["nom_de_la_colonne"].apply(f) où f est une fonction qui renvoie un booléen.
Assure-toi que cette série a le même nombre d’éléments que celle que tu filtres.
Tu peux ensuite calculer la moyenne des salaires du DataFrame filtré :
print(df_high["salary"].mean())Python8744.68085106383Comment modifier des lignes filtrées avec .loc ?
Quand tu veux modifier des lignes filtrées, utilise .loc : il sélectionne les lignes et colonnes en une seule opération, directement sur le DataFrame d’origine.
df.loc[df["salary"] < 6000, "salary_after_tax"] = df["salary"] * .85
df.loc[df["salary"] >= 6000, "salary_after_tax"] = df["salary"] * .7
print(df.head())Python firstname lastname salary salary_after_tax
0 Elodie Pasta 15000 10500.0
1 Vincent Pernaud 9000 6300.0
2 Jessica Bolivar 6000 4200.0
3 Vincent Bolivar 9000 6300.0
4 Elodie Pasta 9000 6300.0Ce code donne le même résultat que la fonction tax(), sans passer par apply(). C’est la méthode recommandée : elle est plus rapide et plus lisible.
Si tu veux au contraire travailler sur une copie filtrée sans toucher au DataFrame d’origine, ajoute .copy() à la fin de la ligne :
df_low = df.loc[df["salary"] < 6000].copy()
df_low["salary_after_tax"] = df_low["salary"] * .5
# Le DataFrame d'origine n'a pas changé
print(df["salary_after_tax"].min())Python4200.0Questions fréquentes sur l’analyse exploratoire de données
Qu’est-ce que l’analyse exploratoire de données (EDA) ?
L’EDA (Exploratory Data Analysis) est la première étape de tout projet de data science. Avant de construire un modèle, tu cherches à comprendre tes données : leur structure, leur qualité, leur distribution et les relations entre les variables.
Quelles méthodes Pandas utiliser pour une première exploration ?
head() pour un aperçu des premières lignes, shape pour la taille, info() pour les types de colonnes et les valeurs manquantes, describe() pour les statistiques des colonnes numériques et value_counts() pour la fréquence de chaque valeur.
Comment installer et lancer Jupyter Notebook ?
Installe-le avec python -m pip install notebook (ou pip3 install --user notebook sous Linux sans droits d’administrateur), puis lance jupyter notebook dans le dossier où tu ranges tes notebooks. Une cellule s’exécute avec Maj + Entrée.
Comment filtrer un DataFrame avec Pandas ?
Avec une série de booléens : df[df["salary"] >= 6000] ne garde que les lignes qui respectent la condition. La série doit avoir le même nombre d’éléments que celle que tu filtres.
Faut-il utiliser apply() ou .loc pour modifier des lignes filtrées ?
.loc est la méthode recommandée : elle sélectionne les lignes et les colonnes en une seule opération, directement sur le DataFrame d’origine, et elle est plus rapide et plus lisible que apply().
Conclusion
Dans cet article, tu as vu comment mener une première analyse exploratoire de données avec le duo Jupyter Notebook et Pandas : lire un fichier, l’inspecter avec head(), info() et describe(), agréger, créer des colonnes et filtrer.
Ce sont les réflexes à avoir avant tout projet de data science. Pour ne rien oublier, garde sous la main nos 10 astuces Pandas.
Tu viens de travailler sur des données fictives. Passe maintenant à des jeux de données réels. Le cours Analyse et visualisation de données de DataXp reprend cette démarche (charger, résumer, tracer) sur des données réelles, avec 3 projets guidés. Les 3 premiers chapitres sont gratuits.













