Parcourir les aide-mémoire · Python
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
- Problème
- Réponse rapide
- Code / commandes
- 1. Additionner des valeurs selon une colonne
- 2. Regrouper sur plusieurs colonnes
- 3. Calculer plusieurs agrégations à la fois
- 4. Compter les lignes de chaque groupe
- 5. Compter les valeurs non nulles d’une colonne donnée
- 6. Compter les entités métier uniques
- 7. Conserver délibérément les clés de regroupement nulles
- 8. Regrouper des colonnes catégorielles sans développer les combinaisons non observées
- 9. Calculer des pourcentages au sein d’un groupe
- 10. Ajouter des totaux de groupe sans réduire le nombre de lignes
- 11. Filtrer selon des indicateurs au niveau du groupe
- 12. Agréger par date
- 13. Agréger par mois
- 14. Obtenir la première ou la dernière ligne de chaque groupe après un tri
- 15. Obtenir la ligne ayant la valeur maximale de chaque groupe
- 16. Agréger avec une fonction personnalisée
- 17. Agréger plusieurs mesures métier
- 18. Trier délibérément le résultat agrégé
- 19. Éviter le double comptage accidentel avant l’agrégation
- 20. Comparer le nombre de lignes avant et après l’agrégation
- Interpréter le résultat
- Points à vérifier
- Les totaux agrégés sont trop élevés
- Certains groupes attendus ont disparu
- Le résultat contient trop de groupes
- Les comptages diffèrent des totaux attendus
- La moyenne semble fausse
- La logique de « ligne la plus récente » renvoie des valeurs mélangées
- Notes de production
- GroupBy peut consommer beaucoup de mémoire
- Privilégier les agrégations intégrées
- Être explicite sur la granularité métier
- Le regroupement des valeurs nulles doit être délibéré
- L’agrégation peut masquer des problèmes de qualité des données en amont
- Éviter groupby().apply() par défaut
- Le regroupement temporel exige une gestion explicite des fuseaux horaires
- Erreurs fréquentes
- 1. Utiliser count() alors que vous voulez le nombre de lignes
- 2. Utiliser size() alors que vous avez besoin d’entités distinctes
- 3. Oublier les clés de groupe nulles
- 4. Agréger après une jointure un-à-plusieurs sans vérifier la granularité
- 5. Faire la moyenne de moyennes
- 6. Utiliser max() pour obtenir la ligne la plus récente
- 7. Utiliser .apply() pour des agrégations simples
- 8. Supposer que l’ordre des groupes a un sens
- Étape suivante
- 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 quenunique()é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.
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
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.