Parcourir les aide-mémoire · PySpark

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

Sélectionner et filtrer des DataFrames

Sélectionnez, projetez, filtrez et validez efficacement des DataFrames PySpark en évitant les colonnes ambiguës, les erreurs de logique sur les valeurs nulles, les lectures inutiles et le filtrage côté driver.

Sur cette page
  1. Problème
  2. Réponse rapide
  3. Code / commandes
  4. 1. Sélectionner des colonnes précises
  5. 2. Sélectionner avec des alias
  6. 3. Ajouter ou remplacer une colonne avec withColumn
  7. 4. Sélectionner toutes les colonnes existantes plus une expression
  8. 5. Supprimer explicitement des colonnes
  9. 6. Filtrer avec une seule condition
  10. 7. Filtrer avec plusieurs conditions
  11. 8. Ne pas utiliser and / or de Python
  12. 9. Filtrer les valeurs nulles
  13. 10. Comprendre la logique à trois valeurs des nulls
  14. 11. Filtrer selon une liste avec isin
  15. 12. Exclure des valeurs
  16. 13. Filtrer des plages numériques
  17. 14. Filtrer des chaînes avec contains
  18. 15. Filtrer avec startswith et endswith
  19. 16. Filtrer avec like
  20. 17. Filtrer avec des expressions régulières
  21. 18. Filtrer des dates avec des bornes explicites
  22. 19. Convertir le type avant de comparer des dates lorsque la source est du texte
  23. 20. Filtrer des horodatages en toute sécurité
  24. 21. Filtrer avec la syntaxe d’expression SQL
  25. 22. Construire des expressions de filtre dynamiques en toute sécurité
  26. 23. Filtrer avant une jointure
  27. 24. Sélectionner uniquement les colonnes nécessaires avant une jointure
  28. 25. Éviter les colonnes ambiguës après les jointures
  29. 26. Utiliser une liste de clés de jointure lorsque les noms correspondent
  30. 27. Utiliser des semi-jointures gauches pour filtrer sur l’existence
  31. 28. Utiliser des anti-jointures gauches pour détecter les références manquantes
  32. 29. Éviter de filtrer en collectant les clés dans Python
  33. 30. Éviter le filtrage Python ligne par ligne
  34. 31. Privilégier les fonctions intégrées aux filtres en UDF Python
  35. 32. Vérifier si les filtres ont atteint le plan physique
  36. 33. Inspecter les filtres de partition Parquet/Delta dans le plan
  37. 34. Éviter d’envelopper inutilement les colonnes de partition
  38. 35. Utiliser limit() uniquement pour une inspection bornée
  39. 36. Utiliser sample() pour une inspection approximative
  40. 37. Vérifier le nombre de lignes avant et après un filtre important
  41. 38. Agréger les diagnostics de filtrage en une seule passe
  42. 39. Valider des résultats de filtre inattendus
  43. 40. Normaliser une seule fois la logique de chaîne répétée
  44. Interpréter le résultat
  45. Points à vérifier
  46. La jointure est coûteuse alors que le résultat est petit
  47. Le filtre renvoie étonnamment peu de lignes
  48. Le filtre renvoie zéro ligne après un changement de schéma
  49. Le plan physique lit toujours un grand volume de données
  50. La mémoire du driver augmente pendant le filtrage
  51. Le même nettoyage de chaînes apparaît dans de nombreux filtres
  52. Notes de production
  53. Les transformations Spark sont lazy
  54. Le pushdown dépend de la source
  55. La sémantique des nulls est celle de SQL
  56. Les grandes listes isin() sont un signal d’alerte
  57. La largeur des colonnes compte
  58. L’ordre des filtres est généralement géré par l’optimiseur
  59. Les fonctions définies par l’utilisateur coûteuses peuvent bloquer l’optimisation
  60. Erreurs fréquentes
  61. 1. Utiliser and / or de Python
  62. 2. Oublier les parenthèses autour des conditions
  63. 3. Utiliser == None
  64. 4. Supposer que != value conserve les valeurs nulles
  65. 5. Collecter les clés de référence dans Python
  66. 6. Sélectionner * tout au long du pipeline
  67. 7. Filtrer après la jointure coûteuse
  68. 8. Utiliser une expression régulière pour une simple logique de préfixe ou de suffixe
  69. 9. Supposer que chaque filtre est poussé jusqu’à la source
  70. 10. Utiliser limit() comme preuve que les données sont correctes
  71. Étape suivante
  72. Pour aller plus loin

Problème

Vous devez réduire un DataFrame PySpark aux lignes et aux colonnes dont la transformation suivante a besoin.

La syntaxe est simple, mais les bugs de production viennent souvent :

  • de colonnes inutiles transportées à travers des jointures coûteuses
  • de l’utilisation de la logique booléenne de Python au lieu des expressions de colonnes Spark
  • d’un filtrage incorrect des valeurs nulles
  • de comparaisons de chaînes, de dates ou d’horodatages avec la mauvaise sémantique
  • de noms de colonnes ambigus créés après des jointures
  • de l’utilisation de collect() ou de boucles Python pour filtrer des données distribuées
  • de fonctions coûteuses appliquées avant de réduire le jeu de données
  • de l’hypothèse qu’un filtre est toujours poussé jusqu’à la source

L’objectif est de rendre la réduction des lignes et des colonnes explicite, efficace et facile à raisonner.

Réponse rapide

Sélectionnez uniquement les colonnes nécessaires :

from pyspark.sql import functions as F

sales = (
    spark.table("sales")
    .select(
        "sale_id",
        "merchant_id",
        "sale_date",
        "amount",
    )
)

Filtrez avec des expressions Spark :

filtered = sales.filter(
    (F.col("sale_date") >= F.lit("2026-10-01"))
    & (F.col("amount") > 0)
)

Pour un filtrage sûr face aux valeurs nulles :

filtered = sales.filter(
    F.col("merchant_id").isNotNull()
)

Pour les charges de travail de production, réduisez les lignes et les colonnes avant les grosses jointures, les agrégations ou les opérations côté Python.

Code / commandes

1. Sélectionner des colonnes précises

df = df.select(
    "sale_id",
    "merchant_id",
    "amount",
)

Faites-le plutôt que de transporter toutes les colonnes de la source à travers l’ensemble du pipeline.

L’élagage des colonnes peut réduire :

  • les E/S
  • la sérialisation
  • la largeur du shuffle
  • l’utilisation de la mémoire

2. Sélectionner avec des alias

df = df.select(
    F.col("sale_id"),
    F.col("merchant_id"),
    F.col("amount").alias("sale_amount"),
)

Utilisez des alias pour rendre explicite le sens des colonnes en aval et pour éviter les collisions après les jointures.


3. Ajouter ou remplacer une colonne avec withColumn

df = df.withColumn(
    "net_amount",
    F.col("amount") - F.col("discount"),
)

Utilisez withColumn() pour des dérivations ciblées.

Si vous créez de nombreuses colonnes, envisagez un seul select() contenant toutes les expressions, pour la lisibilité.


4. Sélectionner toutes les colonnes existantes plus une expression

df = df.select(
    "*",
    (
        F.col("amount")
        - F.col("discount")
    ).alias("net_amount"),
)

Utilisez cette approche avec parcimonie.

select("*") est pratique, mais peut conserver plus de données que n’en a réellement besoin la charge de travail en aval.


5. Supprimer explicitement des colonnes

df = df.drop(
    "_raw_payload",
    "_debug_column",
)

Utilisez drop() lorsqu’une colonne temporaire n’est plus nécessaire.

Pour les pipelines de production comportant de nombreuses colonnes, privilégiez si possible une sélection positive explicite, car elle rend le contrat de schéma plus clair.


6. Filtrer avec une seule condition

filtered = df.filter(
    F.col("amount") > 100
)

Équivalent :

filtered = df.where(
    F.col("amount") > 100
)

filter() et where() sont des alias.

Utilisez celui qui est le plus clair pour l’équipe.


7. Filtrer avec plusieurs conditions

filtered = df.filter(
    (F.col("status") == "active")
    & (F.col("amount") > 100)
)

Utilisez :

  • & pour ET
  • | pour OU
  • ~ pour NON

Entourez chaque comparaison de parenthèses.


8. Ne pas utiliser and / or de Python

Incorrect :

df.filter(
    (F.col("amount") > 100)
    and (F.col("status") == "active")
)

Correct :

df.filter(
    (F.col("amount") > 100)
    & (F.col("status") == "active")
)

Les expressions Spark construisent un plan d’exécution distribué.

and / or de Python n’opèrent pas élément par élément sur les colonnes Spark.


9. Filtrer les valeurs nulles

missing = df.filter(
    F.col("merchant_id").isNull()
)

Valeurs non nulles :

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

N’écrivez pas :

F.col("merchant_id") == None

Utilisez les fonctions explicites dédiées aux valeurs nulles.


10. Comprendre la logique à trois valeurs des nulls

Ce filtre :

df.filter(
    F.col("status") != "closed"
)

ne conserve pas les lignes dont status est nul, car les comparaisons avec null s’évaluent à « inconnu ».

Si les valeurs nulles doivent aussi être conservées :

df.filter(
    (F.col("status") != "closed")
    | F.col("status").isNull()
)

Rendez toujours la sémantique des nulls délibérée.


11. Filtrer selon une liste avec isin

filtered = df.filter(
    F.col("country").isin(
        "US",
        "CA",
        "ES",
    )
)

Pour une liste Python :

allowed = [
    "US",
    "CA",
    "ES",
]

filtered = df.filter(
    F.col("country").isin(allowed)
)

Utilisez cette approche pour de petites listes de référence en mémoire.

Pour de grands ensembles de référence, faites une jointure avec un DataFrame au lieu de créer une énorme expression isin().


12. Exclure des valeurs

filtered = df.filter(
    ~F.col("status").isin(
        "cancelled",
        "deleted",
    )
)

Si les valeurs nulles doivent être conservées, ajoutez explicitement cette règle.


13. Filtrer des plages numériques

filtered = df.filter(
    F.col("amount").between(
        100,
        500,
    )
)

between() inclut les deux bornes.

Équivalent :

filtered = df.filter(
    (F.col("amount") >= 100)
    & (F.col("amount") <= 500)
)

14. Filtrer des chaînes avec contains

filtered = df.filter(
    F.col("description").contains(
        "premium"
    )
)

Cette comparaison est sensible à la casse.

Pour une correspondance insensible à la casse :

filtered = df.filter(
    F.lower(
        F.col("description")
    ).contains("premium")
)

Faites attention aux appels répétés de mise en minuscules et de suppression des espaces sur de grands jeux de données ; normalisez une seule fois si la même logique est réutilisée.


15. Filtrer avec startswith et endswith

filtered = df.filter(
    F.col("sku").startswith("PROD-")
)
filtered = df.filter(
    F.col("filename").endswith(".parquet")
)

Ils sont souvent plus clairs qu’une expression régulière pour de simples règles de préfixe ou de suffixe.


16. Filtrer avec like

filtered = df.filter(
    F.col("email").like("%@example.com")
)

Caractères génériques de SQL LIKE :

%  → n’importe quelle séquence
_  → un seul caractère

Utilisez rlike() uniquement lorsque des expressions régulières sont réellement nécessaires.


17. Filtrer avec des expressions régulières

filtered = df.filter(
    F.col("product_code").rlike(
        r"^[A-Z]{3}-\d{4}$"
    )
)

Les expressions régulières peuvent être coûteuses sur de grands jeux de données textuels.

Privilégiez si possible des opérations sur les chaînes plus simples.


18. Filtrer des dates avec des bornes explicites

filtered = df.filter(
    (F.col("sale_date") >= F.lit("2026-10-01"))
    & (F.col("sale_date") < F.lit("2026-11-01"))
)

Utilisez des intervalles semi-ouverts :

start <= value < next_boundary

Cela évite les problèmes de précision en fin de journée.


19. Convertir le type avant de comparer des dates lorsque la source est du texte

df = df.withColumn(
    "sale_date",
    F.to_date(
        F.col("sale_date_raw"),
        "yyyy-MM-dd",
    ),
)

Puis filtrez :

filtered = df.filter(
    (F.col("sale_date") >= F.to_date(F.lit("2026-10-01")))
    & (F.col("sale_date") < F.to_date(F.lit("2026-11-01")))
)

Ne supposez pas que des chaînes de dates quelconques se trient ou se comparent correctement.


20. Filtrer des horodatages en toute sécurité

filtered = df.filter(
    (F.col("event_time") >= F.to_timestamp(F.lit("2026-10-01 00:00:00")))
    & (F.col("event_time") < F.to_timestamp(F.lit("2026-11-01 00:00:00")))
)

Gardez une sémantique de fuseau horaire cohérente avec la façon dont la colonne d’horodatage a été produite.

Ne mélangez pas des bornes métier en heure locale avec des horodatages UTC sans conversion explicite.


21. Filtrer avec la syntaxe d’expression SQL

filtered = df.filter(
    """
    status = 'active'
    AND amount > 100
    """
)

Cela peut être utile lorsque la condition s’exprime naturellement en SQL.

Privilégiez l’API Column lorsque vous avez besoin d’une composition programmatique et d’une meilleure prise en charge de la refactorisation.


22. Construire des expressions de filtre dynamiques en toute sécurité

conditions = []

if min_amount is not None:
    conditions.append(
        F.col("amount") >= min_amount
    )

if country is not None:
    conditions.append(
        F.col("country") == country
    )

Combinez :

from functools import reduce
from operator import and_

if conditions:
    predicate = reduce(
        and_,
        conditions,
    )

    df = df.filter(predicate)

Ne concaténez pas directement des entrées non fiables dans des chaînes d’expression SQL.


23. Filtrer avant une jointure

Privilégiez :

sales_small = (
    sales
    .filter(
        F.col("sale_date") >= "2026-10-01"
    )
    .select(
        "merchant_id",
        "amount",
    )
)

joined = sales_small.join(
    merchants.select(
        "merchant_id",
        "region",
    ),
    on="merchant_id",
    how="left",
)

plutôt que de joindre d’abord des entrées larges ou non filtrées.

Réduire les deux côtés avant une jointure peut diminuer le shuffle et la pression sur la mémoire.


24. Sélectionner uniquement les colonnes nécessaires avant une jointure

sales_small = sales.select(
    "merchant_id",
    "sale_id",
    "amount",
)

merchants_small = merchants.select(
    "merchant_id",
    "merchant_name",
)

Puis faites la jointure.

Vous évitez ainsi de transporter de volumineuses colonnes de données inutilisées à travers le shuffle.


25. Éviter les colonnes ambiguës après les jointures

Attribuez un alias aux deux DataFrames :

s = sales.alias("s")
m = merchants.alias("m")

joined = (
    s.join(
        m,
        F.col("s.merchant_id")
        == F.col("m.merchant_id"),
        "left",
    )
    .select(
        F.col("s.sale_id"),
        F.col("s.merchant_id"),
        F.col("m.merchant_name"),
        F.col("s.amount"),
    )
)

Cela évite toute ambiguïté lorsque les deux entrées contiennent les mêmes noms de colonnes.


26. Utiliser une liste de clés de jointure lorsque les noms correspondent

joined = sales.join(
    merchants,
    on=["merchant_id"],
    how="left",
)

Cela évite généralement les colonnes de clé de jointure en double.

Utilisez une condition explicite lorsque :

  • les noms des clés diffèrent
  • plusieurs conditions autres que l’égalité sont nécessaires
  • vous avez besoin de plus de contrôle

27. Utiliser des semi-jointures gauches pour filtrer sur l’existence

Conserver les lignes de sales dont le merchant_id existe dans merchants :

valid_sales = sales.join(
    merchants.select("merchant_id"),
    on="merchant_id",
    how="left_semi",
)

C’est plus clair, et souvent plus efficace, qu’une jointure complète suivie de la suppression de colonnes.


28. Utiliser des anti-jointures gauches pour détecter les références manquantes

Trouver les ventes sans commerçant correspondant :

orphan_sales = sales.join(
    merchants.select("merchant_id"),
    on="merchant_id",
    how="left_anti",
)

Utilisez les anti-jointures pour :

  • les clés étrangères sans correspondance
  • la détection incrémentale de nouvelles clés
  • les rapports d’exceptions

29. Éviter de filtrer en collectant les clés dans Python

Mauvaise pratique :

keys = [
    row["merchant_id"]
    for row in merchants.collect()
]

filtered = sales.filter(
    F.col("merchant_id").isin(keys)
)

Cela déplace des données vers le driver et peut échouer à grande échelle.

Utilisez plutôt une semi-jointure.


30. Éviter le filtrage Python ligne par ligne

Mauvais :

rows = df.collect()

filtered = [
    row
    for row in rows
    if row["amount"] > 100
]

Correct :

filtered = df.filter(
    F.col("amount") > 100
)

Gardez le filtrage distribué dans Spark.


31. Privilégier les fonctions intégrées aux filtres en UDF Python

Privilégiez :

filtered = df.filter(
    F.length(
        F.trim(F.col("email"))
    ) > 5
)

plutôt qu’une UDF Python qui vérifie la longueur d’une chaîne.

Les fonctions Spark intégrées sont plus faciles à comprendre pour l’optimiseur et évitent le surcoût de sérialisation Python.


32. Vérifier si les filtres ont atteint le plan physique

filtered.explain("formatted")

Recherchez :

  • Filter
  • les filtres poussés (pushed filters), lorsqu’ils sont affichés
  • les filtres de partition
  • des lectures réduites

Ne supposez pas que chaque filtre est poussé jusqu’à la source.

La forme de l’expression et la prise en charge par la source de données comptent.


33. Inspecter les filtres de partition Parquet/Delta dans le plan

Pour une table partitionnée physiquement, un filtre tel que :

df.filter(
    F.col("sale_year") == 2026
)

peut permettre l’élagage des partitions.

Utilisez :

df.filter(
    F.col("sale_year") == 2026
).explain("formatted")

Recherchez les informations sur les filtres de partition dans le scan.

Si l’élagage ne se produit pas, vérifiez :

  • la colonne de partition
  • le type de l’expression
  • les conversions de type ou fonctions qui enveloppent la colonne de partition
  • l’organisation de la table

34. Éviter d’envelopper inutilement les colonnes de partition

Moins favorable à l’optimiseur :

df.filter(
    F.year(
        F.col("sale_date")
    ) == 2026
)

Si une colonne de partition dédiée existe déjà :

df.filter(
    F.col("sale_year") == 2026
)

est généralement plus clair pour l’élagage des partitions.

Concevez les colonnes de partition en fonction des modèles d’accès réels.


35. Utiliser limit() uniquement pour une inspection bornée

sample = df.limit(100)

C’est utile pour :

  • les aperçus
  • l’inspection locale
  • les résultats de tests

Ne considérez pas limit() comme un substitut au filtrage métier.

Un résultat limité n’est pas représentatif tant que la sémantique d’ordre ou d’échantillonnage n’est pas définie.


36. Utiliser sample() pour une inspection approximative

sample = df.sample(
    withReplacement=False,
    fraction=0.01,
    seed=42,
)

Utilisez l’échantillonnage pour l’exploration.

Ne l’utilisez pas pour prouver :

  • l’unicité
  • l’exhaustivité
  • l’absence de données erronées

Un échantillon ne peut pas valider l’ensemble du jeu de données.


37. Vérifier le nombre de lignes avant et après un filtre important

before = df.count()

filtered = df.filter(
    F.col("status") == "active"
)

after = filtered.count()

print("Before:", before)
print("After:", after)
print("Removed:", before - after)

Pour les gros traitements de production, évitez les lectures complètes répétées uniquement pour la journalisation.

Dans la mesure du possible, regroupez les métriques de qualité dans une seule agrégation.


38. Agréger les diagnostics de filtrage en une seule passe

metrics = (
    df.agg(
        F.count("*").alias("rows_total"),
        F.sum(
            F.when(
                F.col("status") == "active",
                1,
            ).otherwise(0)
        ).alias("rows_active"),
        F.sum(
            F.when(
                F.col("merchant_id").isNull(),
                1,
            ).otherwise(0)
        ).alias("rows_missing_merchant"),
    )
)

metrics.show()

C’est généralement plus efficace que plusieurs jobs count() distincts.


39. Valider des résultats de filtre inattendus

Si un filtre renvoie zéro ligne :

df.select(
    "status"
).distinct().show(
    100,
    truncate=False,
)

Ou :

(
    df.groupBy("status")
    .count()
    .orderBy(
        F.desc("count")
    )
    .show(
        100,
        truncate=False,
    )
)

Recherchez :

  • la casse
  • les espaces
  • les valeurs nulles
  • des codes inattendus
  • des changements dans la source

40. Normaliser une seule fois la logique de chaîne répétée

Au lieu d’écrire :

df.filter(
    F.lower(
        F.trim(F.col("status"))
    ) == "active"
)

à de nombreux endroits, normalisez une seule fois :

df = df.withColumn(
    "status_normalized",
    F.lower(
        F.trim(F.col("status"))
    ),
)

Puis :

filtered = df.filter(
    F.col("status_normalized") == "active"
)

Ne le faites que si le champ normalisé est suffisamment réutilisé pour justifier de le conserver.

Interpréter le résultat

Opération Signification
select() Projette les colonnes et expressions nécessaires en aval
withColumn() Ajoute ou remplace une colonne
drop() Supprime des colonnes
filter() / where() Conserve les lignes qui satisfont un prédicat Spark
isin() Test d’appartenance pour de petits ensembles de valeurs
isNull() / isNotNull() Filtrage explicite des valeurs nulles
left_semi Conserve les lignes de gauche qui ont une clé correspondante à droite
left_anti Conserve les lignes de gauche sans clé correspondante à droite
explain() Affiche le plan d’exécution logique/physique
élagage des partitions Évite de lire les partitions physiques non pertinentes
predicate pushdown Rapproche le filtrage pris en charge de la source de données

Le principe de performance essentiel est le suivant :

réduire tôt
→ moins de shuffle
→ moins de données transportées
→ moins de travail

Points à vérifier

La jointure est coûteuse alors que le résultat est petit

Vérifiez si les deux côtés ont été filtrés et projetés avant la jointure.

Un résultat étroit n’aide pas si Spark a quand même fait un shuffle d’entrées larges.

Le filtre renvoie étonnamment peu de lignes

Vérifiez :

  • le comportement des valeurs nulles
  • le formatage des chaînes
  • le dtype
  • les bornes de dates
  • la sémantique des fuseaux horaires
  • des valeurs inattendues dans la source

Le filtre renvoie zéro ligne après un changement de schéma

La source contient peut-être désormais des codes, des types ou des formats différents.

Inspectez les valeurs réelles avant de modifier le prédicat.

Le plan physique lit toujours un grand volume de données

Vérifiez :

  • si le filtre peut être poussé jusqu’à la source
  • si l’élagage des partitions est possible
  • si vous avez enveloppé les colonnes de partition dans des transformations
  • si l’organisation de la source permet l’élagage

La mémoire du driver augmente pendant le filtrage

Recherchez :

  • collect()
  • des listes Python de clés
  • toPandas()
  • un traitement ligne par ligne

Le filtrage doit généralement rester distribué.

Le même nettoyage de chaînes apparaît dans de nombreux filtres

Normalisez une seule fois dans une transformation maîtrisée plutôt que de répéter partout des expressions coûteuses.

Notes de production

Les transformations Spark sont lazy

select() et filter() construisent un plan.

Le travail réel commence lorsqu’une action s’exécute, par exemple :

count()
show()
write...
collect()

Ne mesurez pas uniquement la construction du DataFrame.

Le pushdown dépend de la source

Delta/Parquet peuvent souvent tirer parti du pushdown des prédicats et des colonnes.

Toutes les expressions ne sont pas compatibles avec le pushdown.

Appuyez-vous sur le plan physique au lieu de supposer que l’optimisation a eu lieu.

La sémantique des nulls est celle de SQL

Spark utilise une logique à trois valeurs :

vrai
faux
inconnu

Une comparaison avec null renvoie généralement « inconnu », ce qui ne passe pas un filtre.

Rendez la gestion des valeurs nulles explicite.

Les grandes listes isin() sont un signal d’alerte

Quelques valeurs littérales ne posent pas de problème.

Des milliers ou des millions de valeurs doivent généralement devenir un DataFrame utilisable dans une jointure.

La largeur des colonnes compte

Un DataFrame de :

10 millions de lignes × 5 colonnes

peut être nettement moins coûteux à redistribuer par shuffle que :

10 millions de lignes × 80 colonnes

Sélectionnez tôt.

L’ordre des filtres est généralement géré par l’optimiseur

Ne faites pas de micro-optimisation en réordonnant manuellement des prédicats déterministes simples, sauf si le plan ou l’exécution révèle un réel problème.

Concentrez-vous plutôt sur :

  • l’élagage à la source
  • les UDF coûteuses
  • les jointures
  • l’organisation des partitions

Les fonctions définies par l’utilisateur coûteuses peuvent bloquer l’optimisation

Une UDF Python dans un filtre peut introduire un surcoût de sérialisation et réduire les possibilités d’optimisation.

Privilégiez les fonctions Spark SQL intégrées.

Erreurs fréquentes

1. Utiliser and / or de Python

Les expressions de colonnes Spark exigent & et |.

2. Oublier les parenthèses autour des conditions

La priorité des opérateurs peut provoquer des erreurs ou une logique involontaire.

3. Utiliser == None

Utilisez isNull() / isNotNull().

4. Supposer que != value conserve les valeurs nulles

Ce n’est pas le cas.

Les comparaisons avec null s’évaluent à « inconnu ».

5. Collecter les clés de référence dans Python

Utilisez plutôt une semi-jointure.

6. Sélectionner * tout au long du pipeline

Les DataFrames larges augmentent le coût du shuffle et de la mémoire.

7. Filtrer après la jointure coûteuse

Réduisez les lignes avant le shuffle lorsque la logique métier le permet.

8. Utiliser une expression régulière pour une simple logique de préfixe ou de suffixe

Utilisez startswith(), endswith() ou contains() lorsqu’ils expriment clairement la règle.

9. Supposer que chaque filtre est poussé jusqu’à la source

Vérifiez le plan.

10. Utiliser limit() comme preuve que les données sont correctes

Un petit aperçu ne peut pas valider l’ensemble du jeu de données.

Étape suivante

Utilisez le symptôme pour choisir l’action suivante.

  • Trop de lignes atteignent une jointure → avancez les filtres sûrs.
  • Trop de colonnes atteignent une jointure → projetez d’abord uniquement les colonnes nécessaires.
  • Le filtre ne renvoie aucune ligne → inspectez les valeurs réelles, les valeurs nulles et les dtypes.
  • L’appartenance à une référence utilise des listes Python → remplacez-les par une semi-jointure ou une anti-jointure.
  • Le comportement des valeurs nulles surprend → rendez la sémantique des nulls explicite.
  • Le filtrage par date est erroné → utilisez des dates/horodatages typés et des intervalles semi-ouverts.
  • La lecture reste volumineuse → inspectez explain("formatted") pour le pushdown et l’élagage des partitions.
  • Le filtrage utilise des UDF Python → remplacez-les si possible par des fonctions Spark intégrées.
  • Les données semblent toujours trop volumineuses malgré un élagage correct → passez à PySpark : référence rapide des performances et inspectez le partitionnement et le shuffle.

← Tous les aide-mémoire