Parcourir les aide-mémoire · Python

Technologie: PythonCatégorie: Analyse de donnéesNiveau: IntermédiaireMis à jour

GroupBy et agrégations avec pandas

Regroupez 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.

Sur cette page
  1. Problème
  2. Réponse rapide
  3. Code / commandes
  4. 1. Additionner des valeurs selon une colonne
  5. 2. Regrouper sur plusieurs colonnes
  6. 3. Calculer plusieurs agrégations à la fois
  7. 4. Compter les lignes de chaque groupe
  8. 5. Compter les valeurs non nulles d’une colonne donnée
  9. 6. Compter les entités métier uniques
  10. 7. Conserver délibérément les clés de regroupement nulles
  11. 8. Regrouper des colonnes catégorielles sans développer les combinaisons non observées
  12. 9. Calculer des pourcentages au sein d’un groupe
  13. 10. Ajouter des totaux de groupe sans réduire le nombre de lignes
  14. 11. Filtrer selon des indicateurs au niveau du groupe
  15. 12. Agréger par date
  16. 13. Agréger par mois
  17. 14. Obtenir la première ou la dernière ligne de chaque groupe après un tri
  18. 15. Obtenir la ligne ayant la valeur maximale de chaque groupe
  19. 16. Agréger avec une fonction personnalisée
  20. 17. Agréger plusieurs mesures métier
  21. 18. Trier délibérément le résultat agrégé
  22. 19. Éviter le double comptage accidentel avant l’agrégation
  23. 20. Comparer le nombre de lignes avant et après l’agrégation
  24. Interpréter le résultat
  25. Points à vérifier
  26. Les totaux agrégés sont trop élevés
  27. Certains groupes attendus ont disparu
  28. Le résultat contient trop de groupes
  29. Les comptages diffèrent des totaux attendus
  30. La moyenne semble fausse
  31. La logique de « ligne la plus récente » renvoie des valeurs mélangées
  32. Notes de production
  33. GroupBy peut consommer beaucoup de mémoire
  34. Privilégier les agrégations intégrées
  35. Être explicite sur la granularité métier
  36. Le regroupement des valeurs nulles doit être délibéré
  37. L’agrégation peut masquer des problèmes de qualité des données en amont
  38. Éviter groupby().apply() par défaut
  39. Le regroupement temporel exige une gestion explicite des fuseaux horaires
  40. Erreurs fréquentes
  41. 1. Utiliser count() alors que vous voulez le nombre de lignes
  42. 2. Utiliser size() alors que vous avez besoin d’entités distinctes
  43. 3. Oublier les clés de groupe nulles
  44. 4. Agréger après une jointure un-à-plusieurs sans vérifier la granularité
  45. 5. Faire la moyenne de moyennes
  46. 6. Utiliser max() pour obtenir la ligne la plus récente
  47. 7. Utiliser .apply() pour des agrégations simples
  48. 8. Supposer que l’ordre des groupes a un sens
  49. Étape suivante
  50. Pour aller plus loin

Problème

Vous devez résumer des données au niveau ligne sous forme d’indicateurs métier, par exemple :

  • chiffre d’affaires par client
  • commandes par pays
  • durée moyenne par statut
  • totaux quotidiens par produit
  • transaction maximale par compte
  • utilisateurs uniques par canal
  • pourcentages au sein d’un groupe
  • valeurs au niveau du groupe tout en conservant la granularité d’origine des lignes

La difficulté ne se limite pas à appeler groupby().

Vous devez vous assurer que :

  • les clés de regroupement sont correctes
  • les clés de groupe nulles sont traitées de façon délibérée
  • les doublons ne faussent pas les totaux
  • les agrégations correspondent à la granularité métier
  • les colonnes de sortie restent compréhensibles
  • les indicateurs au niveau du groupe sont rattachés aux lignes en toute sécurité si nécessaire

Réponse rapide

Pour un seul indicateur :

summary = (
    df.groupby("customer_id", as_index=False)
    .agg(total_revenue=("revenue", "sum"))
)

Pour plusieurs indicateurs :

summary = (
    df.groupby(["country", "channel"], as_index=False)
    .agg(
        orders=("order_id", "nunique"),
        customers=("customer_id", "nunique"),
        revenue=("revenue", "sum"),
        avg_order_value=("revenue", "mean"),
    )
)

Pour un indicateur au niveau du groupe qui doit rester présent sur chaque ligne d’origine :

df["customer_total_revenue"] = (
    df.groupby("customer_id")["revenue"]
    .transform("sum")
)

Utilisez agg() lorsque vous voulez moins de lignes.

Utilisez transform() lorsque vous voulez conserver le nombre de lignes d’origine.

Code / commandes

1. Additionner des valeurs selon une colonne

summary = (
    df.groupby("customer_id", as_index=False)
    .agg(total_revenue=("revenue", "sum"))
)

Le résultat contient une ligne par customer_id.

Utilisez l’agrégation nommée pour que la colonne de sortie porte un nom explicite.


2. Regrouper sur plusieurs colonnes

summary = (
    df.groupby(
        ["country", "channel"],
        as_index=False,
    )
    .agg(
        revenue=("revenue", "sum"),
        orders=("order_id", "nunique"),
    )
)

La granularité de sortie devient :

country + channel

Assurez-vous que cette granularité correspond à la question métier.


3. Calculer plusieurs agrégations à la fois

summary = (
    df.groupby("customer_id", as_index=False)
    .agg(
        total_revenue=("revenue", "sum"),
        avg_revenue=("revenue", "mean"),
        max_revenue=("revenue", "max"),
        order_count=("order_id", "nunique"),
        first_order=("order_date", "min"),
        last_order=("order_date", "max"),
    )
)

L’agrégation nommée est généralement plus claire que les anciens modèles qui créent des colonnes MultiIndex.


4. Compter les lignes de chaque groupe

Utilisez .size() lorsque vous voulez le nombre de lignes.

counts = (
    df.groupby("status", dropna=False)
    .size()
    .reset_index(name="row_count")
)

Cela compte les lignes, quelles que soient les valeurs nulles dans les autres colonnes.


5. Compter les valeurs non nulles d’une colonne donnée

Utilisez .count() lorsque vous voulez le nombre de valeurs non nulles dans une colonne.

counts = (
    df.groupby("status", as_index=False)
    .agg(non_null_email_count=("email", "count"))
)

Important :

size()  -> compte les lignes
count() -> compte les valeurs non nulles

Ne les utilisez pas indifféremment.


6. Compter les entités métier uniques

summary = (
    df.groupby("country", as_index=False)
    .agg(
        unique_customers=("customer_id", "nunique"),
        unique_orders=("order_id", "nunique"),
    )
)

Utilisez nunique() lorsque les lignes répétées pour une même entité ne doivent compter qu’une fois.


7. Conserver délibérément les clés de regroupement nulles

Par défaut, pandas supprime les clés de groupe NA.

Pour les conserver :

summary = (
    df.groupby(
        "country",
        dropna=False,
        as_index=False,
    )
    .agg(revenue=("revenue", "sum"))
)

C’est important lorsque les valeurs de dimension manquantes ont une signification opérationnelle.


8. Regrouper des colonnes catégorielles sans développer les combinaisons non observées

Lorsque vous regroupez des colonnes catégorielles, indiquez explicitement si vous ne voulez que les combinaisons observées.

summary = (
    df.groupby(
        ["country", "channel"],
        observed=True,
        as_index=False,
    )
    .agg(revenue=("revenue", "sum"))
)

observed=True est utile lorsque des colonnes catégorielles définissent de nombreuses combinaisons théoriquement possibles alors que seules certaines apparaissent dans les données.


9. Calculer des pourcentages au sein d’un groupe

Exemple : la part de chaque produit dans le chiffre d’affaires de sa catégorie.

category_total = (
    df.groupby("category")["revenue"]
    .transform("sum")
)

df["category_revenue_pct"] = (
    df["revenue"] / category_total
)

Utilisez transform(), car le résultat doit être aligné ligne à ligne sur le DataFrame d’origine.


10. Ajouter des totaux de groupe sans réduire le nombre de lignes

df["customer_total_revenue"] = (
    df.groupby("customer_id")["revenue"]
    .transform("sum")
)

df["customer_order_count"] = (
    df.groupby("customer_id")["order_id"]
    .transform("nunique")
)

C’est utile pour filtrer des lignes individuelles ou les comparer aux totaux de leur groupe.


11. Filtrer selon des indicateurs au niveau du groupe

Conserver les clients dont le chiffre d’affaires total dépasse 10 000 :

customer_total = (
    df.groupby("customer_id")["revenue"]
    .transform("sum")
)

filtered = df.loc[
    customer_total > 10_000
]

Cela conserve les lignes de détail des clients retenus.


12. Agréger par date

Assurez-vous d’abord que la colonne de date est bien analysée :

df["event_time"] = pd.to_datetime(
    df["event_time"],
    errors="coerce",
)

Puis regroupez par date :

daily = (
    df.groupby(
        df["event_time"].dt.date,
        as_index=False,
    )
    .agg(revenue=("revenue", "sum"))
)

Pour les séries temporelles, pd.Grouper est souvent plus propre :

daily = (
    df.groupby(
        pd.Grouper(
            key="event_time",
            freq="D",
        )
    )
    .agg(revenue=("revenue", "sum"))
    .reset_index()
)

13. Agréger par mois

monthly = (
    df.groupby(
        pd.Grouper(
            key="event_time",
            freq="MS",
        )
    )
    .agg(
        revenue=("revenue", "sum"),
        orders=("order_id", "nunique"),
    )
    .reset_index()
)

freq="MS" regroupe selon les débuts de mois.

Cela conserve une véritable colonne datetime au lieu de la convertir en chaînes.


14. Obtenir la première ou la dernière ligne de chaque groupe après un tri

Supposons que vous vouliez l’enregistrement le plus récent de chaque client.

latest = (
    df.sort_values(
        ["customer_id", "event_time"]
    )
    .groupby(
        "customer_id",
        as_index=False,
    )
    .tail(1)
)

Cela conserve la ligne complète.

N’utilisez pas :

groupby().agg("max")

pour obtenir la « ligne la plus récente » sur plusieurs colonnes.

Cela peut combiner des valeurs provenant de lignes différentes.


15. Obtenir la ligne ayant la valeur maximale de chaque groupe

idx = (
    df.groupby("customer_id")["revenue"]
    .idxmax()
)

highest_orders = df.loc[idx]

Cela conserve la ligne réellement associée à la valeur maximale.

Soyez prudent si la colonne cible peut être entièrement nulle dans un groupe.


16. Agréger avec une fonction personnalisée

def revenue_range(s: pd.Series) -> float:
    return s.max() - s.min()

summary = (
    df.groupby("customer_id", as_index=False)
    .agg(
        revenue_range=("revenue", revenue_range)
    )
)

N’utilisez des fonctions Python personnalisées que lorsque les agrégations intégrées ne peuvent pas exprimer la logique.

Les fonctions intégrées sont généralement plus rapides et plus faciles à maintenir.


17. Agréger plusieurs mesures métier

summary = (
    df.groupby(
        ["merchant_id", "event_date"],
        as_index=False,
    )
    .agg(
        transactions=("transaction_id", "nunique"),
        customers=("customer_id", "nunique"),
        gross_amount=("amount", "sum"),
        avg_amount=("amount", "mean"),
        max_amount=("amount", "max"),
    )
)

Ce modèle est courant dans les charges de travail de reporting et d’ingénierie des données.

Définissez la granularité de sortie avant d’écrire le code.


18. Trier délibérément le résultat agrégé

summary = (
    df.groupby("country", as_index=False)
    .agg(revenue=("revenue", "sum"))
    .sort_values(
        "revenue",
        ascending=False,
    )
)

Ne supposez pas que l’ordre des groupes a une signification métier.

Triez explicitement lorsque le résultat sera relu ou publié.


19. Éviter le double comptage accidentel avant l’agrégation

Supposons que les données d’entrée contiennent des lignes de commande en double à cause d’une jointure antérieure.

Validez d’abord :

duplicate_orders = df.duplicated(
    subset=["order_id"],
    keep=False,
)

print(df.loc[duplicate_orders].head(20))

Si la granularité attendue est d’une ligne par commande, n’agrégez qu’après avoir corrigé la duplication ou l’avoir traitée de façon délibérée.

GroupBy ne peut pas corriger automatiquement une mauvaise granularité en entrée.


20. Comparer le nombre de lignes avant et après l’agrégation

print("Input rows:", len(df))
print("Output rows:", len(summary))

Validez le nombre de groupes attendu :

expected_groups = (
    df[["country", "channel"]]
    .drop_duplicates()
    .shape[0]
)

print("Expected groups:", expected_groups)
print("Actual groups:", len(summary))

Si dropna=False ou un regroupement catégoriel entre en jeu, assurez-vous que la logique de validation applique la même sémantique.

Interpréter le résultat

Modèle Signification
groupby("customer_id") Définit un groupe par clé client.
as_index=False Conserve les clés de regroupement comme colonnes de sortie normales.
agg() Réduit chaque groupe à une ou plusieurs valeurs de synthèse.
transform() Renvoie des valeurs dérivées du groupe, alignées sur le nombre de lignes d’origine.
size() Compte les lignes de chaque groupe.
count() Compte les valeurs non nulles.
nunique() Compte par défaut les valeurs distinctes non nulles.
dropna=False Conserve les clés de regroupement NA dans un groupe distinct.
observed=True Avec des regroupements catégoriels, renvoie les combinaisons de catégories observées plutôt que toutes les combinaisons possibles.
pd.Grouper() Regroupe des données de type datetime par intervalles de temps.

Points à vérifier

Les totaux agrégés sont trop élevés

Causes fréquentes :

  • lignes en double
  • jointures un-à-plusieurs en amont
  • mauvaise granularité métier
  • événements répétés
  • utilisation de count() alors que nunique() était nécessaire

Validez les données d’entrée avant de modifier l’agrégation.

Certains groupes attendus ont disparu

Vérifiez si les clés de regroupement contiennent des valeurs nulles.

Par défaut, les clés de groupe nulles peuvent être exclues, sauf si vous utilisez :

dropna=False

Le résultat contient trop de groupes

Vérifiez :

  • les différences d’espaces
  • les différences de casse
  • les codes incohérents
  • la précision des horodatages
  • les colonnes de regroupement superflues

Exemple :

"US"
"us"
"US "

sont des clés de groupe différentes tant qu’elles ne sont pas normalisées.

Les comptages diffèrent des totaux attendus

Demandez-vous ce que vous comptez :

  • des lignes ?
  • des valeurs non nulles ?
  • des commandes distinctes ?
  • des clients distincts ?

Choisissez size, count ou nunique de façon délibérée.

La moyenne semble fausse

Causes possibles :

  • lignes en double
  • valeurs nulles
  • différences de pondération
  • mauvaise granularité
  • moyenne de moyennes déjà agrégées

Ne faites jamais la moyenne de moyennes de sous-groupes, sauf si la pondération est mathématiquement correcte.

La logique de « ligne la plus récente » renvoie des valeurs mélangées

Appliquer max() à plusieurs colonnes ne reconstitue pas la ligne la plus récente.

Triez plutôt les données et sélectionnez la ligne réelle.

Notes de production

GroupBy peut consommer beaucoup de mémoire

Une forte cardinalité des groupes peut consommer une quantité importante de mémoire.

Le risque augmente avec :

  • de nombreuses colonnes de regroupement
  • des clés à forte cardinalité
  • de nombreuses agrégations
  • des colonnes riches en objets/chaînes
  • de grands DataFrames intermédiaires

Ne sélectionnez que les colonnes nécessaires avant le regroupement.

Privilégier les agrégations intégrées

Celles-ci sont généralement plus rapides :

"sum"
"mean"
"min"
"max"
"count"
"nunique"

que des fonctions Python arbitraires.

N’utilisez .apply() que lorsque la logique de groupe nécessite réellement un comportement personnalisé.

Être explicite sur la granularité métier

Avant de regrouper, formulez conceptuellement la granularité de sortie attendue :

une ligne par client et par jour

Vos clés de regroupement doivent alors représenter exactement cette granularité.

Le regroupement des valeurs nulles doit être délibéré

Supprimer silencieusement les valeurs de dimension nulles peut fausser les totaux.

Utilisez :

dropna=False

lorsque les clés manquantes doivent rester visibles.

L’agrégation peut masquer des problèmes de qualité des données en amont

Un total final peut sembler raisonnable même en présence de lignes en double ou de clés incorrectes.

Validez :

  • le nombre de lignes
  • l’unicité des clés
  • les clés métier en double
  • les clés nulles

avant de vous fier au résultat.

Éviter groupby().apply() par défaut

apply() est puissant, mais souvent plus lent et plus difficile à comprendre.

Privilégiez :

  • agg()
  • transform()
  • filter()
  • les opérations vectorisées

lorsqu’ils permettent d’exprimer la même logique.

Le regroupement temporel exige une gestion explicite des fuseaux horaires

Si les horodatages proviennent de plusieurs fuseaux, normalisez-les avant tout regroupement quotidien ou mensuel.

Sinon, des enregistrements proches de minuit peuvent tomber dans la mauvaise période de reporting.

Erreurs fréquentes

1. Utiliser count() alors que vous voulez le nombre de lignes

count() ignore les valeurs nulles.

Utilisez :

groupby(...).size()

pour obtenir le nombre réel de lignes.

2. Utiliser size() alors que vous avez besoin d’entités distinctes

Utilisez nunique() lorsque l’indicateur porte sur des clients, commandes, sessions ou autres entités métier uniques.

3. Oublier les clés de groupe nulles

Le comportement par défaut peut les exclure.

Utilisez dropna=False lorsque ces lignes doivent rester visibles.

4. Agréger après une jointure un-à-plusieurs sans vérifier la granularité

C’est une source fréquente de totaux gonflés.

Validez d’abord les doublons et la cardinalité de la jointure.

5. Faire la moyenne de moyennes

Exemple :

moyenne(moyennes par région)

n’est généralement pas égal à la moyenne globale.

Utilisez des calculs pondérés lorsque la taille des sous-groupes diffère.

6. Utiliser max() pour obtenir la ligne la plus récente

max() travaille colonne par colonne.

Il ne préserve pas les relations au sein des lignes.

Triez et prenez la ligne réelle.

7. Utiliser .apply() pour des agrégations simples

C’est généralement plus lent et moins clair que les opérations intégrées.

8. Supposer que l’ordre des groupes a un sens

Triez explicitement si l’ordre compte.

Étape suivante

Utilisez le résultat de l’agrégation pour décider de la suite.

  • Besoin de rattacher les totaux de groupe aux lignes → utilisez transform().
  • Les totaux semblent gonflés → inspectez les doublons et les jointures en amont.
  • Des groupes attendus manquent → inspectez les clés de regroupement nulles et la normalisation.
  • Besoin d’indicateurs provenant d’un autre DataFrame → faites le merge après avoir défini la granularité cible.
  • Besoin de synthèses temporelles → utilisez des dates analysées en datetime et pd.Grouper.
  • Besoin de la ligne la plus récente ou la plus élevée par groupe → triez/sélectionnez les lignes réelles au lieu d’agréger chaque colonne.
  • GroupBy est lent ou gourmand en mémoire → réduisez les colonnes, diminuez la cardinalité, préfiltrez ou déplacez la charge de travail vers un moteur distribué.
  • Le résultat est critique pour l’activité → ajoutez des contrôles de rapprochement comparant les totaux regroupés aux totaux sources.

← Tous les aide-mémoire