PySpark pour les débutants : maîtriser les bases

commence souvent avec des outils comme les pandas. Ils sont intuitifs, puissants et parfaits pour les ensembles de données de petite et moyenne taille. Mais dès que vos données dépassent la taille de la mémoire, des problèmes de performances commencent à apparaître. C’est ici PySpark entre.

Notez que dans cet article, j’utiliserai souvent les termes Spark et PySpark de manière interchangeable. Pour nos besoins, cela n’a pas d’importance, mais n’oubliez pas qu’ils sont différents. Spark est le cadre informatique distribué global (écrit en Scala) et PySpark est une API Python dédiée à Spark.

Qu’est-ce que PySpark ?

PySpark est l’API Python pour Apache Spark, un framework informatique distribué permettant de traiter efficacement de gros volumes de données. Au lieu d’exécuter tous les calculs sur une seule machine, Spark répartit le travail sur plusieurs machines (un cluster), vous permettant de traiter les données à grande échelle tout en écrivant du code qui semble encore familier aux utilisateurs de Python.

L’un des principaux avantages de PySpark est qu’il élimine une grande partie de la complexité des systèmes distribués. Vous n’avez pas besoin de gérer manuellement les threads, la mémoire ou la communication réseau. Spark gère ces préoccupations pour vous, pendant que vous vous concentrez sur la description quoi vous voulez faire avec les données plutôt que comment il devrait être exécuté.

Si vous êtes un nouveau venu dans Spark, vous devez apprendre trois idées clés avant de l’utiliser. Ce sont :

1. Grappes

Lorsque les gens entendent que Spark fonctionne sur un « cluster », cela peut sembler intimidant. En pratique, vous n’avez pas besoin d’une connaissance approfondie des systèmes distribués pour commencer. Un cluster est simplement un groupe de serveurs mis en réseau et pouvant collaborer. Dans une application Spark exécutée sur un cluster, une machine fait office de conducteurcoordonnant le travail, tandis que les autres agissent comme exécuteurs testamentaireseffectuant des calculs sur des blocs de données. Lorsque les nœuds exécuteurs ont terminé leur travail, ils renvoient un signal au nœud pilote, et le pilote peut alors effectuer tout ce qui est nécessaire avec l’ensemble de résultats final.

                          ┌───────────────────┐
                          │       Driver      │
                          │(your PySpark app) │
                          └─────────┬─────────┘
                                    │ 
                                    | The Driver farms out work
                                    | to one or more executors
               ┌────────────────────┼───────────────────────────┐
               │                    │                           │
       ┌───────▼────────┐   ┌───────▼────────┐          ┌───────▼────────┐
       │   Executor 1   │   │   Executor 2   │          │   Executor N   │
       │  processes part│   │  processes part│  ......  │  processes part│
       │   of the data  │   |   of the data  │          │   of the data  │
       └────────────────┘   └────────────────┘          └────────────────┘

N’oubliez pas que vous n’avez pas besoin d’exécuter Spark sur un cluster de calcul physique. Lorsque vous exécutez PySpark localement, Spark simule un cluster sur votre ordinateur portable ou PC utilisant plusieurs cœurs. L’un des points forts de PySpark est que le même code peut ensuite être déployé sur un cluster réel, que ce soit dans le cloud ou sur site, avec seulement des modifications très mineures.

Cette séparation de la coordination et de l’exécution permet à Spark d’évoluer. À mesure que les ensembles de données se développent, davantage d’exécuteurs peuvent être ajoutés pour traiter les données en parallèle, réduisant ainsi le temps d’exécution sans nécessiter de modifications de votre code.

2. La trame de données Spark

Au cœur de PySpark se trouve le API DataFramequi constitue la principale façon dont vous travaillez avec les données dans Spark. Un DataFrame est simplement un tableau de données, composé de lignes et de colonnes – très similaire à un tableau dans une base de données ou à un DataFrame dans les pandas. Si vous avez déjà utilisé SQL ou Pandas, les idées de base vous sembleront familières.

Avec Spark DataFrames, vous pouvez effectuer des tâches de données courantes telles que filtrer des lignes, sélectionner des colonnes, regrouper des données, joindre des tables et calculer des résumés tels que des décomptes ou des moyennes. Ces opérations sont faciles à lire et à écrire, vous permettant de vous concentrer sur quoi vous voulez faire avec les données plutôt qu’avec les détails techniques de leur fonctionnement.

Ce qui rend Spark spécial, c’est ce qui se passe dans les coulisses. Spark détermine automatiquement la manière la plus efficace d’exécuter vos opérations DataFrame, puis les exécute en parallèle sur plusieurs ordinateurs d’un cluster. Vous n’avez pas besoin de gérer cela vous-même : Spark gère des tâches telles que le fractionnement des données, la coordination du travail et la récupération après un échec en cas de problème.

Pour cette raison, Spark DataFrames peut gérer de très grands ensembles de donnéesmême ceux qui sont trop volumineux pour tenir en mémoire sur une seule machine. En même temps, ils fournissent une interface simple et familière, faisant de PySpark un outil puissant mais accessible pour travailler avec le Big Data.

3. Évaluation paresseuse ou enthousiaste

Un autre point fort de PySpark qui mérite d’être connu est son approche de l’exécution paresseuse ou impatiente.

La plupart des bibliothèques de données Python, comme Pandas, utilisent exécution impatiente. Cela signifie que lorsque vous exécutez une opération, elle s’exécute immédiatement, suivie de l’opération suivante, et ainsi de suite.

PySpark gère cela différemment en utilisant une technique appelée exécution paresseuse. Lorsque vous écrivez des transformations de données, telles que la sélection de colonnes ou le filtrage de lignes, Spark ne les exécute pas immédiatement. Au lieu de cela, il crée un plan d’exécution optimisé et exécute le calcul uniquement lorsqu’une action (telle que l’affichage des résultats ou l’écriture de données sur le disque) est déclenchée. Cela permet à Spark d’optimiser le flux de travail avant l’exécution, rendant votre code plus efficace sans effort supplémentaire de votre part.

Eager execution (e.g. pandas)
data  ──filter──► result (computed immediately)

In pandas, each operation runs as soon as it is called. This is 
intuitive but can be inefficient for large datasets.

PySpark uses lazy execution.

Lazy execution (PySpark)
data ──filter──►
        │
        └─groupby──►   (plan builds here)
             │
             └─agg──►  (still no execution)
                     │
                 action ──► executes here

Pour bien comprendre ce point, considérons le scénario suivant. Disons que nous avons une trame de données de 10 millions d’enregistrements que nous voulons…

a) Ajoutez-y une nouvelle colonne vide appelée X

b) Filtrer les données d’une manière qui nous amène à supprimer 50 % des enregistrements

c) Effectuer une agrégation sur les enregistrements restants afin que la nouvelle colonne X contienne la valeur MAX d’une autre valeur de cette ligne

d) Imprimez la ligne avec la valeur la plus élevée de X

Sur un système qui effectue une exécution rapide, comme Pandas, chaque étape est effectuée exactement comme nous l’avons décrit ci-dessus. Pour 10 millions d’enregistrements, cela ressemblerait à ceci :

1. Ajouter une colonne : Le système crée une nouvelle version de l’ensemble de données de 10 millions de lignes en mémoire, en ajoutant la colonne X.
2. Filtre: Le système filtre les 10 millions de lignes, ce qui entraîne 5 millions de suppressions, et écrit un nouveau Ensemble de données de 5 millions de lignes en mémoire.
3. Agrégation: Il calcule la valeur MAX pour chaque ligne et met à jour la colonne.
4. Imprimer: Il trouve la rangée supérieure et vous la montre.

Le problème est que nous avons fait un énorme travail de « gros travail » (ajout d’une colonne à 10 millions de lignes) pour ensuite jeter immédiatement la moitié de ce travail à l’étape suivante.

Spark, en revanche, en raison de son modèle d’exécution paresseux, n’effectue aucun travail lorsque vous définissez les étapes (a), (b) ou (c). Au lieu de cela, il construit un Plan logique (également appelé DAG — Directed Acyclic Graph) pour faire le travail.

Lorsque vous déclenchez enfin l’étape (d) – le Action – L’optimiseur de Spark examine l’ensemble du plan et se rend compte qu’il peut fonctionner beaucoup plus intelligemment :

• Pushdown de prédicat : Spark voit le filtre (supprime 50 % des enregistrements). Au lieu d’ajouter la colonne X à 10 millions de lignes, il déplace le filtrage au tout début.
• Optimisation: Il ajoute uniquement la colonne X et regroupe les restant 5 millions de lignes.
• Résultat: Il évite de traiter 5 millions d’enregistrements, économisant ainsi 50 % de mémoire et de temps CPU.

Configuration de l’environnement de développement

Ok, c’est assez de théorie. Voyons comment installer PySpark sur votre système et exécuter quelques exemples d’extraits de code. Désormais, pour un texte d’introduction pour débutant, la création d’un cluster multi-nœuds réel dépasse le cadre de cet article. Mais comme je l’ai mentionné précédemment, Spark peut créer un cluster synthétique sur votre PC ou ordinateur portable s’il est multicœur, ce qui sera le cas si votre système a moins de 10 ans environ.

La première chose que nous ferons est de mettre en place un environnement de développement distinct pour ce travail, en garantissant que nos projets sont cloisonnés et n’interfèrent pas les uns avec les autres. J’utilise WSL2 Ubuntu pour Windows et Conda pour cette partie, mais n’hésitez pas à utiliser l’environnement et la méthode auxquels vous êtes habitué.

Installez PySpark, etc.

# 1. Create a new environment with Python 3.11 (very stable for Spark)
conda create -n spark_env python=3.11 -y

# 2. Activate it
conda activate spark_env

# 3. Install PySpark and PyArrow (needed for Parquet files)
pip install pyspark pyarrow jupyter

Pour vérifier que PySpark a été correctement installé, tapez la commande pyspark dans une fenêtre de terminal.

$ pyspark

Python 3.11.14 | packaged by conda-forge | (main, Oct 22 2025, 22:46:25) [GCC 14.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
WARNING: Using incubator modules: jdk.incubator.vector
WARNING: package sun.security.action not in java.base
Using Spark's default log4j profile: org/apache/spark/log4j2-defaults.properties
26/01/15 16:15:21 WARN Utils: Your hostname, tpr-desktop, resolves to a loopback address: 127.0.1.1; using 10.255.255.254 instead (on interface lo)
26/01/15 16:15:21 WARN Utils: Set SPARK_LOCAL_IP if you need to bind to another address
Using Spark's default log4j profile: org/apache/spark/log4j2-defaults.properties
Setting default log level to "WARN".
To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).
26/01/15 16:15:22 WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable
WARNING: A terminally deprecated method in sun.misc.Unsafe has been called
WARNING: sun.misc.Unsafe::arrayBaseOffset has been called by org.apache.spark.unsafe.Platform (file:/home/tom/miniconda3/envs/pandas_to_pyspark/lib/python3.11/site-packages/pyspark/jars/spark-unsafe_2.13-4.1.1.jar)
WARNING: Please consider reporting this to the maintainers of class org.apache.spark.unsafe.Platform
WARNING: sun.misc.Unsafe::arrayBaseOffset will be removed in a future release
Welcome to
      ____              __
     / __/__  ___ _____/ /__
    _\ \/ _ \/ _ `/ __/  '_/
   /__ / .__/\_,_/_/ /_/\_\   version 4.1.1
      /_/
Using Python version 3.11.14 (main, Oct 22 2025 22:46:25)
Spark context Web UI available at http://10.255.255.254:4040
Spark context available as 'sc' (master = local[*], app id = local-1768493723158).
SparkSession available as 'spark'.
>>>

Si vous ne voyez pas la bannière de bienvenue de Spark, c’est que quelque chose s’est mal passé et vous devez revérifier votre installation.

Exemple 1 — Création d’un cluster local

C’est en fait assez simple. Tapez simplement ce qui suit dans votre cahier.

from pyspark.sql import SparkSession

# Initialize the Spark Session
spark = SparkSession.builder \
    .master("local[*]") \
    .appName("MyLocalCluster") \
    .config("spark.driver.memory", "2g") \
    .getOrCreate()

# Verify the cluster is running
print(f"Spark is running version: {spark.version}")
print(f"Master URL: {spark.sparkContext.master}")



#
# The output
#
Spark is running version: 4.1.1
Master URL: local[*]

Le Session Spark la notion est importante. Au début de Spark, les utilisateurs devaient jongler avec plusieurs « points d’entrée » (comme SparkContext pour les fonctions principales, SQLContext pour les dataframes et HiveContext pour les bases de données). C’était déroutant pour les débutants.

La SparkSession a été introduite dans Spark 2.0 en tant que « guichet unique » pour tout. Il s’agit du point d’entrée unique pour interagir avec la fonctionnalité Spark.

Exemple 2 — Création d’un dataframe

Créer des Dataframes et manipuler les données qu’elles contiennent dans PySpark sera ce que vous ferez la plupart du temps. Et c’est assez simple à faire. Ici, nous définissons que notre dataframe contiendra trois enregistrements et trois colonnes nommées.

# 1. Define your data as a list of tuples
data = [
    ("Alice", 34, "New York"),
    ("Bob", 45, "London"),
    ("Catherine", 29, "Paris")
]

# 2. Define your column names
columns = ["Name", "Age", "City"]

# 3. Create the DataFrame
df = spark.createDataFrame(data, columns)

# 4. Show the result
df.show()



#
# The output
#
+---------+---+--------+
|     Name|Age|    City|
+---------+---+--------+
|    Alice| 34|New York|
|      Bob| 45|  London|
|Catherine| 29|   Paris|
+---------+---+--------+

Il est plus probable que toutes les trames de données que vous utilisez seront initialement créées en lisant les données d’un fichier ou d’une base de données. Créez un fichier CSV nommé sales_data.csv sur votre système avec le contenu suivant.

transaction_id,customer_name,net_amount,tax_amount, is_member
101,Alice,250.50,25.05,true
102,Bob,120.00,6.00, false
103,Charlie,450.75,25.07,true
104,David,89.99,5.73,false

Créer une trame de données à partir d’un fichier comme celui-ci est simple,

# Load the CSV file
df = spark.read.format("csv") \
    .option("header", "true") \
    .option("inferSchema", "true") \
    .load("sales_data.csv")

# Show the data
print("Dataframe Contents:")
df.show()

# Show the data types (Schema)
print("Data Schema:")
df.printSchema()



#
# The output
#
Dataframe Contents:
+--------------+-------------+----------+----------+----------+
|transaction_id|customer_name|net_amount|tax_amount| is_member|
+--------------+-------------+----------+----------+----------+
|           101|        Alice|     250.5|     25.05|      true|
|           102|          Bob|     120.0|       6.0|     false|
|           103|      Charlie|    450.75|     25.07|      true|
|           104|        David|     89.99|      5.73|     false|
+--------------+-------------+----------+----------+----------+

Data Schema:
root
 |-- transaction_id: integer (nullable = true)
 |-- customer_name: string (nullable = true)
 |-- net_amount: double (nullable = true)
 |-- tax_amount: double (nullable = true)
 |--  is_member: string (nullable = true)

Exemple 3 — Traitement des données

Bien sûr, une fois que vous avez vos données d’entrée dans une trame de données, la prochaine chose que vous voudrez faire est de les traiter ou de les manipuler d’une manière ou d’une autre. C’est aussi facile. En nous référant aux sales_data que nous venons de charger, disons que nous souhaitons calculer le montant brut (net + taxes) et le taux de taxe en pourcentage du montant brut pour chaque enregistrement et les ajouter à notre base de données initiale.

from pyspark.sql import functions as F

# 1. Add 'gross_amount' by adding net and tax
# 2. Add 'tax_percentage' by dividing tax by the new gross amount
df_extended = df.withColumn("gross_amount", F.col("net_amount") + F.col("tax_amount")) \
                .withColumn("tax_percentage", 
                            (F.col("tax_amount") / (F.col("net_amount") + F.col("tax_amount"))) * 100)

# 3. Optional: Round the percentage to 2 decimal places for readability
df_extended = df_extended.withColumn("tax_percentage", F.round(F.col("tax_percentage"), 2))

# Show the new columns along with the old ones
df_extended.show()



#
# The output
#
+--------------+-------------+----------+----------+----------+------------+--------------+
|transaction_id|customer_name|net_amount|tax_amount| is_member|gross_amount|tax_percentage|
+--------------+-------------+----------+----------+----------+------------+--------------+
|           101|        Alice|     250.5|     25.05|      true|      275.55|          9.09|
|           102|          Bob|     120.0|       6.0|     false|       126.0|          4.76|
|           103|      Charlie|    450.75|     25.07|      true|      475.82|          5.27|
|           104|        David|     89.99|      5.73|     false|       95.72|          5.99|
+--------------+-------------+----------+----------+----------+------------+--------------+

Résumé

Ceci conclut notre bref séjour dans le monde de l’informatique distribuée avec PySpark. J’ai expliqué ce qu’est PySpark et pourquoi vous devriez envisager de l’utiliser si les données que vous traitez dépassent vos limites de mémoire. En bref, la capacité de PySpark à s’adapter à de grands clusters multi-nœuds, son modèle d’exécution paresseux et la structure de données dataframe en font une centrale de traitement de données idéale.

PySpark est largement utilisé dans les pipelines d’ingénierie de données, d’analyse et d’apprentissage automatique. Il s’intègre bien aux plates-formes cloud, prend en charge une variété de sources de données (telles que CSV, Parquet et bases de données) et s’adapte depuis un ordinateur portable jusqu’aux grands clusters de production.

Si vous êtes à l’aise avec Python et souhaitez travailler avec de grands ensembles de données sans abandonner la syntaxe familière, PySpark est une excellente prochaine étape. Il comble le fossé entre la simple analyse de données et le traitement de données à grande échelle, ce qui en fait un outil précieux pour toute personne entrant dans le monde du Big Data.

J’espère que vous pourrez utiliser mes exemples et explications de codage simples pour passer à l’étape suivante vers l’utilisation de PySpark dans le monde réel, sur un cluster réel, et pour effectuer un traitement Big Data approprié.