0Pricing
Scala for Backend Engineering & Functional Programming · Lekcja

Przekształcenia i akcje

Leniwe obliczenia

Przekształcenia i akcje to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Scala for Backend Engineering & Functional Programming, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Scala for Backend Engineering & Functional Programming zawiera 4 lekcji w sumie.

Dwa rodzaje operacji

Operacje Sparka dzielą się na transformacje (tworzą nowy dataset i są leniwe) oraz akcje (uruchamiają obliczenia i zwracają wynik lub zapisują dane wyjściowe).

Leniwe obliczanie

Transformacje są leniwe: rejestrują, co należy zrobić, ale niczego nie wykonują. Spark buduje skierowany graf acykliczny (DAG) transformacji i wykonuje je dopiero po wywołaniu akcji.

map i filter

map przekształca każdy element, a filter zachowuje elementy spełniające predykat. Oba zwracają nowe RDD lub Datasety i jeszcze ich nie wykonują.

val nums  = sc.parallelize(1 to 10)
val evens = nums.filter(_ % 2 == 0).map(_ * 10)
// nothing computed yet

flatMap

flatMap mapuje każdy element na zero lub więcej wyników i spłaszcza je — klasycznie służy do dzielenia wierszy na słowa.

val lines = sc.parallelize(Seq("hello world", "spark rocks"))
val words = lines.flatMap(_.split(" "))

Typowe akcje

Działania wyzwalają wykonanie:

  • collect — sprowadza wszystkie wyniki do sterownika
  • count — zlicza elementy
  • first / take(n) — pobiera przykładowe wiersze
  • reduce — scala elementy w jedną wartość
val total = sc.parallelize(1 to 100).reduce(_ + _)
println(total) // 5050 — runs now

Wąskie a szerokie

Transformacje wąskie (map, filter) nie wymagają przenoszenia danych. Transformacje szerokie (groupByKey, reduceByKey, join) wyzwalają operację shuffle w całej sieci.

reduceByKey

W przypadku RDD typu klucz-wartość reduceByKey agreguje wartości dla każdego klucza. Najpierw łączy je lokalnie, a dopiero potem wykonuje shuffle, dzięki czemu jest wydajniejsze niż groupByKey.

val pairs  = sc.parallelize(Seq(("a", 1), ("b", 1), ("a", 1)))
val counts = pairs.reduceByKey(_ + _)
// (a, 2), (b, 1)

Buforowanie

Jeśli zbiór danych jest używany w wielu działaniach, cache lub persist przechowuje go w pamięci, aby nie trzeba było obliczać go ponownie za każdym razem.

val cached = sc.parallelize(1 to 1000).filter(_ % 3 == 0).cache()
println(cached.count())
println(cached.sum())

Transformacje DataFrame

DataFrame mają własne leniwe transformacje: select, where, withColumn, orderBy. Działania takie jak show i collect je wyzwalają.

import org.apache.spark.sql.functions._

val adults = df.where(col("age") >= 18)
               .withColumn("adult", lit(true))
adults.show()

Klasyczne zliczanie słów

Kanoniczne zadanie w Spark: podzielić wiersze, przypisać każdemu słowu wartość jeden, a następnie zredukować według klucza. Tylko końcowe collect uruchamia cały potok.

val text   = sc.textFile("book.txt")
val counts = text.flatMap(_.split(" "))
                 .map(w => (w, 1))
                 .reduceByKey(_ + _)
counts.collect().foreach(println)

Prosty odpowiednik leniwej ewaluacji w Scali

Samodzielny odpowiednik w Scali: leniwy widok odracza pracę do momentu wymuszenia, odwzorowując podział na transformacje i działania w 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)
  }
}

Szybkie sprawdzenie

Kiedy Spark faktycznie wykonuje łańcuch transformacji map i filter?

Podsumowanie

Uczestnik poznał model wykonywania Spark:

  • Transformacje są leniwe (map, filter, flatMap, reduceByKey)
  • Działania wyzwalają pracę (collect, count, reduce)
  • operacje wąskie i szerokie (shuffle)
  • cache służy do ponownego używania wyników

Następnie: Spark SQL.

Często zadawane pytania

Czy lekcja „Przekształcenia i akcje” jest bezpłatna?

Tak — pełny tekst „Przekształcenia i akcje” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Scala for Backend Engineering & Functional Programming, przejdź na CoddyKit PRO. Kurs Scala for Backend Engineering & Functional Programming zawiera 4 lekcji w sumie.

Co nauczysz się w „Przekształcenia i akcje”?

Leniwe obliczenia Ćwiczysz Scala for Backend Engineering & Functional Programming z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Scala for Backend Engineering & Functional Programming?

Nie wymagamy żadnego doświadczenia. Scala for Backend Engineering & Functional Programming w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Przekształcenia i akcje”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Scala for Backend Engineering & Functional Programming?

Tak. Każda lekcja Scala for Backend Engineering & Functional Programming zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. RDD i DataFrame’y
  2. Przekształcenia i akcje
  3. Spark SQL
  4. Agregacje
← Powrót do Scala for Backend Engineering & Functional Programming