Aggregationen
Gruppieren und aggregieren
Aggregationen ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Scala for Backend Engineering & Functional Programming-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.
Warum aggregieren?
Aggregationen fassen viele Zeilen zu weniger Zeilen zusammen: Summen, Mittelwerte und Anzahlen pro Gruppe. In Spark sind sie breite Operationen, die Daten möglicherweise im Cluster per Shuffle übertragen.
Globale Aggregationen
Berechnen Sie mit agg und Funktionen wie count, sum, avg, min und max eine einzige Zusammenfassung für den gesamten DataFrame.
import org.apache.spark.sql.functions._
df.agg(
count("*").as("rows"),
avg("age").as("avg_age")
).show()groupBy
groupBy partitioniert Zeilen nach einer oder mehreren Spalten und erzeugt ein für Aggregationen bereites RelationalGroupedDataset.
import org.apache.spark.sql.functions._
val byCity = df.groupBy("city").agg(count("*").as("people"))
byCity.show()Mehrere Aggregationen
Übergeben Sie mehrere Aggregationsausdrücke an agg, um in einem Durchlauf mehrere Zusammenfassungen pro Gruppe zu berechnen.
import org.apache.spark.sql.functions._
df.groupBy("department").agg(
sum("salary").as("total"),
avg("salary").as("avg"),
max("salary").as("top")
).show()Eindeutige Werte zählen
Verwenden Sie countDistinct, um eindeutige Werte zu zählen, und approx_count_distinct für eine schnellere, angenäherte Zählung bei sehr großen Datasets.
import org.apache.spark.sql.functions._
df.agg(countDistinct("city").as("unique_cities")).show()Gruppen mit having filtern
In SQL filtert HAVING aggregierte Gruppen. In der DSL wenden Sie nach agg einen filter auf die berechnete Spalte an.
import org.apache.spark.sql.functions._
df.groupBy("city")
.agg(count("*").as("n"))
.filter(col("n") > 100)
.show()In SQL aggregieren
Dieselbe Logik wie bei einer SQL-Abfrage für eine registrierte Sicht mit GROUP BY und HAVING.
df.createOrReplaceTempView("people")
spark.sql(
"SELECT city, COUNT(*) AS n FROM people GROUP BY city HAVING COUNT(*) > 100"
).show()Pivot-Tabellen
pivot wandelt eindeutige Werte einer Spalte in eigene Spalten um — praktisch für Kreuztabellen wie Verkäufe pro Region und Quartal.
import org.apache.spark.sql.functions._
sales.groupBy("region")
.pivot("quarter")
.agg(sum("amount"))
.show()Fensterfunktionen
Fensterfunktionen aggregieren über einen gleitenden Rahmen, ohne Zeilen zusammenzufassen — ideal für laufende Summen oder Rangfolgen.
import org.apache.spark.sql.expressions.Window
import org.apache.spark.sql.functions._
val w = Window.partitionBy("dept").orderBy(col("salary").desc)
df.withColumn("rank", rank().over(w)).show()RDD-Aggregationen
Auf RDD-Ebene kombinieren aggregateByKey und reduceByKey Werte pro Schlüssel mit benutzerdefinierter Logik und lokaler Voraggregation für bessere Effizienz.
val pairs = sc.parallelize(Seq(("a", 10), ("a", 20), ("b", 5)))
val sums = pairs.reduceByKey(_ + _)
// (a, 30), (b, 5)Einfaches Scala-groupBy
Ein eigenständiges Pendant: Das groupBy von Scala-Collections zusammen mit mapValues bildet eine Gruppierung und Aggregation in Spark nach.
object Main {
def main(args: Array[String]): Unit = {
val data = Seq(("a", 10), ("a", 20), ("b", 5))
val sums = data.groupBy(_._1).map { case (k, v) => k -> v.map(_._2).sum }
sums.toSeq.sortBy(_._1).foreach { case (k, s) => println(s"$k: $s") }
}
}Schnelltest
Welche Funktion aggregiert über einen Zeilenrahmen, ohne ihn zu einer Zeile pro Gruppe zusammenzufassen?
Zusammenfassung
Sie haben Daten in Spark aggregiert:
aggmitcount,sum,avg,min,maxgroupBy, mehrere Aggregationen undhaving-Filterpivotund Fensterfunktionen- RDD-
reduceByKey/aggregateByKey
Sie haben den Apache-Spark-Kurs abgeschlossen.
Häufig gestellte Fragen
Ist die Lektion „Aggregationen“ kostenlos?
Ja — der vollständige Text von „Aggregationen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Scala for Backend Engineering & Functional Programming-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Aggregationen“?
Gruppieren und aggregieren Du übst Scala for Backend Engineering & Functional Programming mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Scala for Backend Engineering & Functional Programming zu starten?
Keine Vorkenntnisse erforderlich. Scala for Backend Engineering & Functional Programming auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.
Wie lange dauert die Lektion „Aggregationen“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Scala for Backend Engineering & Functional Programming-Lektion Code schreiben und ausführen?
Ja. Jede Scala for Backend Engineering & Functional Programming-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.