Scala PySpark Big Data en pratique : le code et les commandes qui comptent vraiment

// Tapez ces commandes une par une dans le spark-shell :

scala> import spark.implicits._
// déjà importé automatiquement, mais utile si vous créez votre propre SparkSession

scala> val data = Seq(("Java", "20000"), ("Python", "100000"), ("Scala", "3000"))
// data: Seq[(String, String)] = List((Java,20000), (Python,100000), (Scala,3000))

scala> val df = data.toDF()
// df: org.apache.spark.sql.DataFrame = [_1: string, _2: string]

scala> df.show()
// +------+------+
// |    _1|    _2|
// +------+------+
// |  Java| 20000|
// |Python|100000|
// | Scala|  3000|
// +------+------+

scala> val df = data.toDF("langage", "offres")
scala> df.show()
// +-------+------+
// |langage|offres|
// +-------+------+
// |   Java| 20000|
// | Python|100000|
// |  Scala|  3000|
// +-------+------+

// Afficher l'aide complète (liste de toutes les commandes spéciales)
scala> :help

// Étape 1 : tapez :paste et appuyez sur Entrée
scala> :paste
// Entering paste mode (ctrl-D to finish)

// Étape 2 : collez votre code multi-lignes
val noms = Seq("Alice", "Bob", "Charlie")
val rdd = sc.parallelize(noms)
val majuscules = rdd.map(_.toUpperCase)
majuscules.collect()

// Étape 3 : appuyez sur Ctrl+D pour exécuter
// Exiting paste mode, now interpreting.

// noms: Seq[String] = List(Alice, Bob, Charlie)
// rdd: org.apache.spark.rdd.RDD[String] = ...
// majuscules: org.apache.spark.rdd.RDD[String] = ...
// res0: Array[String] = Array(ALICE, BOB, CHARLIE)

val jour = "Mercredi"

val typeJour = jour match {
  case "Lundi" | "Mardi" | "Mercredi" | "Jeudi" | "Vendredi" =>
    "Jour ouvré"
  case "Samedi" | "Dimanche" =>
    "Week-end"
  case _ =>
    "Jour inconnu"  // _ = la boîte "Autres" du tri postal
}

println(typeJour)  // "Jour ouvré"

val note = 15

val mention = note match {
  case 20                 => "Parfait"
  case 16 | 17 | 18 | 19 => "Très bien"
  case 14 | 15            => "Bien"
  case 12 | 13            => "Assez bien"
  case 10 | 11            => "Passable"
  case _                  => "Insuffisant"
}

println(mention)  // "Bien"

// Scala : match est une expression, on peut l'assigner directement
val categorie = age match {
  case a if a < 18  => "Mineur"
  case a if a < 65  => "Adulte"
  case _            => "Senior"
}

// On peut aussi l'utiliser comme argument d'une fonction
println(age match {
  case a if a < 18 => "Mineur"
  case _           => "Adulte"
})

// Ou dans une interpolation de string
val message = s"Statut : ${age match {
  case a if a < 18 => "Mineur"
  case _           => "Adulte"
}}"

// Java : le switch (avant Java 14) ne retourne pas de valeur
// Il fallait écrire :
String categorie;
switch (age) {
  case ...: categorie = "Mineur"; break;
  default:  categorie = "Adulte";
}
// Java 14+ a ajouté les switch expressions pour combler ce manque

# Python 3.10+ structural pattern matching
jour = "Mercredi"
match jour:
    case "Lundi" | "Mardi" | "Mercredi" | "Jeudi" | "Vendredi":
        type_jour = "Jour ouvre"
    case "Samedi" | "Dimanche":
        type_jour = "Week-end"
    case _:
        type_jour = "Jour inconnu"

# Difference : en Python, match est une instruction (pas d'assignation directe)
# En Scala : val x = valeur match { ... }  <-- expression qui retourne une valeur
# En Python : vous devez assigner dans chaque branche manuellement

# Python < 3.10 : pas de match/case, on utilise if/elif/else
jour = "Mercredi"

if jour in ("Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi"):
    type_jour = "Jour ouvre"
elif jour in ("Samedi", "Dimanche"):
    type_jour = "Week-end"
else:
    type_jour = "Jour inconnu"