Pandas : manipuler ses données en Python sans se noyer

Pandas est la bibliothèque que tout profil data finit par utiliser tous les jours. Elle compte plusieurs centaines de fonctions, ce qui décourage beaucoup de débutants — à tort : une vingtaine d'opérations couvre 90 % du travail réel. Le reste s'apprend au besoin, en cherchant sur le moment.

Cet article présente ces vingt opérations dans l'ordre où on les rencontre sur un vrai jeu de données, du chargement du fichier jusqu'à l'export du résultat, avec les pièges qui font perdre le plus de temps.

1. Charger et inspecter les données

Tout commence par un fichier. Dans 95 % des cas, un CSV ou un Excel.

import pandas as pd

df = pd.read_csv("ventes.csv")            # séparateur virgule par défaut
df = pd.read_csv("ventes.csv", sep=";")   # fichiers exportés depuis Excel FR
df = pd.read_excel("ventes.xlsx", sheet_name="2026")

Avant toute autre chose, quatre commandes à exécuter systématiquement :

df.shape        # (nombre de lignes, nombre de colonnes)
df.head(10)     # les 10 premières lignes
df.dtypes       # le type de chaque colonne
df.describe()   # statistiques des colonnes numériques

2. Nettoyer : types et valeurs manquantes

Un jeu de données réel n'est jamais propre. Deux problèmes reviennent toujours.

Les types mal détectés

Pandas devine le type de chaque colonne. Il se trompe dès qu'une valeur parasite traîne (un « N/A », un espace, une virgule décimale).

df["montant"] = pd.to_numeric(df["montant"], errors="coerce")
df["date"]    = pd.to_datetime(df["date"], errors="coerce", dayfirst=True)

errors="coerce" transforme les valeurs illisibles en NaN au lieu de faire planter le script. Vous décidez ensuite quoi en faire — mais vous savez combien il y en a.

Les valeurs manquantes

df.isna().sum()                    # combien de manquants par colonne
df = df.dropna(subset=["montant"]) # supprimer les lignes sans montant
df["remise"] = df["remise"].fillna(0)

Supprimer ou remplacer n'est pas un choix technique mais un choix métier. Une remise absente vaut probablement zéro ; un âge absent ne vaut certainement pas zéro.

3. Sélectionner : loc et iloc

C'est la source d'erreur numéro un chez les débutants. La règle est pourtant simple :

Le filtrage par condition se lit comme une phrase :

gros = df.loc[(df["montant"] > 1000) & (df["region"] == "Alger")]

Notez les parenthèses autour de chaque condition et l'usage de & / | plutôt que de and / or : pandas travaille sur des vecteurs, pas sur des booléens simples.

4. Grouper et agréger : le cœur du métier

La logique groupby remplace la quasi-totalité des boucles Python qu'écrivent les débutants. C'est aussi ce qui rend pandas rapide.

df.groupby("region")["montant"].sum()

df.groupby(["region", "mois"]).agg(
    total=("montant", "sum"),
    panier_moyen=("montant", "mean"),
    nb_ventes=("montant", "count"),
).reset_index()

Le .reset_index() final ramène le résultat à un DataFrame classique, avec les colonnes de groupement redevenues de vraies colonnes. Sans lui, la suite du code devient inutilement compliquée.

Le tableau croisé

pd.pivot_table(df, index="region", columns="mois",
               values="montant", aggfunc="sum", fill_value=0)

C'est l'équivalent exact d'un tableau croisé dynamique Excel, en une ligne et reproductible.

5. Fusionner plusieurs sources

Rarement toute l'information tient dans un seul fichier. merge fonctionne comme un JOIN SQL :

complet = ventes.merge(clients, on="client_id", how="left")

Pour empiler des fichiers de même structure — douze mois d'exports par exemple :

annee = pd.concat([janvier, fevrier, mars], ignore_index=True)

6. Créer et transformer des colonnes

df["marge"]      = df["prix_vente"] - df["prix_achat"]
df["taux_marge"] = df["marge"] / df["prix_vente"]
df["mois"]       = df["date"].dt.month
df["categorie"]  = df["montant"].apply(lambda x: "élevé" if x > 1000 else "standard")

apply est pratique mais lent sur de gros volumes. Quand une opération vectorielle existe, préférez-la :

# Plus rapide que apply sur des centaines de milliers de lignes
import numpy as np
df["categorie"] = np.where(df["montant"] > 1000, "élevé", "standard")

7. Trier, exporter, et s'arrêter là

resultat = df.sort_values("montant", ascending=False).head(20)
resultat.to_csv("top20.csv", index=False)
resultat.to_excel("top20.xlsx", index=False)

index=False évite la colonne parasite « Unnamed: 0 » que tout le monde a déjà vue dans un fichier reçu par e-mail.

Les cinq pièges qui coûtent le plus de temps

• Le SettingWithCopyWarning — vous modifiez une copie sans le savoir. Utilisez df.loc[condition, "colonne"] = valeur plutôt qu'un double indexage.
• Les colonnes avec des espaces — df.columns = df.columns.str.strip().str.lower() dès le chargement règle le problème définitivement.
• Les doublons invisibles — df.duplicated().sum() avant toute agrégation.
• Les dates au format américain — précisez toujours dayfirst=True sur des données locales.
• Les chaînes avec des majuscules incohérentes — « Alger », « alger » et « ALGER » sont trois groupes différents pour groupby.

Et ensuite ?

Une fois ces vingt opérations maîtrisées, vous êtes autonome sur l'essentiel du travail d'analyse. La suite logique est la visualisation (matplotlib ou seaborn), puis la modélisation — c'est le moment de passer au Machine Learning proprement dit.

Si vous n'avez pas encore installé Python sur votre machine, Google Colab permet d'exécuter tout le code de cet article dans un navigateur, sans rien installer. Et pour vous entraîner sur des données réelles, notre sélection de 10 projets pour débutants fournit les jeux de données et l'objectif de chacun.

En data, on passe 70 % de son temps à préparer les données et 30 % à modéliser. Maîtriser pandas, ce n'est pas maîtriser un outil parmi d'autres : c'est maîtriser la partie la plus longue du métier.