Parcourir les aide-mémoire · PySpark

Technologie: PySparkCatégorie: Transformation de donnéesNiveau: IntermédiaireMis à jour

GroupBy et agrégations avec PySpark

Agrégez des DataFrames PySpark en toute sécurité en définissant la granularité de sortie, en traitant les clés de regroupement nulles, en choisissant les bonnes fonctions d’agrégation, en validant les totaux et en maîtrisant les charges de travail groupBy gourmandes en shuffle.

Sur cette page
  1. Problème
  2. Réponse rapide
  3. Code / commandes
  4. 1. Regrouper sur une colonne
  5. 2. Regrouper sur plusieurs colonnes
  6. 3. Compter les lignes avec count("*")
  7. 4. Compter les valeurs non nulles d’une colonne
  8. 5. Compter les clés métier distinctes
  9. 6. Additionner des valeurs numériques
  10. 7. Calculer une moyenne
  11. 8. Calculer plusieurs agrégats en une seule passe
  12. 9. Obtenir les horodatages minimum et maximum
  13. 10. Conserver les clés de regroupement nulles
  14. 11. Filtrer les clés de regroupement non valides avant l’agrégation
  15. 12. Mesurer séparément les clés de regroupement nulles
  16. 13. Regrouper sur une colonne de date
  17. 14. Dériver le jour à partir d’un horodatage
  18. 15. Agréger par mois
  19. 16. Agrégation conditionnelle
  20. 17. Somme conditionnelle
  21. 18. Calculer un ratio à partir de composantes agrégées
  22. 19. Calculer une moyenne pondérée
  23. 20. Agréger des booléens ou des indicateurs
  24. 21. Collecter des valeurs dans un tableau
  25. 22. N’utiliser collect_list() que lorsque les doublons comptent
  26. 23. Ne pas supposer que collect_list() préserve l’ordre
  27. 24. Agréger dans un struct
  28. 25. Utiliser first() et last() avec prudence
  29. 26. Obtenir la valeur la plus récente avec max_by lorsqu’il est disponible
  30. 27. Obtenir la ligne associée à l’horodatage le plus récent
  31. 28. Utiliser rollup() pour des totaux hiérarchiques
  32. 29. Utiliser cube() pour toutes les combinaisons de regroupement
  33. 30. Utiliser grouping_id() avec les rollups et les cubes
  34. 31. N’utiliser pivot() qu’avec des catégories bornées
  35. 32. Éviter de faire un pivot sur des identifiants de client ou de transaction
  36. 33. Rapprocher les totaux agrégés de la source
  37. 34. Valider l’unicité du résultat à la granularité prévue
  38. 35. Vérifier la duplication des données d’entrée avant de sommer
  39. 36. Filtrer et projeter avant l’agrégation
  40. 37. Inspecter le plan physique
  41. 38. Vérifier le skew des clés de regroupement
  42. 39. Ne pas remplacer toutes les clés nulles par une seule valeur sentinelle avant le regroupement
  43. 40. Éviter l’agrégation par UDF Python lorsque les fonctions intégrées suffisent
  44. Interpréter le résultat
  45. Points à vérifier
  46. Le chiffre d’affaires est trop élevé
  47. Le nombre de lignes baisse plus que prévu
  48. Le comptage distinct diffère fortement du nombre de lignes
  49. Une étape prend beaucoup plus de temps que prévu
  50. collect_list() provoque une pression mémoire
  51. La moyenne semble fausse
  52. Notes de production
  53. GroupBy est généralement une opération gourmande en shuffle
  54. Les agrégats intégrés peuvent utiliser l’agrégation partielle
  55. La cardinalité des clés de regroupement influe sur la taille du résultat
  56. Le skew compte davantage que la taille moyenne des groupes
  57. Les types décimaux sont préférables pour des totaux financiers exacts
  58. L’agrégation distincte peut être coûteuse
  59. N’utilisez pas l’agrégation pour masquer une mauvaise granularité
  60. Erreurs fréquentes
  61. 1. Regrouper avant de définir la granularité de sortie
  62. 2. Utiliser count(col) alors que le nombre de lignes est requis
  63. 3. Utiliser une moyenne simple alors qu’une moyenne pondérée est requise
  64. 4. Supposer que first() signifie le plus ancien
  65. 5. Utiliser max() sur plusieurs colonnes pour reconstituer la ligne la plus récente
  66. 6. Faire un pivot sur des champs à forte cardinalité
  67. 7. Utiliser collect_list() sur des groupes non bornés
  68. 8. Ignorer les clés de regroupement nulles
  69. 9. Incriminer les performances du groupBy avant de vérifier le skew
  70. 10. Exécuter de nombreuses agrégations distinctes sur les mêmes données d’entrée
  71. Étape suivante
  72. Pour aller plus loin

Problème

Vous devez résumer un DataFrame PySpark par client, commerçant, date, région ou selon une autre granularité métier.

La syntaxe est simple, mais les erreurs en production proviennent souvent :

  • d’une agrégation à la mauvaise granularité
  • d’un double comptage après une jointure
  • de la perte des clés de regroupement nulles
  • d’une confusion entre nombre de lignes et nombre de valeurs non nulles
  • d’une moyenne simple sur des valeurs qui devraient être pondérées
  • de l’utilisation de collect_list() sur des groupes non bornés
  • d’une agrégation personnalisée coûteuse en Python
  • d’un shuffle ou d’un skew extrême
  • d’un regroupement sur des clés à forte cardinalité sans en mesurer le coût

L’objectif est de rendre la logique d’agrégation explicite, correcte et capable de monter en charge.

Réponse rapide

Définissez d’abord la granularité de sortie.

Exemple :

Granularité de sortie :
une ligne par merchant_id + sale_date

Puis agrégez :

from pyspark.sql import functions as F

summary = (
    sales
    .groupBy(
        "merchant_id",
        "sale_date",
    )
    .agg(
        F.count("*").alias("row_count"),
        F.countDistinct("sale_id").alias("sale_count"),
        F.sum("amount").alias("revenue"),
        F.avg("amount").alias("avg_sale_amount"),
    )
)

Avant de vous fier au résultat, vérifiez :

Le nombre de lignes a-t-il changé comme prévu ?
Les totaux concordent-ils ?
Des lignes source en double gonflent-elles les indicateurs ?
Les clés de regroupement nulles sont-elles conservées ou supprimées de façon délibérée ?

La justesse de l’agrégation passe avant l’optimisation de Spark.

Code / commandes

1. Regrouper sur une colonne

summary = (
    df
    .groupBy("merchant_id")
    .count()
)

Cela renvoie une ligne par valeur distincte de merchant_id.

Utilisez count() lorsque vous avez besoin du nombre de lignes par groupe.


2. Regrouper sur plusieurs colonnes

summary = (
    df
    .groupBy(
        "merchant_id",
        "sale_date",
    )
    .agg(
        F.sum("amount").alias("revenue")
    )
)

Les colonnes de regroupement définissent la granularité de sortie.

Documentez-les.


3. Compter les lignes avec count("*")

summary = (
    df
    .groupBy("merchant_id")
    .agg(
        F.count("*").alias("row_count")
    )
)

Cela compte les lignes, que les colonnes individuelles contiennent des valeurs nulles ou non.

Utilisez-le lorsque la question est :

Combien d’enregistrements chaque groupe contient-il ?

4. Compter les valeurs non nulles d’une colonne

summary = (
    df
    .groupBy("merchant_id")
    .agg(
        F.count("sale_id").alias("non_null_sale_id_count")
    )
)

Cela ne compte que les valeurs non nulles de sale_id.

Ne le confondez pas avec le nombre de lignes.


5. Compter les clés métier distinctes

summary = (
    df
    .groupBy("merchant_id")
    .agg(
        F.countDistinct("sale_id").alias("distinct_sales")
    )
)

Utilisez-le lorsque les lignes source peuvent contenir plusieurs enregistrements par vente.

Cela permet de distinguer :

le nombre de lignes physiques

de :

le nombre d’événements métier

6. Additionner des valeurs numériques

summary = (
    df
    .groupBy("merchant_id")
    .agg(
        F.sum("amount").alias("revenue")
    )
)

Les valeurs nulles sont ignorées par sum().

Si toutes les valeurs d’un groupe sont nulles, le résultat de la somme peut être null.

Ne remplacez pas automatiquement null par zéro, sauf si cela correspond à la règle métier.


7. Calculer une moyenne

summary = (
    df
    .groupBy("merchant_id")
    .agg(
        F.avg("amount").alias("avg_amount")
    )
)

Les valeurs nulles sont ignorées.

Demandez-vous si une moyenne simple est le bon indicateur métier.


8. Calculer plusieurs agrégats en une seule passe

summary = (
    df
    .groupBy("merchant_id")
    .agg(
        F.count("*").alias("row_count"),
        F.countDistinct("sale_id").alias("sale_count"),
        F.sum("amount").alias("revenue"),
        F.avg("amount").alias("avg_amount"),
        F.min("amount").alias("min_amount"),
        F.max("amount").alias("max_amount"),
    )
)

C’est généralement préférable à l’exécution de plusieurs jobs groupBy distincts sur les mêmes données d’entrée.


9. Obtenir les horodatages minimum et maximum

summary = (
    df
    .groupBy("merchant_id")
    .agg(
        F.min("event_time").alias("first_event_time"),
        F.max("event_time").alias("last_event_time"),
    )
)

Vous obtenez ainsi les valeurs d’horodatage la plus ancienne et la plus récente.

Cela ne renvoie pas la ligne complète associée à ces horodatages.

Utilisez une fenêtre lorsque vous avez besoin de la ligne la plus récente elle-même.


10. Conserver les clés de regroupement nulles

Spark regroupe les valeurs nulles ensemble.

Exemple :

summary = (
    df
    .groupBy("country")
    .count()
)

Les lignes dont country est null forment leur propre groupe.

Ce comportement diffère de certains comportements par défaut de pandas.

Si les clés de regroupement nulles ne sont pas valides, filtrez-les ou mettez-les en quarantaine explicitement.


11. Filtrer les clés de regroupement non valides avant l’agrégation

valid = df.filter(
    F.col("merchant_id").isNotNull()
)

summary = (
    valid
    .groupBy("merchant_id")
    .agg(
        F.sum("amount").alias("revenue")
    )
)

N’utilisez cette approche que lorsque les clés nulles sont réellement non valides.

Ne les supprimez pas silencieusement sans en mesurer l’impact.


12. Mesurer séparément les clés de regroupement nulles

null_key_count = (
    df
    .filter(
        F.col("merchant_id").isNull()
    )
    .count()
)

print(
    "Rows with null merchant_id:",
    null_key_count,
)

Pour les charges de travail de production volumineuses, combinez si possible cette mesure avec d’autres indicateurs dans une seule agrégation.


13. Regrouper sur une colonne de date

daily = (
    df
    .groupBy("sale_date")
    .agg(
        F.sum("amount").alias("revenue")
    )
)

Assurez-vous que sale_date est bien une date et non un texte arbitraire.


14. Dériver le jour à partir d’un horodatage

daily = (
    df
    .withColumn(
        "sale_date",
        F.to_date("sale_time"),
    )
    .groupBy("sale_date")
    .agg(
        F.sum("amount").alias("revenue")
    )
)

Faites attention à la sémantique des fuseaux horaires.

Si sale_time est en UTC mais que le reporting repose sur l’heure locale, convertissez-le dans le fuseau horaire métier avant de dériver la date.


15. Agréger par mois

monthly = (
    df
    .withColumn(
        "sale_month",
        F.date_trunc(
            "month",
            F.col("sale_time"),
        ),
    )
    .groupBy("sale_month")
    .agg(
        F.sum("amount").alias("revenue")
    )
)

Cela conserve une limite de mois de type timestamp.

Utilisez une clé de date dédiée si votre modèle exige une sémantique de date seule.


16. Agrégation conditionnelle

Compter les lignes en succès :

summary = (
    df
    .groupBy("merchant_id")
    .agg(
        F.sum(
            F.when(
                F.col("status") == "success",
                1,
            ).otherwise(0)
        ).alias("success_count")
    )
)

C’est souvent plus clair et plus efficace que de créer de nombreux DataFrames filtrés et de les agréger chacun séparément.


17. Somme conditionnelle

summary = (
    df
    .groupBy("merchant_id")
    .agg(
        F.sum(
            F.when(
                F.col("status") == "approved",
                F.col("amount"),
            ).otherwise(F.lit(0))
        ).alias("approved_amount")
    )
)

N’utilisez zéro que si les lignes exclues doivent contribuer pour zéro à l’indicateur.

Si la sémantique des valeurs nulles compte, encodez-la délibérément.


18. Calculer un ratio à partir de composantes agrégées

summary = (
    df
    .groupBy("merchant_id")
    .agg(
        F.count("*").alias("total_rows"),
        F.sum(
            F.when(
                F.col("status") == "success",
                1,
            ).otherwise(0)
        ).alias("success_rows"),
    )
    .withColumn(
        "success_rate",
        F.when(
            F.col("total_rows") > 0,
            F.col("success_rows")
            / F.col("total_rows"),
        ),
    )
)

Construisez le ratio à partir d’un numérateur et d’un dénominateur explicites.

Ne faites pas la moyenne de pourcentages calculés ligne par ligne, sauf si c’est mathématiquement correct.


19. Calculer une moyenne pondérée

Supposons que :

price × quantity

doive être pondéré par la quantité.

summary = (
    df
    .groupBy("product_id")
    .agg(
        F.sum(
            F.col("price")
            * F.col("quantity")
        ).alias("weighted_value"),
        F.sum("quantity").alias("total_quantity"),
    )
    .withColumn(
        "weighted_avg_price",
        F.when(
            F.col("total_quantity") != 0,
            F.col("weighted_value")
            / F.col("total_quantity"),
        ),
    )
)

N’utilisez pas avg(price) lorsque chaque ligne représente un poids différent.


20. Agréger des booléens ou des indicateurs

Exemple :

summary = (
    df
    .groupBy("customer_id")
    .agg(
        F.max(
            F.col("is_high_risk").cast("int")
        ).alias("has_high_risk")
    )
)

Si une ligne au moins est vraie, le résultat devient 1.

Explicitez ensuite le type de sortie et sa signification métier si nécessaire.


21. Collecter des valeurs dans un tableau

summary = (
    df
    .groupBy("merchant_id")
    .agg(
        F.collect_set("country").alias("countries")
    )
)

Utilisez collect_set() lorsque les valeurs uniques par groupe sont utiles.

Faites attention aux groupes non bornés.

Un seul groupe volumineux peut créer un très grand tableau en mémoire.


22. N’utiliser collect_list() que lorsque les doublons comptent

summary = (
    df
    .groupBy("customer_id")
    .agg(
        F.collect_list("event_type").alias("events")
    )
)

Cela conserve les doublons, mais ne garantit pas un ordre d’événements significatif, sauf si vous modélisez explicitement l’ordre.

N’utilisez pas collect_list() pour construire d’énormes tableaux pour des groupes à fort volume.


23. Ne pas supposer que collect_list() préserve l’ordre

Si l’ordre compte, utilisez un modèle structuré.

Exemple :

events = (
    df
    .groupBy("customer_id")
    .agg(
        F.sort_array(
            F.collect_list(
                F.struct(
                    "event_time",
                    "event_type",
                )
            )
        ).alias("events")
    )
)

Cela trie les structs collectés selon leurs champs.

Explicitez la sémantique croissante ou décroissante exigée par la règle métier.


24. Agréger dans un struct

summary = (
    df
    .groupBy("merchant_id")
    .agg(
        F.struct(
            F.sum("amount").alias("revenue"),
            F.countDistinct("sale_id").alias("sales"),
        ).alias("metrics")
    )
)

N’utilisez des sorties imbriquées que lorsque le consommateur en aval tire profit d’un struct.

Les tables analytiques plates sont souvent plus faciles à interroger.


25. Utiliser first() et last() avec prudence

summary = (
    df
    .groupBy("customer_id")
    .agg(
        F.first(
            "status",
            ignorenulls=True,
        ).alias("some_status")
    )
)

Sans stratégie d’ordonnancement explicite, first() ne signifie pas :

le plus ancien par horodatage

et last() ne signifie pas :

le plus récent par horodatage

Utilisez une fenêtre ou un modèle d’agrégat ordonné lorsque l’ordre temporel compte.


26. Obtenir la valeur la plus récente avec max_by lorsqu’il est disponible

Dans les versions de Spark qui le prennent en charge :

summary = (
    df
    .groupBy("customer_id")
    .agg(
        F.max_by(
            F.col("status"),
            F.col("event_time"),
        ).alias("latest_status")
    )
)

Cela renvoie la valeur associée au maximum de l’expression d’ordonnancement.

Utilisez une fenêtre lorsque vous avez besoin de plusieurs colonnes de la même ligne la plus récente ou d’un départage complexe des ex æquo.


27. Obtenir la ligne associée à l’horodatage le plus récent

Utilisez une fenêtre :

from pyspark.sql import Window

w = (
    Window
    .partitionBy("customer_id")
    .orderBy(
        F.col("event_time").desc(),
        F.col("event_id").desc(),
    )
)

latest = (
    df
    .withColumn(
        "_rn",
        F.row_number().over(w),
    )
    .filter(F.col("_rn") == 1)
    .drop("_rn")
)

N’utilisez pas des appels max() indépendants sur plusieurs colonnes pour reconstituer une ligne.


28. Utiliser rollup() pour des totaux hiérarchiques

summary = (
    df
    .rollup(
        "region",
        "merchant_id",
    )
    .agg(
        F.sum("amount").alias("revenue")
    )
)

Cela peut produire :

total par région + commerçant
sous-total par région
total général

Les valeurs nulles dans les colonnes de regroupement peuvent représenter des lignes de sous-total.

Utilisez grouping() / grouping_id() lorsque vous devez distinguer les véritables valeurs nulles des marqueurs de sous-total.


29. Utiliser cube() pour toutes les combinaisons de regroupement

summary = (
    df
    .cube(
        "region",
        "channel",
    )
    .agg(
        F.sum("amount").alias("revenue")
    )
)

cube() peut produire de nombreuses combinaisons d’agrégation.

Utilisez-le avec prudence, car la taille du résultat augmente avec le nombre de dimensions de regroupement.


30. Utiliser grouping_id() avec les rollups et les cubes

summary = (
    df
    .rollup(
        "region",
        "merchant_id",
    )
    .agg(
        F.sum("amount").alias("revenue"),
        F.grouping_id().alias("grouping_id"),
    )
)

Cela aide à distinguer :

une véritable valeur de dimension nulle

de :

une ligne de sous-total ou de total général

31. N’utiliser pivot() qu’avec des catégories bornées

pivoted = (
    df
    .groupBy("merchant_id")
    .pivot(
        "status",
        [
            "approved",
            "declined",
            "pending",
        ],
    )
    .agg(
        F.count("*")
    )
)

Fournir les valeurs de pivot attendues évite à Spark de devoir d’abord découvrir chaque catégorie distincte.

Ne faites pas de pivot sur des champs non bornés ou à forte cardinalité.


32. Éviter de faire un pivot sur des identifiants de client ou de transaction

À éviter :

df.groupBy("merchant_id").pivot("customer_id")

Cela peut créer un nombre énorme de colonnes.

Ne faites de pivot que sur de petits ensembles de catégories maîtrisés.


33. Rapprocher les totaux agrégés de la source

Avant :

source_total = (
    df
    .agg(
        F.sum("amount").alias("amount")
    )
    .first()["amount"]
)

Après :

summary_total = (
    summary
    .agg(
        F.sum("revenue").alias("amount")
    )
    .first()["amount"]
)

Comparez ensuite.

Si la transformation ne fait que changer la granularité, les totaux doivent concorder, sauf si la logique métier exclut ou modifie intentionnellement des lignes.


34. Valider l’unicité du résultat à la granularité prévue

Pour :

merchant_id + sale_date

vérifiez :

duplicates = (
    summary
    .groupBy(
        "merchant_id",
        "sale_date",
    )
    .count()
    .filter(F.col("count") > 1)
)

if duplicates.limit(1).count() > 0:
    raise RuntimeError(
        "Aggregation output grain is not unique"
    )

Un groupBy() correct devrait naturellement produire des combinaisons de regroupement uniques.

Si des doublons apparaissent plus tard, une jointure en aval a peut-être modifié la granularité.


35. Vérifier la duplication des données d’entrée avant de sommer

(
    df
    .groupBy("sale_id")
    .count()
    .filter(F.col("count") > 1)
    .show(50, truncate=False)
)

Si une vente qui devrait apparaître une seule fois apparaît plusieurs fois, l’agrégation peut masquer la duplication sous-jacente tout en gonflant les totaux.

Corrigez la granularité en amont lorsque c’est pertinent.


36. Filtrer et projeter avant l’agrégation

Préférez :

small = (
    df
    .filter(
        F.col("sale_date") >= "2026-10-01"
    )
    .select(
        "merchant_id",
        "sale_date",
        "sale_id",
        "amount",
    )
)

summary = (
    small
    .groupBy(
        "merchant_id",
        "sale_date",
    )
    .agg(
        F.sum("amount").alias("revenue")
    )
)

N’emportez pas dans le shuffle de grandes colonnes de données inutilisées.


37. Inspecter le plan physique

summary.explain("formatted")

Recherchez :

  • Exchange
  • l’agrégation par hachage (hash aggregation)
  • l’agrégation par tri (sort aggregation)
  • l’agrégation partielle
  • le repartitionnement

Le regroupement nécessite normalement un shuffle, sauf si les données sont déjà partitionnées de manière utile.


38. Vérifier le skew des clés de regroupement

(
    df
    .groupBy("merchant_id")
    .count()
    .orderBy(
        F.desc("count")
    )
    .show(
        50,
        truncate=False,
    )
)

Un petit nombre de groupes énormes peut créer des tâches retardataires.

Causes fréquentes :

  • un tenant ou client dominant
  • une clé nulle ou sentinelle
  • des données malformées
  • une distribution métier très inégale

39. Ne pas remplacer toutes les clés nulles par une seule valeur sentinelle avant le regroupement

Risqué :

df = df.fillna(
    {
        "merchant_id": 0
    }
)

Cela peut fusionner de nombreuses lignes sans rapport en un seul groupe gigantesque.

N’utilisez une valeur sentinelle que lorsqu’elle a une véritable signification métier.


40. Éviter l’agrégation par UDF Python lorsque les fonctions intégrées suffisent

Préférez :

F.sum("amount")
F.avg("amount")
F.max("event_time")
F.countDistinct("sale_id")

à une logique d’agrégation Python personnalisée.

Les fonctions Spark intégrées restent dans le moteur d’exécution optimisé de Spark.

N’utilisez des pandas UDF ou une agrégation personnalisée que lorsque la logique métier ne peut pas être exprimée avec les fonctions intégrées.

Interpréter le résultat

Fonction Signification
count("*") Nombre de lignes du groupe
count("col") Nombre de valeurs non nulles dans col
countDistinct() Valeurs distinctes non nulles
sum() Somme des valeurs non nulles
avg() Moyenne des valeurs non nulles
min() / max() Valeur minimale/maximale
collect_set() Valeurs uniques collectées dans un tableau
collect_list() Valeurs collectées dans un tableau, doublons conservés
rollup() Sous-totaux hiérarchiques + total général
cube() Toutes les combinaisons des dimensions de regroupement
pivot() Convertit des valeurs de catégorie en colonnes
grouping_id() Identifie le niveau de regroupement sous-total/total général

Le concept le plus important est le suivant :

colonnes du groupBy = granularité de sortie

Si la granularité est mauvaise, chaque indicateur construit dessus peut être faux.

Points à vérifier

Le chiffre d’affaires est trop élevé

Vérifiez :

  • les clés source en double
  • la multiplication des lignes due à des jointures antérieures
  • une mauvaise granularité de regroupement
  • des fichiers d’entrée en double
  • des lots rejoués

L’agrégation peut masquer des lignes en double tout en gonflant les totaux.

Le nombre de lignes baisse plus que prévu

C’est normal lorsqu’on regroupe de nombreuses lignes en moins de groupes, mais vérifiez :

  • la granularité prévue
  • le traitement des clés nulles
  • les filtres appliqués avant l’agrégation

Le comptage distinct diffère fortement du nombre de lignes

Cela peut indiquer :

  • plusieurs lignes physiques par événement métier
  • des doublons
  • une granularité légitime au niveau des lignes de détail
  • des enregistrements de statut ou d’historique répétés

Comprenez la granularité de la source avant de conclure qu’elle est erronée.

Une étape prend beaucoup plus de temps que prévu

Vérifiez le skew des clés de regroupement et le volume du shuffle.

Une clé chaude peut dominer le temps d’agrégation.

collect_list() provoque une pression mémoire

Un ou plusieurs groupes accumulent peut-être de très grands tableaux.

Utilisez un autre modèle de données si la cardinalité des groupes n’est pas bornée.

La moyenne semble fausse

Vérifiez si :

  • les valeurs nulles sont exclues
  • une pondération est nécessaire
  • les données d’entrée ont été dupliquées
  • l’unité ou la granularité est correcte

Notes de production

GroupBy est généralement une opération gourmande en shuffle

Spark doit souvent redistribuer les lignes selon la clé de regroupement.

Réduisez les lignes et les colonnes avant l’agrégation lorsque la logique métier le permet.

Les agrégats intégrés peuvent utiliser l’agrégation partielle

Spark peut souvent agréger localement avant le shuffle, puis combiner les résultats.

C’est l’une des raisons pour lesquelles les fonctions d’agrégation intégrées sont préférables à une logique Python personnalisée.

La cardinalité des clés de regroupement influe sur la taille du résultat

Regrouper par :

merchant_id + date

peut produire des millions de groupes.

Regrouper par :

country

peut n’en produire que quelques dizaines.

Une forte cardinalité n’est pas fautive en soi, mais elle modifie le comportement du shuffle et de la mémoire.

Le skew compte davantage que la taille moyenne des groupes

Une charge de travail peut sembler équilibrée en moyenne alors qu’un seul groupe contient un pourcentage énorme des lignes.

Inspectez les plus gros groupes lorsque des étapes présentent des tâches retardataires.

Les types décimaux sont préférables pour des totaux financiers exacts

Utilisez une précision/échelle DecimalType adaptée pour les valeurs de type monétaire lorsque l’arithmétique exacte compte.

Évitez d’introduire inutilement des erreurs de virgule flottante dans les rapprochements financiers.

L’agrégation distincte peut être coûteuse

countDistinct() et les opérations distinctes similaires peuvent nécessiter un shuffle ou un état importants.

Ne les utilisez que lorsque l’indicateur métier exige réellement une sémantique distincte.

N’utilisez pas l’agrégation pour masquer une mauvaise granularité

Si une jointure a doublé chaque vente et que vous regroupez ensuite pour revenir à une ligne par vente, le résultat peut rester faux.

Corrigez la relation en amont.

Erreurs fréquentes

1. Regrouper avant de définir la granularité de sortie

Les colonnes de regroupement constituent le contrat métier du résultat.

Définissez-les en premier.

2. Utiliser count(col) alors que le nombre de lignes est requis

count(col) ignore les valeurs nulles.

Utilisez count("*") pour compter les lignes.

3. Utiliser une moyenne simple alors qu’une moyenne pondérée est requise

Cela produit des indicateurs métier mathématiquement faux.

4. Supposer que first() signifie le plus ancien

Sans ordonnancement, ce n’est pas le cas.

Utilisez une fenêtre ou un agrégat ordonné.

5. Utiliser max() sur plusieurs colonnes pour reconstituer la ligne la plus récente

Chaque maximum peut provenir d’une ligne source différente.

Sélectionnez la ligne réelle.

6. Faire un pivot sur des champs à forte cardinalité

Cela peut créer un nombre de colonnes ingérable.

7. Utiliser collect_list() sur des groupes non bornés

Un seul groupe peut devenir trop volumineux pour la mémoire.

8. Ignorer les clés de regroupement nulles

Spark regroupe les valeurs nulles ensemble.

Décidez si ce groupe est valide.

9. Incriminer les performances du groupBy avant de vérifier le skew

Une seule clé chaude peut dicter toute l’étape.

10. Exécuter de nombreuses agrégations distinctes sur les mêmes données d’entrée

Combinez les agrégats liés dans un seul agg() lorsque c’est possible.

Étape suivante

Utilisez le résultat pour choisir l’action suivante.

  • Les totaux sont trop élevés → inspectez les doublons en amont et la cardinalité des jointures.
  • Le comptage distinct diffère du nombre de lignes → confirmez la granularité de la source et la sémantique des événements répétés.
  • La moyenne est trompeuse → déterminez si une pondération est nécessaire.
  • La valeur la plus récente est fausse → utilisez une logique de fenêtre ou un agrégat ordonné.
  • Un groupe domine → analysez le skew et les clés sentinelles ou nulles.
  • L’agrégation est lente → filtrez/projetez plus tôt et inspectez le shuffle dans le plan Spark.
  • Le résultat doit contenir les N premières lignes ou les lignes les plus récentes plutôt qu’une valeur scalaire par groupe → passez à Fonctions de fenêtre dans PySpark.
  • Le résultat doit être persisté → choisissez un modèle d’écriture Delta adapté et validez la granularité cible.

← Tous les aide-mémoire