Transformations et actions
Calcul différé
Transformations et actions est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Scala for Backend Engineering & Functional Programming, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.
Deux types d'opérations
Les opérations Spark se répartissent entre les transformations (qui construisent un nouveau jeu de données, de manière différée) et les actions (qui déclenchent le calcul et renvoient un résultat ou écrivent une sortie).
Évaluation différée
Les transformations sont différées : elles enregistrent les opérations à effectuer sans rien exécuter. Spark construit un graphe orienté acyclique (DAG) de transformations et ne l'exécute que lorsqu'une action est appelée.
map et filter
map transforme chaque élément ; filter conserve les éléments qui correspondent à un prédicat. Les deux renvoient de nouveaux RDD ou Datasets et ne s'exécutent pas immédiatement.
val nums = sc.parallelize(1 to 10)
val evens = nums.filter(_ % 2 == 0).map(_ * 10)
// nothing computed yetflatMap
flatMap associe à chaque élément zéro, une ou plusieurs sorties, puis les aplatit — une opération classique pour découper des lignes en mots.
val lines = sc.parallelize(Seq("hello world", "spark rocks"))
val words = lines.flatMap(_.split(" "))Actions courantes
Les actions déclenchent l'exécution :
collect— ramener tous les résultats au pilotecount— compter les élémentsfirst/take(n)— échantillonner des lignesreduce— réduire à une seule valeur
val total = sc.parallelize(1 to 100).reduce(_ + _)
println(total) // 5050 — runs nowÉtroites ou larges
Les transformations étroites (map, filter) ne nécessitent aucun déplacement de données. Les transformations larges (groupByKey, reduceByKey, join) déclenchent un shuffle sur le réseau.
reduceByKey
Sur les RDD de paires clé-valeur, reduceByKey agrège les valeurs pour chaque clé. Il les combine localement avant le shuffle, ce qui le rend plus efficace que groupByKey.
val pairs = sc.parallelize(Seq(("a", 1), ("b", 1), ("a", 1)))
val counts = pairs.reduceByKey(_ + _)
// (a, 2), (b, 1)Mise en cache
Si un jeu de données est réutilisé par plusieurs actions, cache ou persist le conserve en mémoire afin d'éviter de le recalculer à chaque fois.
val cached = sc.parallelize(1 to 1000).filter(_ % 3 == 0).cache()
println(cached.count())
println(cached.sum())Transformations de DataFrame
Les DataFrames possèdent leurs propres transformations différées : select, where, withColumn, orderBy. Des actions comme show et collect les déclenchent.
import org.apache.spark.sql.functions._
val adults = df.where(col("age") >= 18)
.withColumn("adult", lit(true))
adults.show()Le grand classique du comptage des mots
La tâche Spark canonique : découper les lignes, associer la valeur un à chaque mot, puis réduire par clé. Seul le collect final exécute le pipeline.
val text = sc.textFile("book.txt")
val counts = text.flatMap(_.split(" "))
.map(w => (w, 1))
.reduceByKey(_ + _)
counts.collect().foreach(println)Équivalent Scala classique avec évaluation différée
Un équivalent Scala autonome : une vue différée reporte le travail jusqu'à son évaluation, reproduisant la séparation entre transformations et actions de Spark.
object Main {
def main(args: Array[String]): Unit = {
val pipeline = (1 to 10).view.filter(_ % 2 == 0).map(_ * 10) // lazy
val result = pipeline.toList // forces evaluation (action)
println(result)
}
}Vérification rapide
Quand Spark exécute-t-il réellement une chaîne de transformations map et filter ?
Récapitulatif
Vous avez appris le modèle d'exécution de Spark :
- Les transformations sont différées (
map,filter,flatMap,reduceByKey) - Les actions déclenchent le travail (
collect,count,reduce) - les opérations étroites ou larges (shuffle)
cachepour réutiliser les résultats
Ensuite : Spark SQL.
Questions Fréquemment Posées
La leçon « Transformations et actions » est-elle gratuite ?
Oui — le texte complet de « Transformations et actions » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Scala for Backend Engineering & Functional Programming, passe à CoddyKit PRO. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Transformations et actions » ?
Calcul différé Tu pratiques Scala for Backend Engineering & Functional Programming avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Scala for Backend Engineering & Functional Programming ?
Aucune expérience préalable n'est requise. Scala for Backend Engineering & Functional Programming sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.
Combien de temps prend la leçon « Transformations et actions » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Scala for Backend Engineering & Functional Programming ?
Oui. Chaque leçon Scala for Backend Engineering & Functional Programming inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- RDD et DataFrames
- Transformations et actions
- Spark SQL
- Agrégations