PySpark Lire CSV : Chargement et traitement efficaces de fichiers volumineux

Les fichiers CSV sont des piliers essentiels du traitement des données et de l'analyse. Presque tous les professionnels des données, qu'il s'agisse d'ingénieurs et de scientifiques des données intermédiaires ou de développeurs utilisant PySpark, ont affaire à des fichiers CSV à un moment ou à un autre. Cependant, lorsque les ensembles de données passent des mégaoctets aux gigaoctets, voire aux téraoctets et au-delà, les outils simples et uniques comme Pandas ou les bibliothèques Python standard peinent à gérer la charge. C'est là qu'Apache Spark et PySpark deviennent importants pour gérer des fichiers CSV à grande échelle dans des environnements informatiques distribués.

Cet article vous apprendra tout ce que vous devez savoir pour lire de gros fichiers CSV avec PySpark. 

Assurez-vous que PySpark est installé et que vous êtes familier avec les bases en suivant notre tutoriel Getting Started with PySpark. 

Qu'est-ce que la lecture de CSV dans PySpark ?

PySpark permet aux utilisateurs de lire des fichiers CSV dans des DataFrame distribués. Les DataFrames dans PySpark ressemblent beaucoup aux DataFrames de Pandas, offrant une interface familière. Cependant, sous la surface, les DataFrame de PySpark distribuent le calcul et le stockage sur plusieurs nœuds, offrant des performances exceptionnelles pour les ensembles de données massifs. 

PySpark offre des avantages indéniables pour les gros fichiers CSV, tels que

• Chargement de données distribuées,
• Traitement robuste des valeurs nulles,
• Flexibilité dans la définition du schéma, et
• Des méthodes simples pour gérer des fichiers CSV multiples ou compressés.

Néanmoins, des problèmes communs se posent, notamment le traitement efficace des en-têtes, la déduction ou la spécification précise des schémas et la gestion des enregistrements malformés ou incohérents. Poursuivez votre lecture pour découvrir comment faire face à tous ces défis. 

La lecture de fichiers CSV dans PySpark est l'un des sujets que vous devez comprendre pour réussir un entretien avec PySpark. Notre Top 36 PySpark Interview Questions and Answers for 2025 fournit un guide complet des questions et réponses des entretiens PySpark, couvrant des sujets allant des concepts fondamentaux aux techniques avancées et aux stratégies d'optimisation.  

Principes de base de la lecture des fichiers CSV dans PySpark

La lecture de données CSV est souvent l'une des étapes initiales et les plus critiques dans les flux de travail PySpark, formant la base des transformations ultérieures, de l'analyse exploratoire et des tâches d'apprentissage automatique. La réussite de cette étape garantit un traitement plus propre des données et une amélioration des performances en aval.

Cadre conceptuel

PySpark lit les fichiers CSV dans le cadre du modèle distribué de Spark. Au lieu de lire les données CSV entièrement en mémoire sur une seule machine, Spark répartit les tâches de données volumineuses sur plusieurs nœuds de cluster. L'optimiseur Catalyst intégré à Spark améliore encore les performances en exécutant efficacement les opérations sous-jacentes requises lors de l'ingestion CSV.

Syntaxe de lecture de base

La manière simple de lire des fichiers CSV fait appel aux fonctions intégrées de Spark : 

spark.read.csv("file_path", header=True, inferSchema=True)

Ou explicitement :

spark.read.format("csv").option("header", "True").load("file_path")

Les principaux paramètres sont les suivants :

• file_path - l'emplacement des fichiers CSV.
• header - définir les noms de colonnes à partir des en-têtes CSV si True.
• inferSchema - déduit automatiquement les types de données des colonnes.
• delimiter - caractère séparant les colonnes ; la valeur par défaut est la virgule.

Notre tutoriel Apprendre PySpark à partir de zéro en 2025 présente plus en détail les principes fondamentaux de PySpark et la manière de l'apprendre. 

Lecture des fichiers CSV : Options et configurations

PySpark propose des options étendues qui permettent un contrôle granulaire du processus de lecture CSV.

Inférence d'en-tête et de schéma

Le paramètre header=True indique à Spark d'utiliser la première ligne CSV comme nom de colonne.

inferSchema=True  permet à Spark de deviner automatiquement les types de colonnes en analysant vos données :

spark.read.csv("customers.csv", header=True, inferSchema=True)

Si l'inférence de schéma est pratique et efficace au départ, les grands ensembles de données souffrent d'une réduction des performances car Spark effectue des passages répétés sur les données pour déterminer les types de données.

Spécification d'un schéma personnalisé 

La définition explicite de votre schéma améliore considérablement les performances en éliminant les analyses répétées des données par Spark. Un schéma défini communique d'emblée les noms et les types de colonnes.

Voici comment définir un schéma personnalisé dans PySpark :

from pyspark.sql.types import StructType, StructField, StringType, IntegerType, DoubleType
schema = StructType([
    StructField("user_id", IntegerType(), True),
    StructField("name", StringType(), True),
    StructField("score", DoubleType(), True),
])
df = spark.read.csv("customers.csv", schema=schema, header=True)

Ensuite, explorons la gestion des délimiteurs dans PySpark lors de la lecture de fichiers CSV. 

Gestion des délimiteurs et des caractères spéciaux

De nombreux fichiers CSV utilisent des délimiteurs autres que les virgules, tels que les pipes ou les tabulations. PySpark permet de spécifier explicitement le délimiteur :

spark.read.csv("customers.csv", header=True, delimiter="|")

En outre, les caractères d'échappement et les guillemets peuvent également être configurés pour gérer les scénarios de caractères spéciaux :

spark.read.csv("data.csv", header=True, escape='\"', quote='"')

Gestion des valeurs nulles et manquantes

Les données CSV réelles contiennent souvent des incohérences ou des enregistrements incomplets. PySpark simplifie la gestion des valeurs nulles en traduisant les caractères de remplacement personnalisés en valeurs nulles :

spark.read.csv("customers.csv", header=True, schema=schema, nullValue="NA")

Les valeurs nulles sont ainsi clarifiées, ce qui réduit considérablement le nettoyage manuel des données par la suite.

Explorons d'autres stratégies pour traiter les valeurs nulles. 

Vous pouvez décider de filtrer les valeurs nulles : 

# Filter rows where Age is not null
df_filtered = df.filter(df["Age"].isNotNull())
df_filtered.show()

Cela permet de filtrer le DataFrame pour n'inclure que les lignes dont la colonne Age n'est pas nulle. Le résultat devrait ressembler à ceci :

+---+-----+---+------+
| ID| Name|Age|Salary|
+---+-----+---+------+
|  1| John| 25| 50000|
|  3|  Bob| 30|  NULL|
|  4|Carol| 28| 55000|
+---+-----+---+------+

L'autre stratégie consiste à remplir les valeurs nulles : 

# Replace null values in Age and Salary with default values
df_filled = df.na.fill({"Age": 0, "Salary": 0})
df_filled.show()

Le résultat sera le suivant : 

+---+-----+---+------+
| ID| Name|Age|Salary|
+---+-----+---+------+
|  1| John| 25| 50000|
|  2|Alice|  0| 60000|
|  3|  Bob| 30|     0|
|  4|Carol| 28| 55000|
|  5|David|  0| 48000|
+---+-----+---+------+

Lecture de plusieurs fichiers et répertoires

PySpark excelle dans la gestion de grands ensembles de données multi-fichiers. Plutôt que de charger et de fusionner manuellement les fichiers d'un répertoire de manière séquentielle, PySpark prend en charge les motifs de caractères génériques pour un chargement en masse rapide et efficace :

spark.read.csv("/data/sales/*.csv", header=True, schema=schema)

Cela permet d'agréger de nombreux fichiers CSV dans un DataFrame en une seule opération simplifiée.

Une fois les données chargées dans PySpark, les étapes suivantes comprennent le traitement, l'ingénierie des caractéristiques et la construction de modèles d'apprentissage automatique. Notre cours Feature Engineering with PySpark couvre ces concepts en profondeur. 

Techniques d'optimisation pour une lecture efficace des fichiers CSV

Lorsque vous traitez des données CSV à grande échelle, il est essentiel de tirer parti des stratégies d'optimisation de PySpark.

Stratégies de partitionnement

Le partitionnement influe fortement sur les performances en répartissant uniformément les données entre les nœuds de la grappe. Spark permet un contrôle explicite de la taille et du nombre de partitions lors de l'ingestion des données afin d'accélérer les opérations ultérieures :

df = spark.read.csv("data.csv", header=True, schema=schema).repartition(20)

​​.repartition(20) divise le DataFrame en 20 partitions à travers votre cluster Spark. Étant donné que Spark traite les données par morceaux, le fait d'avoir plus de partitions peut :

• Améliorer le parallélisme
• Équilibrer la charge de travail sur l'ensemble du cluster
• Accélérer les transformations et les écritures

Si vous travaillez sur un cluster avec de nombreux cœurs, cela permet de les utiliser pleinement. Mais vous pouvez ralentir les choses si vous en faites trop (par exemple, 1000 partitions sur un petit ensemble de données).

Découvrez d'autres fonctions Spark comme repartition avec notre PySpark Cheat Sheet : Spark en Python. Il entre dans le détail de l'initialisation de Spark en Python, du chargement des données, du tri et du repartitionnement. 

Mise en cache et persistance

Si votre flux de travail implique des accès répétés au même ensemble de données après l'ingestion, la mise en cache de votre DataFrame en mémoire ou sur disque peut considérablement améliorer les performances :

df.cache()

Cependant, n'oubliez pas que la mise en cache nécessite des ressources système suffisantes ; équilibrez toujours l'utilisation de la mémoire par rapport aux gains de performance.

Évaluation paresseuse et déclenchement d'actions

PySpark s'appuie sur un modèle d'évaluation paresseux : les opérations sur les DataFrames transforment les plans au lieu de s'exécuter immédiatement. La lecture des fichiers ne s'effectue qu'en cas de besoin, déclenchée par des commandes telles que show(), count() ou collect():

# no reading yet
df = spark.read.csv("data.csv", header=True, schema=schema)   
# actual read triggered here
df.show(5)  

Cas d'utilisation avancés et considérations

Explorons des scénarios plus complexes que vous pouvez rencontrer lors de la lecture de fichiers CSV : 

Lecture de fichiers CSV compressés

Spark gère efficacement les fichiers CSV compressés comme gz ou .bz2 de manière transparente sans configuration supplémentaire :

spark.read.csv("logs.csv.gz", header=True, schema=schema)

Traitement des enregistrements malformés

Les ensembles de données CSV peuvent contenir des lignes malformées. PySpark propose plusieurs options pour vous aider à gérer les erreurs ou les enregistrements malformés de manière élégante :

• mode="PERMISSIVE" (par défaut) : inclut les lignes malformées dont les colonnes sont remplies de nullités.
• mode="DROPMALFORMED: ignore silencieusement les enregistrements malformés. Ce mode n'est pas pris en charge par les fonctions intégrées de CSV.
• mode="FAILFAST": lève une exception en cas d'enregistrement malformé.

spark.read.csv("data.csv", header=True, schema=schema, mode="FAILFAST")

Paramètres de la langue et de l'encodage

Les données CSV utilisent parfois des encodages non standard. PySpark gère facilement les différents encodages via le paramètre encoding :

spark.read.csv("data_utf8.csv", header=True, encoding="UTF-8")

Les encodages pris en charge sont les suivants, US-ASCII, ISO-8859-1, UTF-8, UTF-16BE, UTF-16LE, et UTF-16.

Meilleures pratiques et pièges courants

Voici quelques bonnes pratiques à garder à l'esprit lors de la lecture de fichiers CSV avec Spark : 

• Spécifiez explicitement le schéma lorsque la structure de l'ensemble de données est connue.
• Contrôlez le partitionnement pour répartir efficacement la charge de travail.
• Mise en cache stratégique des DataFrames fréquemment consultées.
• Déclenchez des actions de lecture de manière intentionnelle, en gardant à l'esprit l'évaluation paresseuse.

Veillez à éviter: 

• Définition de header=False pour les CSV avec des lignes d'en-tête.
• S'appuyer uniquement sur inferSchema dans des ensembles de données volumineux ou consultés de manière répétée.
• Ignorer des paramètres critiques de délimitation ou d'encodage.

Conclusion

Il est essentiel de bien comprendre et d'exploiter les puissantes capacités d'ingestion CSV de PySpark pour un traitement efficace des big data. Grâce à une spécification claire des schémas, à la gestion des formats null personnalisés, à l'utilisation d'un partitionnement efficace et à la gestion des scénarios de fichiers compressés ou multiples, votre flux de travail est rationalisé et performant.

N'oubliez pas que si PySpark offre d'énormes avantages pour les tâches liées aux données à grande échelle, des outils plus simples comme Pandas peuvent encore suffire pour les petits ensembles de données. Utilisez PySpark lorsque vous travaillez avec des données qui dépassent les capacités d'une seule machine, et tenez toujours compte de ses avantages en matière de calcul distribué.

Pour explorer PySpark plus en profondeur, consultez nos cours approfondis sur Spark, notamment :

• Introduction à PySpark
• Fondements de PySpark 
• Fondamentaux du Big Data avec PySpark
• Construire des moteurs de recommandation avec PySpark