Agrégations
Regroupez et agrégez
Agrégations est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 4 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.
Pourquoi agréger ?
Les agrégations résument plusieurs lignes en un nombre réduit de lignes : totaux, moyennes et comptages par groupe. Dans Spark, ce sont des opérations étendues qui peuvent redistribuer les données dans le cluster.
Agrégations globales
Calculez un seul résumé sur l'ensemble du DataFrame avec agg et des fonctions comme count, sum, avg, min et max.
import org.apache.spark.sql.functions._
df.agg(
count("*").as("rows"),
avg("age").as("avg_age")
).show()groupBy
groupBy répartit les lignes selon une ou plusieurs colonnes et produit un RelationalGroupedDataset prêt pour l'agrégation.
import org.apache.spark.sql.functions._
val byCity = df.groupBy("city").agg(count("*").as("people"))
byCity.show()Agrégations multiples
Transmettez plusieurs expressions d'agrégation à agg pour calculer plusieurs résumés par groupe en un seul passage.
import org.apache.spark.sql.functions._
df.groupBy("department").agg(
sum("salary").as("total"),
avg("salary").as("avg"),
max("salary").as("top")
).show()Compter les valeurs distinctes
Utilisez countDistinct pour compter les valeurs uniques, et approx_count_distinct pour obtenir plus rapidement un décompte approximatif sur de très grands ensembles de données.
import org.apache.spark.sql.functions._
df.agg(countDistinct("city").as("unique_cities")).show()Filtrer les groupes avec having
En SQL, HAVING filtre les groupes agrégés. Dans le DSL, appliquez un filter après agg sur la colonne calculée.
import org.apache.spark.sql.functions._
df.groupBy("city")
.agg(count("*").as("n"))
.filter(col("n") > 100)
.show()Agréger en SQL
La même logique qu'une requête SQL sur une vue enregistrée, avec GROUP BY et HAVING.
df.createOrReplaceTempView("people")
spark.sql(
"SELECT city, COUNT(*) AS n FROM people GROUP BY city HAVING COUNT(*) > 100"
).show()Tableaux croisés
pivot transforme les valeurs distinctes d'une colonne en colonnes séparées — pratique pour les tableaux croisés, comme les ventes par région et par trimestre.
import org.apache.spark.sql.functions._
sales.groupBy("region")
.pivot("quarter")
.agg(sum("amount"))
.show()Fonctions de fenêtre
Les fonctions de fenêtre agrégeront sur un cadre glissant sans regrouper les lignes — idéal pour les totaux cumulés ou les classements.
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()Agrégations de RDD
Au niveau des RDD, aggregateByKey et reduceByKey combinent les valeurs par clé selon une logique personnalisée et effectuent une combinaison locale préalable pour gagner en efficacité.
val pairs = sc.parallelize(Seq(("a", 10), ("a", 20), ("b", 5)))
val sums = pairs.reduceByKey(_ + _)
// (a, 30), (b, 5)groupBy Scala classique
Un équivalent autonome : le groupBy des collections Scala associé à mapValues reproduit un regroupement suivi d'une agrégation dans Spark.
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") }
}
}Vérification rapide
Quelle fonctionnalité agrège les lignes d'un cadre sans les regrouper en une seule ligne par groupe ?
Récapitulatif
Vous avez agrégé des données dans Spark :
aggaveccount,sum,avg,minetmaxgroupBy, agrégations multiples et filtreshavingpivotet fonctions de fenêtre- RDD
reduceByKey/aggregateByKey
Vous avez terminé le cours Apache Spark.
Questions Fréquemment Posées
La leçon « Agrégations » est-elle gratuite ?
Oui — le texte complet de « Agrégations » 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 « Agrégations » ?
Regroupez et agrégez 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 4 sur 4.
Combien de temps prend la leçon « Agrégations » ?
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.