Accueil / pandas

pandas

La bibliothèque Python de référence pour manipuler des données tabulaires : charger un CSV, filtrer, regrouper, calculer des statistiques. Le couteau suisse de toute analyse de données en Python.

À quoi ça sert

Dès que tu travailles avec des données qui ressemblent à un tableau Excel — des lignes, des colonnes, des en-têtes — pandas est l'outil naturel en Python. Il introduit deux structures principales : la Series (une colonne avec un index) et le DataFrame (un tableau entier).

Concrètement, pandas te permet de faire en quelques lignes ce qui prendrait des dizaines de lignes en Python pur :

  • Charger un fichier CSV, Excel, JSON, Parquet, ou même une table SQL.
  • Explorer : combien de lignes, quelles colonnes, valeurs manquantes, statistiques de base.
  • Filtrer et transformer : sélectionner des lignes selon des critères, créer de nouvelles colonnes, nettoyer.
  • Agréger : grouper par catégorie, calculer des moyennes, des sommes, des comptages (le fameux groupby).
  • Joindre deux tableaux entre eux (merge/join, comme en SQL).
pandas, NumPy, Excel… c'est quoi la différence ?

NumPy manipule des tableaux de nombres (matrices) — pandas est construit dessus et y ajoute la notion de colonnes nommées et d'index. Excel fait à peu près la même chose que pandas mais à la souris, sans automatisation ni reproductibilité. pandas, c'est Excel scriptable, capable de traiter des millions de lignes.

Un exemple d'usage

Tu reçois un CSV avec les ventes d'un magasin (date, produit, montant). Tu veux savoir quels produits rapportent le plus :

python 
import pandas as pd

# Charger le CSV en DataFrame
df = pd.read_csv("ventes.csv")

# Aperçu rapide
df.head()
df.info()
df.describe()

# Filtrer les ventes > 100€
grosses = df[df["montant"] > 100]

# Total des ventes par produit, trié
totaux = (
    df.groupby("produit")["montant"]
      .sum()
      .sort_values(ascending=False)
)
print(totaux.head(10))

En 5 lignes utiles, tu as chargé, exploré, filtré et agrégé le fichier. Le DataFrame df se manipule comme un objet Python normal, mais chaque opération est optimisée pour traiter des millions de lignes rapidement (pandas s'appuie sur NumPy en dessous).

How-to : installer et utiliser pandas

  1. Installer pandas dans ton projet

    On reste dans la logique UV : pandas est une dépendance principale (pas de dev) puisqu'on l'utilise dans le code, pas seulement pour les tests.

    bash 
    uv add pandas

    Souvent on l'installe avec ses compagnons : matplotlib pour les graphiques, openpyxl pour lire des fichiers Excel, pyarrow pour le format Parquet.

    bash 
    uv add pandas matplotlib openpyxl pyarrow

  2. Charger un fichier en DataFrame

    pandas reconnaît tout seul de très nombreux formats. Les plus courants :

    python 
    import pandas as pd

df = pd.read_csv("data.csv")
df = pd.read_excel("data.xlsx")
df = pd.read_json("data.json")
df = pd.read_parquet("data.parquet")

    read_csv a beaucoup d'options utiles : sep=";" pour les CSV à point-virgule, encoding="latin-1" pour les fichiers Windows, parse_dates=["date"] pour convertir une colonne en date.

  3. Explorer un DataFrame

    Les premiers réflexes après un chargement :

    python 
    df.head()           # 5 premières lignes
df.tail(10)         # 10 dernières
df.shape             # (nb_lignes, nb_colonnes)
df.columns           # noms des colonnes
df.dtypes            # type de chaque colonne
df.info()           # résumé général + valeurs manquantes
df.describe()       # stats sur les colonnes numériques
df.isna().sum()    # nombre de NaN par colonne

  4. Sélectionner colonnes et lignes

    Trois patterns à connaître par cœur :

    python 
    # 1. Une colonne (renvoie une Series)
df["montant"]

# 2. Plusieurs colonnes (renvoie un DataFrame)
df[["produit", "montant"]]

# 3. Filtrer des lignes par condition (booléen)
df[df["montant"] > 100]
df[(df["montant"] > 100) & (df["produit"] == "A")]

# 4. Sélection par label (loc) ou par position (iloc)
df.loc[0, "montant"]      # ligne 0, colonne "montant"
df.iloc[0, 2]              # ligne 0, 3e colonne
    Le piège des conditions multiples

    En Python on écrirait and, or. En pandas, il faut & et |, et parenthéser chaque condition. Sinon : ValueError.

  5. Créer et modifier des colonnes

    python 
    # Ajouter une colonne calculée
df["ttc"] = df["montant"] * 1.20

# Renommer
df = df.rename(columns={"montant": "montant_ht"})

# Supprimer
df = df.drop(columns=["colonne_inutile"])

# Appliquer une fonction sur une colonne
df["produit_maj"] = df["produit"].str.upper()

  6. Grouper et agréger (groupby)

    L'opération la plus puissante de pandas, l'équivalent du GROUP BY en SQL :

    python 
    # Total des ventes par produit
df.groupby("produit")["montant"].sum()

# Plusieurs agrégations en même temps
df.groupby("produit").agg(
    total=("montant", "sum"),
    moyenne=("montant", "mean"),
    nb_ventes=("montant", "count"),
)

# Grouper par plusieurs colonnes
df.groupby(["region", "produit"])["montant"].sum()

  7. Gérer les valeurs manquantes

    Les vraies données ont des trous. pandas représente les valeurs manquantes par NaN :

    python 
    # Compter les manquants
df.isna().sum()

# Supprimer les lignes avec des NaN
df.dropna()

# Remplacer par une valeur par défaut
df["montant"] = df["montant"].fillna(0)

# Remplacer par la moyenne
df["age"] = df["age"].fillna(df["age"].mean())

  8. Sauvegarder le résultat

    python 
    df.to_csv("resultat.csv", index=False)
df.to_excel("resultat.xlsx", index=False)
df.to_parquet("resultat.parquet")

    index=False évite d'écrire l'index automatique de pandas (0, 1, 2…) comme première colonne du CSV — sinon tu te retrouves avec une colonne Unnamed: 0 à la prochaine relecture.

Aide-mémoire

python (lecture / écriture) 
pd.read_csv("f.csv", sep=";", encoding="latin-1")
pd.read_excel("f.xlsx", sheet_name="Feuil1")
pd.read_parquet("f.parquet")
df.to_csv("out.csv", index=False)
python (exploration) 
df.head(), df.tail(), df.shape, df.columns, df.dtypes
df.info(), df.describe()
df["col"].value_counts()        # comptage par valeur
df["col"].unique()              # valeurs distinctes
df.sort_values("col", ascending=False)
python (transformations) 
df.groupby("cat")["val"].sum()
df.merge(other, on="id", how="left")   # jointure SQL-like
pd.concat([df1, df2], axis=0)        # empiler verticalement
df.pivot_table(index="r", columns="c", values="v")
df["col"].apply(lambda x: x * 2)
python (dates) 
df["date"] = pd.to_datetime(df["date"])
df["annee"] = df["date"].dt.year
df["mois"]  = df["date"].dt.month

pandas et le reste de l'écosystème

pandas est rarement utilisé seul. Il est le maillon central entre les sources de données et les outils d'analyse ou de modélisation.

  • Jupyter — l'environnement naturel pour explorer un DataFrame. Les sorties s'affichent en tableau formaté juste sous la cellule, idéal pour itérer.
  • SQLAlchemy — pd.read_sql(query, engine) charge directement le résultat d'une requête SQL en DataFrame. À l'inverse, df.to_sql() écrit un DataFrame dans une table.
  • Streamlit — passer un DataFrame à st.dataframe(df) affiche un tableau interactif triable. C'est la base de tout dashboard data en Streamlit.
  • FastAPI — pandas n'est pas idéal pour servir une API (on préfère des objets Pydantic), mais on l'utilise souvent dans les fonctions internes de calcul, puis on convertit le résultat en dict avec df.to_dict(orient="records").
  • MLflow — les datasets passés aux modèles scikit-learn sont quasi toujours des DataFrames pandas. MLflow sait logger un DataFrame d'exemple comme « signature » du modèle pour documenter les colonnes attendues.
pandas est lent au-delà de quelques Go

pandas charge tout en mémoire et utilise un seul cœur CPU. Au-delà de quelques millions de lignes, regarde du côté de Polars (API similaire, beaucoup plus rapide) ou DuckDB (SQL sur fichiers). En MLOps, c'est un signal classique de passage à l'échelle.

Pour aller plus loin