Pandas : manipuler des données en Python
Pandas est la bibliothèque Python de référence pour manipuler des données tabulaires : tout ce qui ressemble à un tableau, une feuille de calcul ou une table de base de données. Là où une boucle Python peinerait sur des milliers de lignes, Pandas offre des opérations concises, rapides et lisibles, qui sont devenues le socle de l’analyse de données dans l’écosystème Python.
Ce guide suit le fil naturel d’un travail sur des données : charger un fichier, l’inspecter, sélectionner et filtrer, nettoyer les valeurs douteuses, regrouper pour agréger, puis exporter le résultat. Chaque étape est illustrée par un exemple que vous pouvez reproduire.
Les deux structures de base
La Series : une colonne étiquetée
Une Series est un tableau à une dimension : une suite de valeurs, chacune associée à une étiquette d’index. C’est, en pratique, une colonne isolée.
import pandas as pd
temperatures = pd.Series([18, 21, 19, 23], index=["lun", "mar", "mer", "jeu"])
print(temperatures["mar"]) # 21
print(temperatures.mean()) # 20.25
L’index (lun, mar…) permet d’accéder aux valeurs par un nom plutôt que par une position, comme un dictionnaire enrichi de méthodes de calcul.
Le DataFrame : un tableau complet
Le DataFrame est la structure centrale de Pandas : un tableau à deux dimensions, avec des lignes et des colonnes nommées. On peut le voir comme un ensemble de Series partageant le même index.
data = {
"ville": ["Paris", "Lyon", "Marseille"],
"population": [2148000, 513000, 861000],
"region": ["IDF", "ARA", "PACA"],
}
df = pd.DataFrame(data)
print(df)
Chaque colonne peut avoir son propre type (texte, entier, date), et toutes les opérations qui suivent s’appliquent à cette structure.
Charger des données depuis un CSV
La lecture de base
Dans la vraie vie, les données viennent rarement d’un dictionnaire écrit à la main mais d’un fichier. read_csv() lit un fichier CSV et le transforme en DataFrame.
df = pd.read_csv("ventes.csv")
Pandas devine les séparateurs et les types courants. Quand le fichier sort de l’ordinaire, quelques paramètres suffisent à l’ajuster :
df = pd.read_csv(
"ventes.csv",
sep=";", # séparateur point-virgule (fréquent en France)
encoding="utf-8",
parse_dates=["date"], # convertit la colonne date en vraies dates
)
Inspecter avant de travailler
Avant toute manipulation, on regarde ce qu’on a. Trois méthodes suffisent pour se faire une idée : head() affiche les premières lignes, info() liste les colonnes et leurs types, describe() donne les statistiques des colonnes numériques.
print(df.head(3)) # les 3 premières lignes
print(df.info()) # types et valeurs manquantes
print(df.describe()) # moyenne, min, max, quartiles
Ce réflexe d’inspection vous évite de partir sur de fausses hypothèses.
Sélectionner et filtrer
Choisir des colonnes
On accède à une colonne par son nom, entre crochets. Pour plusieurs colonnes, on passe une liste.
prix = df["prix"] # une Series
extrait = df[["produit", "prix"]] # un DataFrame réduit
Sélectionner des lignes avec loc et iloc
Pandas distingue deux façons de cibler des lignes : loc par étiquette d’index, iloc par position numérique.
print(df.loc[0]) # la ligne dont l'étiquette d'index est 0
print(df.iloc[0]) # la première ligne, quelle que soit son étiquette
print(df.loc[0:2, "prix"]) # colonne prix, lignes 0 à 2 incluses
Filtrer par condition
C’est l’opération la plus fréquente : ne garder que les lignes qui respectent un critère. On construit un masque booléen que l’on passe entre crochets.
chers = df[df["prix"] > 100] # une condition
paris_chers = df[(df["ville"] == "Paris") & (df["prix"] > 100)] # deux conditions
Attention aux parenthèses et à l’usage de & (et) et | (ou) : Pandas exige ces opérateurs, pas les mots-clés and et or.
Nettoyer les données
Repérer les valeurs manquantes
Les fichiers réels contiennent des trous. isna() repère les valeurs manquantes (NaN) et se combine à sum() pour les compter colonne par colonne.
print(df.isna().sum()) # nombre de valeurs manquantes par colonne
Traiter les valeurs manquantes
Deux stratégies principales : supprimer les lignes concernées avec dropna(), ou les remplir avec fillna(). Le choix dépend de la proportion de trous et de l’importance de la colonne.
df_propre = df.dropna(subset=["prix"]) # supprime les lignes sans prix
df["prix"] = df["prix"].fillna(0) # ou remplit par 0
df["ville"] = df["ville"].fillna("Inconnue") # remplit du texte manquant
Corriger les types et les doublons
Une colonne numérique parfois lue comme du texte, des lignes en double : deux corrections classiques.
df["prix"] = pd.to_numeric(df["prix"], errors="coerce") # force en nombre
df = df.drop_duplicates() # retire les doublons
errors="coerce" transforme les valeurs illisibles en NaN plutôt que de faire échouer toute la conversion, ce qui vous laisse ensuite les traiter proprement.
Regrouper et agréger avec groupby
Le principe
groupby() est l’outil le plus puissant de Pandas. Il applique le schéma « diviser, appliquer, combiner » : on divise les lignes en groupes selon une colonne, on applique un calcul à chaque groupe, on recombine les résultats.
# Chiffre d'affaires total par région
ca_region = df.groupby("region")["montant"].sum()
print(ca_region)
Pandas a séparé les lignes par région, sommé les montants de chacune, puis renvoyé une Series indexée par région.
Plusieurs agrégations d’un coup
agg() permet d’appliquer plusieurs calculs simultanément, et de nommer les colonnes de sortie.
resume = df.groupby("region").agg(
total=("montant", "sum"),
moyenne=("montant", "mean"),
nb_ventes=("montant", "count"),
)
print(resume)
Grouper sur plusieurs colonnes
On peut croiser deux dimensions en passant une liste à groupby().
detail = df.groupby(["region", "produit"])["montant"].sum()
Le résultat est indexé sur les deux niveaux, région puis produit : une table croisée prête à être analysée.
Trier et calculer de nouvelles colonnes
Trier
sort_values() ordonne selon une ou plusieurs colonnes.
top = df.sort_values("montant", ascending=False).head(10) # les 10 plus grosses ventes
Créer une colonne dérivée
On ajoute une colonne en l’affectant directement ; les opérations sont vectorisées, donc appliquées à toutes les lignes en une fois, sans boucle.
df["ttc"] = df["prix"] * 1.20 # TVA à 20 %
df["marge"] = df["prix"] - df["cout"]
Cette approche vectorisée est à la fois plus lisible et bien plus rapide qu’une boucle Python ligne par ligne.
Exporter le résultat
Une fois vos données transformées, vous les enregistrez pour les partager ou les réutiliser. Pandas écrit dans les mêmes formats qu’il sait lire.
df.to_csv("resultat.csv", index=False) # CSV, sans la colonne d'index
resume.to_excel("rapport.xlsx", sheet_name="CA") # fichier Excel
df.to_json("export.json", orient="records") # JSON, une entrée par ligne
Le paramètre index=False évite d’ajouter une colonne d’index numérique dont vous n’avez généralement pas besoin dans un CSV de sortie.
En résumé
Pandas structure tout le travail sur des données tabulaires autour du DataFrame : on charge avec read_csv(), on inspecte avec head() et info(), on filtre avec des masques booléens, on nettoie avec fillna() et dropna(), on agrège avec groupby(), et on exporte avec to_csv(). Ces quelques verbes couvrent l’immense majorité des tâches quotidiennes. Le meilleur moyen de les ancrer reste de prendre un vrai fichier CSV et de refaire chaque étape sur vos propres données.