Trasformazioni e action
Calcolo lazy
Trasformazioni e action è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Scala for Backend Engineering & Functional Programming, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.
Due tipi di operazioni
Le operazioni di Spark si dividono in trasformazioni (costruiscono un nuovo dataset, in modo lazy) e azioni (avviano il calcolo e restituiscono un risultato o scrivono l'output).
Valutazione lazy
Le trasformazioni sono lazy: registrano le operazioni da eseguire, ma non eseguono nulla. Spark costruisce un grafo aciclico diretto (DAG) delle trasformazioni ed esegue il calcolo solo quando viene chiamata un'azione.
map e filter
map trasforma ogni elemento; filter conserva gli elementi che soddisfano un predicato. Entrambi restituiscono nuovi RDD/Dataset e non eseguono ancora alcuna operazione.
val nums = sc.parallelize(1 to 10)
val evens = nums.filter(_ % 2 == 0).map(_ * 10)
// nothing computed yetflatMap
flatMap associa a ogni elemento zero o più risultati e li appiattisce: è il metodo classico per suddividere le righe in parole.
val lines = sc.parallelize(Seq("hello world", "spark rocks"))
val words = lines.flatMap(_.split(" "))Azioni comuni
Le azioni avviano l'esecuzione:
collect— porta tutti i risultati al drivercount— conta gli elementifirst/take(n)— seleziona righe di esempioreduce— riduce tutto a un unico valore
val total = sc.parallelize(1 to 100).reduce(_ + _)
println(total) // 5050 — runs nowNarrow e wide
Le trasformazioni narrow (map, filter) non richiedono lo spostamento dei dati. Le trasformazioni wide (groupByKey, reduceByKey, join) attivano uno shuffle sulla rete.
reduceByKey
Sugli RDD di coppie chiave-valore, reduceByKey aggrega i valori per chiave. Combina i valori localmente prima dello shuffle, risultando più efficiente di groupByKey.
val pairs = sc.parallelize(Seq(("a", 1), ("b", 1), ("a", 1)))
val counts = pairs.reduceByKey(_ + _)
// (a, 2), (b, 1)Caching
Se un dataset viene riutilizzato in più azioni, cache o persist lo mantiene in memoria, evitando di ricalcolarlo ogni volta.
val cached = sc.parallelize(1 to 1000).filter(_ % 3 == 0).cache()
println(cached.count())
println(cached.sum())Trasformazioni dei DataFrame
I DataFrame hanno trasformazioni lazy proprie: select, where, withColumn, orderBy. Azioni come show e collect le attivano.
import org.apache.spark.sql.functions._
val adults = df.where(col("age") >= 18)
.withColumn("adult", lit(true))
adults.show()Il classico conteggio delle parole
Il job Spark canonico: divide le righe, associa a ogni parola il valore uno e riduce per chiave. Solo il collect finale esegue la pipeline.
val text = sc.textFile("book.txt")
val counts = text.flatMap(_.split(" "))
.map(w => (w, 1))
.reduceByKey(_ + _)
counts.collect().foreach(println)Analogo lazy in Scala semplice
Un analogo Scala autosufficiente: una vista lazy rimanda l'elaborazione fino alla sua valutazione, riproducendo la distinzione di Spark tra trasformazioni e azioni.
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)
}
}Verifica rapida
Quando esegue effettivamente Spark una catena di trasformazioni map e filter?
Riepilogo
Ha imparato il modello di esecuzione di Spark:
- le trasformazioni sono lazy (
map,filter,flatMap,reduceByKey) - le azioni attivano l'elaborazione (
collect,count,reduce) - operazioni narrow e wide (shuffle)
cacheper riutilizzare i risultati
Prossimo argomento: Spark SQL.
Domande Frequenti
La lezione «Trasformazioni e action» è gratuita?
Sì — il testo completo di «Trasformazioni e action» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Scala for Backend Engineering & Functional Programming, passa a CoddyKit PRO. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.
Cosa imparerò in «Trasformazioni e action»?
Calcolo lazy Eserciti Scala for Backend Engineering & Functional Programming con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Scala for Backend Engineering & Functional Programming?
Non è richiesta alcuna esperienza precedente. Scala for Backend Engineering & Functional Programming su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.
Quanto tempo richiede la lezione «Trasformazioni e action»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Scala for Backend Engineering & Functional Programming?
Sì. Ogni lezione Scala for Backend Engineering & Functional Programming include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- RDD e DataFrame
- Trasformazioni e action
- Spark SQL
- Aggregazioni