Python
GroupBy et agrégations avec pandas
Construisez des synthèses pandas fiables en définissant la granularité, les règles de chiffre d’affaires, le traitement des nulls et les jointures avant de regrouper des commandes réelles.
Dans cet article
Une agrégation n’est fiable que si les lignes qui y entrent le sont. Avant de sommer un chiffre d’affaires, définissez les statuts qui comptent, le traitement des doublons, la signification des prix manquants et si l’enrichissement avec les produits a préservé la granularité des commandes.
Problème
Vous avez besoin du chiffre d’affaires mensuel des commandes terminées par catégorie de produit, ainsi que du nombre de commandes, des unités et de la valeur moyenne par commande. Le fichier des commandes contient des doublons, des champs numériques manquants et une référence à un produit qui n’existe pas dans le catalogue.
Jeux de données utilisés
Téléchargez l’Orders Dataset et le Products Dataset :
Les commandes fournissent les transactions ; les produits, la catégorie. Les garder séparés reflète un flux classique entre faits et dimensions.
Code : préparer une entrée validée
from pathlib import Path
import pandas as pd
data = Path("data")
orders = pd.read_csv(data / "orders.csv", parse_dates=["order_date"])
products = pd.read_csv(data / "products.csv")
orders["quantity"] = pd.to_numeric(orders["quantity"], errors="coerce")
orders["unit_price"] = pd.to_numeric(orders["unit_price"], errors="coerce")
clean_orders = orders.drop_duplicates().copy()
completed = clean_orders.loc[clean_orders["status"].eq("Completed")].copy()
completed["revenue"] = completed["quantity"] * completed["unit_price"]
completed["order_month"] = completed["order_date"].dt.to_period("M").astype(str)Cet exemple supprime les lignes en double exact, car ce sont des doublons pédagogiques connus. Il ne déduplique pas sur le seul order_id sans examiner les conflits. Il laisse aussi le chiffre d’affaires inconnu à l’état manquant au lieu de le remplacer par zéro.
Code : enrichir, valider et agréger
enriched = completed.merge(
products[["product_id", "category"]],
on="product_id",
how="left",
validate="many_to_one",
indicator=True,
)
unmatched = enriched.loc[enriched["_merge"].eq("left_only")]
print("Unmatched completed product rows:", len(unmatched))
summary = (
enriched.loc[enriched["_merge"].eq("both")]
.groupby(["order_month", "category"], as_index=False, dropna=False)
.agg(
order_count=("order_id", "nunique"),
units=("quantity", "sum"),
revenue=("revenue", "sum"),
average_order_value=("revenue", "mean"),
)
.sort_values(["order_month", "revenue"], ascending=[True, False])
)
summary[["revenue", "average_order_value"]] = summary[
["revenue", "average_order_value"]
].round(2)
print(summary.head(10))validate="many_to_one" garantit que chaque clé produit apparaît au plus une fois côté produits. Sans cette validation, un produit dupliqué par erreur pourrait multiplier les commandes et gonfler le chiffre d’affaires. L’indicateur du merge empêche les transactions sans correspondance de disparaître sans que personne ne s’en aperçoive. Joindre et fusionner des DataFrames avec pandas détaille ce modèle.
Résultat
La sortie contient une ligne par mois et par catégorie :
| order_month | category | order_count | units | revenue | average_order_value |
|---|---|---|---|---|---|
| 2025-01 | Electronics | … | … | … | … |
| 2025-01 | Office | … | … | … | … |
| 2025-01 | Accessories | … | … | … | … |
Les points de suspension sont volontaires : exécutez le code sur les fichiers déterministes pour obtenir les valeurs complètes. Un tutoriel doit montrer la forme et le sens du résultat sans recopier des centaines de lignes.
Explication : granularité et traitement des nulls
L’agrégation nommée rend explicites les noms de sortie et les opérations sources. nunique compte les identifiants de commande, alors que size compterait les lignes. Les deux diffèrent en présence de doublons ou de commandes à plusieurs lignes. Ce jeu de données comporte une ligne par enregistrement de commande, mais les systèmes de commandes en production ont souvent une granularité d’en-tête et une granularité de ligne de commande.
La plupart des fonctions d’agrégation ignorent les valeurs numériques manquantes. Ce comportement peut être pratique, mais aussi dangereux. Une somme de chiffre d’affaires peut sembler plausible alors que certaines commandes terminées n’ont ni prix ni quantité. Mesurez l’exhaustivité en même temps que le résultat :
quality = completed.agg(
rows=("order_id", "size"),
missing_quantity=("quantity", lambda values: values.isna().sum()),
missing_price=("unit_price", lambda values: values.isna().sum()),
missing_revenue=("revenue", lambda values: values.isna().sum()),
)
print(quality)Pour les regroupements sur des colonnes catégorielles, décidez si les catégories non observées doivent apparaître. Le comportement et les valeurs par défaut de pandas peuvent changer selon les versions : définissez délibérément les options utiles lorsque la stabilité de la forme de sortie compte.
Erreurs fréquentes
- Sommer avant d’avoir supprimé les doublons d’entrée connus.
- Regrouper des prix de transaction sans calculer d’abord quantité × prix.
- Utiliser le nombre de lignes lorsque la métrique exige des commandes distinctes.
- Laisser une jointure de plusieurs à plusieurs multiplier les mesures.
- Écarter des clés sans correspondance par une jointure interne sans les signaler.
- Traiter les nulls ignorés comme si toutes les valeurs sources étaient complètes.
- Arrondir les entrées avant l’agrégation au lieu d’arrondir ensuite les valeurs de présentation.
À vous de jouer
Construisez une synthèse par statut contenant le nombre de lignes, les clients distincts, les unités, le chiffre d’affaires et le chiffre d’affaires manquant. Calculez ensuite le chiffre d’affaires par catégorie de toutes les commandes non annulées et comparez-le au chiffre d’affaires des seules commandes terminées. Expliquez pourquoi les transactions retournées et en attente changent l’interprétation.
Enfin, rapprochez le total général de la sortie regroupée des mêmes lignes filtrées avant regroupement. Si les totaux diffèrent, examinez la jointure, le traitement des nulls et la granularité plutôt que de forcer les chiffres à concorder.
Notes de production
Publiez les définitions des agrégations avec la sortie. Le « chiffre d’affaires » nécessite une règle de statut, une hypothèse de devise, un traitement des taxes, une politique de retours et une date d’effet. Deux expressions groupby techniquement correctes peuvent répondre à des questions métier différentes. Les noms de métriques doivent rendre visibles les distinctions importantes plutôt que de dépendre d’un contexte de notebook qui disparaîtra.
Le rapprochement est plus solide lorsqu’il porte sur plusieurs dimensions : lignes sources, commandes distinctes, somme des quantités, somme du chiffre d’affaires, clés sans correspondance et mesures manquantes. Conservez ces contrôles avec l’exécution. Si la transformation est relancée, des entrées et un code identiques doivent produire des contrôles identiques.
La consommation de mémoire peut augmenter pendant le regroupement, car pandas construit des clés et des résultats intermédiaires. Réduisez les colonnes avant l’opération, utilisez des types catégoriels adaptés aux dimensions répétées et testez avec une cardinalité représentative. Le traitement par blocs (chunks) est possible pour les agrégats additifs, mais les moyennes exigent de conserver numérateur et dénominateur, et les comptages distincts sont plus difficiles à combiner exactement. Lorsque les données ne tiennent plus confortablement en mémoire ou nécessitent une exécution distribuée, conservez le contrat de la métrique et déplacez le calcul vers un moteur plus adapté.
Avant de publier la synthèse, vérifiez son schéma autant que ses totaux. L’ordre des colonnes, les types numériques, la précision et l’orthographe des catégories font partie du contrat avec le consommateur. Écrivez un petit test sur un sous-ensemble connu dont le résultat peut être calculé à la main. Ce jeu de test détecte les changements de filtrage et de traitement des nulls plus clairement qu’un grand instantané dont les relecteurs ne peuvent pas expliquer les chiffres par eux-mêmes.
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
Continuer à apprendre
- Aide-mémoireGroupBy et agrégations avec pandasRegroupez des données pandas par clés métier, calculez des agrégations fiables, conservez le contexte de chaque ligne avec transform et évitez les erreurs courantes liées aux valeurs nulles, aux doublons et aux logiques d’agrégation mélangées.Ouvrir l’aide-mémoire
- Feuille de routePython DataFrames for Data EngineeringConstruisez des synthèses pandas fiables en définissant la granularité, les règles de chiffre d’affaires, le traitement des nulls et les jointures avant de regrouper des commandes réelles.Voir la feuille de route
Que devrais-je créer ensuite ?
Je développe Javi Builds autour des problèmes concrets rencontrés par les data engineers. Dites-moi quel sujet vous aimeriez voir ensuite.
Restez au courant
Recevez uniquement les nouvelles de Javi Builds qui vous intéressent.
Consultez votre boîte de réception
Je vous ai envoyé un lien de confirmation. Votre abonnement sera actif après confirmation.