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