Programmation Scala

Master2 Management et Sciences de Données

Mr DIATTARA Ibrahima

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

 Sommaire
1. Introduction

2. Déclaration

3. Interpolation

4. Fonction & méthode

5. List &Array

6. Pattern matching

7. Optimisation des inits

8. Lambda Expression

9. Case class vs class simple

10. Implicite

11. Héritage Simple

12. Trait vs Abstract

13. Object Singleton

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

 Install

Pour pratiquer ce cours il faut installer:

Scala
https://downloads.lightbend.com/scala/2.13.1/scala-2.13.1.msi

Apache Zeppelin
http://mirrors.standaloneinstaller.com/apache/zeppelin/zeppelin-0.9.0-preview1/zeppelin-0.9.0-
preview1-bin-netinst.tgz

IntelliJ IDEA
https://www.jetbrains.com/help/idea/installation-guide.html#

Vous pouvez aller sur yutube et taper :

Comment installer IntelliJ IDEA avec scala

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

 Projets
À la fin de ce cours vous aurez deux projets :

❑ Projet Machine Learning [Spark/Scala avec Zeppelin]

❑ Projet Data Engineer [ Spark/Scala/ Maven /GitHup avec IntelliJ ]

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

 1 Introduction

Scala intègre les paradigmes de la programmation orientée objet et ceux de la

programmation fonctionnelle

Le Framework Spark et le système de messagerie Kafka sont développés en Scala

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

 2 Déclaration
Le langage Scala propose différentes façons de déclarer une variable ou une constante
❑ var valeur peut changer (variable)
❑ val valeur immutable(constante)
❑ final éviter les dérivés (override) )

❑ Lazy (lazy est toujours accompagné de val ): pour faire de l évaluation paresseuse , maintenir
l'évaluation d'une expression jusqu'à ce que sa valeur soit nécessaire=> optimisation

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

 3 Interpolation

L’ interpolation consiste d'incorporer des références de variables et de les évaluer directement dans une
chaîne de caractère

❑ Interpoler une référence dans une chaîne

val name="fall"
println("ça va mister " + name+ " ?" ) //dirty code

s
println( "ça va mister $name ?")

❑ Interpoler une évaluation dans une chaîne

val a=10
val b=5
println(" la valeur de a+b est "+a+b+5) ????

s
println( " la valeur de a+b est ${a+b+5} ") ?????

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

 4 Fonction & Méthode
❑ Fonction
def nom_fonction(param1:type,….paramN:type):[typeRetour]={
Intruction1
………..
intructionN
return [typeRetour]
}
def somme(a : Int, b:Int) : Int = {
return a+b
}
Quand on a une seule instruction on peut simplifier une fonction comme suit
def nom_fonction(param1:type, ….paramN:type)=...
def somme(a : Int, b:Int) = a+b

❑ Méthode
def affiche(value : Int) : Unit = {
print(s"la valeur est $value")
}

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

 5 Array & List
val l = List(1,2,3)

val tab = Array(1,2,3)

val mat = List(List(1,2), List(1,3)) ou val mat = Array(Array(1,2), Array(1,3))

Pour voir les opérations CRUD des listes ou tab voici le lien
https://www.tutorialspoint.com/scala/scala_lists.htm

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

 6 Pattern matching

Le pattern matching de Scala possède un cas d’utilisation qui est similaire aux switch-case de Java et de C

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

 7 Option[type]

Option[Type] permet d’inviter l’initialisation des variables, afin d’optimiser la mémoire

Elle permet aussi de gérer les exceptions

❑ Optimisation des affectations

def prixAchat(prix:Int , bonnus:Option[Int]=None)=prix - bonnus.getOrElse(0)
prixAchat(3)
prixAchat(4, Some(1))

❑ Gérer les exceptions

def divide(x:Double, y:Double) : Option[Double]={
y match {
case 0 => None
case _ => Some(x/y)
}
}
val a= divide(1, 0).getOrElse("error check your input parametres!!!! ")

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

 8 Lambda expression
Expression Lambda fait référence à une expression qui utilise une fonction anonyme au lieu d'une variable

var l=List(1, 3,2,0)

var mat=List(List(4,6), List(1,3,4))
❑ Map
l.map(x => e * e )
mat.map(e=>e.map(a=>a*a))

❑ Reduce
l.reduce((a, b) => a + b)

mat.map(e=>e.reduce((a, b)=>a+b)).reduce((a,b)=>a+b)

mat.flatMap(e=>e).reduce((a,b)=>a+b)
❑ MapReduce & filter
l.map(e=>e*2).filter(e=>e+1>=3).reduce((a,b)=>a+b)
l.map(e=>e*2).filter(_>3).reduce((a,b)=>a+b)
l.filter(_==1).length ou l.filter(e=>e==1).length

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

Exo:
Exo1:Manupilation des structures à une dimension
Les fonctions doivent être codées de 3 façons itérative , récursive et fonctionnelle(lambda expression)
❑ Recherche un élément dans une liste => true si trouvé false sino
recherche(list :List[Any], elt:Any)........

❑ Retourne le nombre d’occurrence d’un élément dans un tableau

nboc(list:List[Int],elt:Int))........

Exo2: Manipulation des Structures à deux dimensions

Les fonctions doivent être codées de deux façons itérative et fonctionnelle(lambda expression)

❖ sommeMatrice retourne la somme de tous les éléments de la matrice

sommeMat(mat:List[List[Int]])……
❖ sommeLigneMat retourne une liste qui contient la somme de chaque ligne d'une matrice
sommeligne(mat:List[List[Int]])……….

!!!!!!! Pour les lambda expression limitez vous sur les fonctions filter, map, flatMap, reduce et length

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

 Mise en Exergue impérative vs fonctionnelle

❑ Le code fonctionnel reflète bien les deux étapes de calcul : filtrer l’élément puis compter, alors que le code impératif fait
tout en même temps
❑ La programmation fonctionnelle s'affranchit de façon radicale des effets secondaires (effets de bord) en interdisant toute
opération d'affectation, on constate aussi qu’elle est moins verbeuse

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

 Programmation orientée objet

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

 9 Case class vs class simple

Classe: est un modèle de définition pour des objets ayant le même ensemble d'attributs, et le même ensemble
d'opérations
En scala nous avons 2 types de class , les class simples et les case class

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

 Case class vs class simple
class PersonSimple(nom:String)
case class PersonCase(nom:String)
1 Instance
val p1=new PersonSimple( "fall")
val p2=new PersonsSimple( "fall")
val p3=PersonCase( "diop")
val p4=PersonCase( "diop")
2 Accès
p1.nom p3.nom
3 Comparaison
p1.equals(p2) p3.equals(p4)
4 Copy
val p5=p1.copy() val p5=p3.copy()
5 Patern matching
def guesseth(p:PersonCase ):String={
p match {
case PersonCase("diouf")|PersonCase("sene" ) => "serere"
case PersonCase("ba")|PersonCase("sow") =>"peul"
case _ => "dont know"
}
}
 Conclusion case class vs class simple

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

 10 Implicite

L’utilisation des implicits permet aux développeurs de se faciliter la tâche en laissant le compilateur le
soin d’aller chercher dans le scoop ce qui manque

Devinez le plat que Fatou va préparer si tu es intelligent(e) et donnes ce qui manque

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

 10 Implicite[variable/constante]

implicit val myname= "Diop"

implicit val myage = 20

def salam(salutation:String)(implicit name:String, age:Int ) = s"$salutation $name, you are $age"

❑ Passage explicite
salam("Helo")("diop",28)
❑ Passage implicite
salam("Hello")

Il est impossible d’avoir deux variables ou constantes implicites de même type dans un scoop
=> Impossible d’avoir deux variables ou constantes implicites de même type dans une fonction ou méthode

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

 10 Implicite: [Fonction]

case class Personne(nom: String , age:Int)

implicit def toPersonne( personne: String) = Personne(personne.split(",")(0), personne.split(",")(1).toInt )

def getAgeDans( n:Int, p:Personne ): Int = p.age+n

val s:String= "ndiaye,28 "

getAgeDans(10, )s

implicit def toPersonneDasn10( personne: String ) = Personne( personne.split(",")(0), personne.split(",")(1).toInt +10 )

// error

Il est impossible d’avoir deux méthodes/fonctions implicites de même signature dans un même scoop

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

 Héritage
En scala nous avons trois types héritage
❑ Héritage Mono simple
❑ Héritage Mono avec trait ou class abstraite
❑ Héritage multiple

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

 11 Héritage Mono simple

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données
 11 Héritage Mono simple

Une case class ne peut pas hériter une case class

Une case peut hériter une class simple
Une class simple peut hériter une case class
Une class simple peut hériter une class simple

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

 12 Héritage Mono [class abstract & trait)

❑ Une classe abstraite est une class dont l'implémentation n'est pas complète et qui n'est pas instanciable,

elle sert de base à :

❖ Factoriser le code

❖ Gérer les contraintes

❑ Les traits sont comme les interfaces en Java

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

 12 Abstract

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

 12 Abstract:Application1

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données
 Abstract: Factoriser un code

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données
 Trait Vs class abstract
❖ Constructeur
trait Person(nom:String) abstract class Person(nom:String)

❖ Ajout dans une instance

trait Traitement1{ def action = " i do something "}

abstract class Traitement2 { def action = " i do something "}

case class Ordinateur(marque:String)

val ordi1=new Ordinateur(" HP " ) with Traitement1 val ordi2=new Ordinateur(" HP " ) withTraitement2
ordi.action

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

 Héritage Multiple

❖ Pour faire de l’héritage multiple , il faut utiliser le mot with

NB:with est toujours suivi d’un type trait

Héritier(e) extends with

case class(..) case class(..) si la class à hérité n est pas une class trait
class simple class simple
trait trait
class abstract class abstract

trait T1; trait T2 ; trait T3 | abstract class Abs| class C1 | case class C2(..)
class C extends Abs1 with C2 => error
class C extends Abs1 with T1 with T2 with T2 => ok

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

 Trait Vs Abs

Action Trait Class Abstract

Ajouter dans une instance Yes No
Avoir un constructeur No Yes
with class abstract Yes No
with trait
Faire appel à des fonction No Yes
java sans wrapper(lib)

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données

 13 Singleton

Le langage Scala ne permet pas de définir des méthodes ou des attributs statiques dans une classe, pour faire cela, il faut
utiliser un type de classe particulier qui est instancié par défaut et ne peut être réinstancié. Scala utilise le nom de
«singleton object» pour définir ce type de classe. La définition d'un singleton object est similaire à la définition d'une
classe, sauf qu'il faut utiliser le mot-clé «object» à la place du mot-clé «class»

Mr DIATTARA Ibrahima Université de Thiès Master2 Management et Sciences de Données