> Prendre en main Pandas, la bibliothèque Python de manipulation de données : DataFrame et Series, lire un CSV, sélectionner, filtrer, grouper avec groupby, nettoyer, agréger et exporter, avec des exemples concrets. *Source : https://coder-studio.com/tutoriels/pandas-python-guide/* --- [// Data & Python](https://coder-studio.com/tutoriels/) # Pandas : manipuler des données en Python Par **Kévin Papot** · publié le 26 janvier 2026 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. ## À lire ensuite - [L’analyse de données avec Python : par où commencer](https://coder-studio.com/tutoriels/analyse-donnees-python/) - [Apprendre Python : le guide pour débuter](https://coder-studio.com/tutoriels/apprendre-python/) - [Lire et écrire un fichier en Python](https://coder-studio.com/tutoriels/lire-ecrire-fichier-python/)