#1.

Initiation rapide à google Colab et Python (Strings et fonction Lambda)

##1.1 C'est quoi Google Colab ? Google Colaboratory ou Colab est un des services cloud de
Google Research. Il permet à quiconque d'écrire et d'exécuter du code Python via le navigateur,
et est particulièrement bien adapté à l'apprentissage automatique et à l'analyse de données.
Plus techniquement, Colab est un service de bloc-notes Jupyter hébergé qui ne nécessite aucune
configuration pour être utilisé, tout en offrant un accès gratuit aux ressources informatiques, y
compris les GPU.

Bases de Jupyter notebook

Dans Jupyter notebook il y a des cellueles de codes et des cellules de texte. Il est possible
d'utiliser également le shell.

Cellule de code

2*3

Cellule de texte

Cecci est une cellule texte.

Accès au shell

!pwd

/content

##1.2 String — Opérations usuelles sur des chaînes Sous Python, les chaînes de caractères sont
des objets. On peut donc effectuer de nombreux traitements dessus en utilisant des méthodes
appropriées. En voici quelques-unes, choisies parmi les plus utiles. Mais vous pouvez obtenir la
liste complète de toutes les méthodes associées à un objet à l’aide de la fonction intégrée
dir(str) ou help(str). Il existe de nombreuses méthodes (sortes de fonctions préfixées par l’objet
ici la chaîne) sur le traitement des chaînes.Les méthodes suivantes sont applicables sur des
objets Python de type str : capitalize(), casefold(), center(), count(), encode(), endswith(),
expandtabs(), find(), format(), format_map(), index(), isalnum(), isalpha(), isascii(), isdecimal(),
isdigit(), isidentifier(), islower(), isnumeric(), isprintable(), isspace(), istitle(), isupper(), join(),
ljust(), lower(), lstrip(), maketrans(), partition(), replace(), rfind(), rindex(), rjust(), rpartition(),
rsplit(), rstrip(), split(), splitlines(), startswith(), strip(), swapcase(), title(), translate(), upper(),
zfill().

dir(str)

Quelques méthodes
####Les méthodes .lower() et .upper()
Les méthodes .lower() et .upper() renvoient un texte en minuscule et en majuscule
respectivement. On remarque que l’utilisation de ces fonctions n’altère pas la chaîne de
caractères de départ mais renvoie une chaîne de caractères transformée. Pour mettre en
majuscule la première lettre seulement, vous pouvez faire :

x='girafe'
print(x [0]. upper () + x [1:])
#'Girafe '
#ou encore plus simple avec la méthode adéquate
print(x. capitalize())
#'Girafe'
#pour mettre en MAJ toute la chaine
print(x. upper())
#pour mettre en MIN toute la chaine
print(x. lower())

Girafe
Girafe
girafe
girafe

####Application: Ecrire votre nom en Majuscule et votre prénom en minuscule avec la

première lettre en majuscule.

####La méthode .split()

La méthode .split() découpe une chaîne de caractères en plusieurs éléments appelés champs, en
utilisant comme séparateur n’importe quelle combinaison « d’espace(s) blanc(s) ».

animaux = "girafe tigre singe souris"

animaux . split ()
#['girafe ', 'tigre ', 'singe ', 'souris ']
for animal in animaux.split ():
print ( animal )

girafe
tigre
singe
souris

Il est possible de modifier le séparateur de champs, par exemple :

animaux = " girafe : tigre : singe :: souris "

animaux . split (":")
#['girafe ', 'tigre ', 'singe ', '', 'souris ']

[' girafe ', ' tigre ', ' singe ', '', ' souris ']
Attention, dans cet exemple, le séparateur est un seul caractères : (et non pas une combinaison
de un ou plusieurs ":)" menant ainsi à une chaîne vide entre singe et souris. Il est également
intéressant d’indiquer à .split() le nombre de fois qu’on souhaite découper la chaîne de
caractères avec l’argument maxsplit() :

animaux = " girafe tigre singe souris "

animaux . split ( maxsplit =2)
#['girafe ', 'tigre singe souris ']
#animaux . split ( maxsplit =2)
#['girafe ', 'tigre ', 'singe souris ']

['girafe', 'tigre', 'singe souris ']

####La méthode .find()

La méthode .find(), quant à elle, recherche une chaîne de caractères passée en argument :

animal = "girafe"
print(animal . find ("i"))
#1
print(animal . find ("afe"))
#3
print(animal . find ("z"))
#-1
print(animal . find ("tig"))
#-1

1
3
-1
-1

####La méthode .replace()

On trouve aussi la méthode .replace() qui substitue une chaîne de caractères par une autre :

animaux = "tigre girafe tigre"

print(animaux.replace("tigre", "singe"))
#'girafe singe '
print(animaux . replace ("i", "o"))
#'gorafe togre '

singe girafe singe

togre gorafe togre

####La méthode .count()

La méthode .count() compte le nombre d’occurrences d’une chaîne de caractères passée en

argument :
animaux = "girafe tigre"
print(animaux . count ("i"))
# 2
print(animaux . count ("z"))
#0
print (animaux . count ("tigre"))

2
0
1

####La méthode .startswith() La méthode .startswith() vérifie si une chaîne de caractères

commence par une autre chaîne de caractères :

chaine = "Bonjour monsieur le capitaine !"

chaine . startswith ("Bonjour")
#True
chaine . startswith ("Au revoir")
#False

False

Cette méthode est particulièrement utile lorsqu’on lit un fichier et que l’on veut récupérer
certaines lignes commençant par un mot-clé. Par exemple dans un fichier PDB, les lignes
contenant les coordonnées des atomes commencent par le mot-clé ATOM.

####La méthode .strip() La méthode .strip() permet de “nettoyer les bords” d’une chaîne de
caractères. C'est l'équivalent de trim() dans Java :

chaine = " Comment enlever les espaces au dé but et à la fin ?

"
chaine.strip()
#'Comment enlever les espaces au dé but et à la fin ?'

{"type":"string"}

La méthode .strip() enlève les espaces situés sur les bords de la chaîne de caractère mais pas
ceux situés entre des caractères visibles. En réalité, cette méthode enlève n’importe quel
combinaison « d’espace(s) blanc(s) » sur les bords, par exemple :

chaine = " \t fonctionne avec les tabulations et les retours à la

ligne \n"
chaine . strip ()
'fonctionne avec les tabulations et les retours à la ligne '

{"type":"string"}

La méthode .strip() est très pratique quand on lit un fichier et qu’on veut se débarrasser des
retours à la ligne.
####Application: On considère la chaîne de caractères val :val = "3.4 17.2 atom " On souhaite
extraire les valeurs 3.4 et 17.2 pour ensuite les additionner.

####Solution:

##1.3 Prérequis: Les fonctions Lambda:

##Qu’est-ce la fonction Lambda en Python ? La fonction lambda est une petite fonction
contenant qu’une seule expression. Elle peut agir sous anonymat parce qu’elle ne nécessite
aucun nom. Elles sont très utiles lorsqu’il faut effectuer des petites tâches avec moins de code.
Ce qui est très pratique lorsqu’on élabore des solutions Big Data.

On retrouve les fonctions lambda dans plusieurs langages de programmation. Elles sont très
pratiques, mais dans cet article, nous nous concentrons ici sur leur utilisation en Python. Voici la
syntaxe de la fonction lambda en Python :

La fonction lambda a trois différentes parties :

• Mot-clé
• Variable/argument lié
• Corps ou expression

Le mot-clé est obligatoire et ne peut être que “lambda”, mais les variables et les corps peuvent
être changés en fonction des exigences.

Quelle est la différence entre les fonctions lambda et les

fonctions régulières ?

Les fonctions lambda sont définies dans l’ensemble par le mot-clé lambda et elles peuvent
comporter n’importe quel nombre d’argument mais une seule expression.

Même sans aucune instruction, la fonction lambda renvoie un objet fonction qui peut être affecté
à n’importe quelle autre variable.

Quant aux fonctions régulières, elles sont créées avec le mot clé def. Le nombre d’argument et
d’expression de ce dernières peuvent être un, deux, voire plus.

Elles sont utilisées pour n’importe quelle instruction et sont généralement utilisées pour les
gros blocs de code.

add3= lambda x:x+3

print(add3(10))

13
C'est équivalent à:

def add3(x):
return x+3
print(add3(10))

13

##Pour quelle raison les fonctions lambda sont très utiles ? On ne voit l’utilité de la fonction
lambda que lorsque l’on veut utiliser une fonction qui prend comme argument une autre
fonction. Par exemple les fonctions map(), filter() …

##Un exemple pratique de fonction lambda en Python Dans cet exemple, nous allons découvrir
l’utilisation de la fonction python filter() avec la notation lambda. Mais avant de commencer,
nous vous conseillons de lire notre tutoriel sur la programmation Python pour obtenir les bases
nécessaires.

La fonction filter() a pour premier argument une fonction et c’est la fonction lambda dans ce cas.
Le deuxième argument est la liste à filtrer.

my_list = [1, 5, 4, 6, 8, 11, 3, 12]

filtered_list = filter(lambda x: (x%2 == 0) , my_list)
new_list = list(filtered_list)
#or in one line
#new_list = list(filter(lambda x: (x%2 == 0) , my_list))

print(new_list)

[4, 6, 8, 12]

my_list = [1, 5, 4, 6, 8, 11, 3, 12]

new_list = list(map(lambda x: x * 2 , my_list))

print(new_list)

[2, 10, 8, 12, 16, 22, 6, 24]

##Application: Utiliser une fonction Lambda pour afficher le carré de la liste des nombres de 1 à
10.

# votre réponse

#2. Premiers pas avec pySpark

##2.1 Installation de pyspark et configuration de Colab Nous devons d'abord installer et

configurer pyspark car il n'est pas installé par défaut dans l'environnement d'exécution Colab.
L'installation de pyspark persistera jusqu'à ce que le runtime soit recyclé.

Installation des dépendances:

 1. Java 8
2. Apache Spark with hadoop and
3. Findspark (used to locate the spark in the system)
#Executer seulement si on travaille sur collab
!apt-get install openjdk-8-jdk-headless -qq > /dev/null
!wget -q http://archive.apache.org/dist/spark/spark-3.1.1/spark-3.1.1-
bin-hadoop3.2.tgz
!tar xf spark-3.1.1-bin-hadoop3.2.tgz
!pip install -q findspark

import os
os.environ["JAVA_HOME"] = "/usr/lib/jvm/java-8-openjdk-amd64"
os.environ["SPARK_HOME"] = "/content/spark-3.1.1-bin-hadoop3.2"
!ls
import findspark
findspark.init()
from pyspark.sql import SparkSession
spark = SparkSession.builder.master("local[*]").getOrCreate()
spark.conf.set("spark.sql.repl.eagerEval.enabled", True) # Property
used to format output tables better
spark

logo.png sample_data spark-3.1.1-bin-hadoop3.2 spark-3.1.1-bin-

hadoop3.2.tgz

<pyspark.sql.session.SparkSession at 0x7f030e88dd60>

2.2 Initialisation de Spark

Il s'agit du démarrage typique pour que Spark fonctionne en mode standalone. On obtient:

• spark : un objet SparkSession - ce notebook agit comme driver program qui

communique avec Spark via la session Spark (nous parlerons de l'architecture
interne de Spark dans le cours).

• sc : un objet SparkContext qui expose l'API de bas niveau de Spark.

#commencez ici
from pyspark import SparkContext
from pyspark.sql import SparkSession

spark = SparkSession\
.builder\
.master('local[*]')\
.getOrCreate()
sc = spark.sparkContext

##2.3 Introduction à Spark RDDs

Cette partie présente l'utilisation des ensembles de données distribués résilients (RDD) dans
Spark. Les RDD sont à la base de l'API "bas niveau" de Spark. Bien que nous utiliserons
principalement l'API DataFrame de niveau supérieur, les RDD sont plus pratiques pour
introduire un certain nombre de concepts de base dans Spark et pour exprimer des calculs de
type MapReduce.

References:

• RDD API documentation.

C'est quoi un RDD?

Les RDD sont "une collection immuable et partitionnée d'éléments qui peuvent être utilisés en
parallèle". Ça signifie:

• Ils sont immuables, car vous ne pouvez pas modifier le contenu des RDD après les
avoir créés.

• Leurs données sont réparties en plusieurs partitions.

• Les partitions peuvent être traitées en parallèle.

2 types d'opérations sur les RDDs transformations and actions:

-Transformations : crée un nouveau RDD à partir d'une source de données ou d'un RDD existant
précédemment. Un graphe acyclique dirigé (DAG) de transformations (dans de nombreux cas
prenant simplement la forme d'une séquence) qui définit un RDD est appelé le RDD lineage.

• Les transformations sont évaluées paresseusement, ce qui signifie qu'elles ne

s'exécuteront que lorsqu'elles seront déclenchées par actions qui renvoie une valeur au
programme pilote.

-Actions : Une action consiste à appliquer une fonction et à retourner une valeur au programme
driver pour par exemple les afficher sur l’écran ou les enregistrer dans un fichier.
data = sc.parallelize([1,2,3,4,5])
print (data)

ParallelCollectionRDD[0] at readRDDFromFile at PythonRDD.scala:274

data = sc.parallelize([(1,2),(3,4),(3,6),(3,4)])
print (data)
data.collect()

ParallelCollectionRDD[3] at readRDDFromFile at PythonRDD.scala:274

[(1, 2), (3, 4), (3, 6), (3, 4)]

type(data)

pyspark.rdd.RDD

data.count()

##Transformations sur les RDD

Il existe deux types de transformations :

• les dépendances étroites où chaque partition d’un parent RDD est utilisé par au plus
une partition d’un RDD enfant,

• les dépendances larges où plusieurs partitions filles peuvent dépendre d’une

partition donnée. Par exemple, la fonction map peut engendrer des dépendances
étroites alors que la fonction join peut produire des dépendances larges.
Ces distinctions sont importantes car :
 • une dépendance étroite permet l’exécution en pipeline sur un seul noeud du cluster.
A l’inverse, une dépendance large nécessite que les données de toutes les partitions
parentes soient présentes et il convient donc de les déplacer entre les noeuds en
utilisant une opération de type MapReduce

• la récupération après un noeud en échec est plus efficace avec une dépendance
étroite puisque seules les partitions parentes perdues doivent être recalculées et
que cela peut être fait en parallèle sur différents noeuds. A l’inverse, avec une
dépendance large, un simple échec d’un noeud peut entrainer la perte de plusieurs
partitions sur tous les ancêtres d’un RDD entraînant une réexécution complète des
opérations.

Les transformations étroites (narrow transformations)

Image(filename='Map.jpg')
num = sc.parallelize([5,5,4,3,2,9,2],3)
num.collect()
num.getNumPartitions()
#partitionnement des données

num.map(lambda a : a*2).collect()
#.collect se fait pas avec les big datas(cas réel)

[10, 10, 8, 6, 4, 18, 4]

#paw c'est le carré de a

num.map(lambda a : pow(a,2)).collect()

[25, 25, 16, 9, 4, 81, 4]

names = sc.parallelize([ "Bills", "Mark","Brain","Mick"])

#ajoute MR au debut de chaque nom

names.map(lambda a : "Mr. "+ a).collect()

['Mr. Bills', 'Mr. Mark', 'Mr. Brain', 'Mr. Mick']

Image(filename='FlatMap.jpg')
rdd = sc.parallelize([ 2, 3,4])
rdd.collect()

[2, 3, 4]

a = range(1,10)
for i in a:
print(i)

1
2
3
4
5
6
7
8
9

rdd.flatMap(lambda x: range(1, x)).collect()

[1, 1, 2, 1, 2, 3]

a = sc.parallelize([1,2,3])

a.map(lambda x: (x,x*10,57)).collect()

[(1, 10, 57), (2, 20, 57), (3, 30, 57)]

#remarquer la différence avec map
a.flatMap(lambda x: (x,x*10,57)).collect()

[1, 10, 57, 2, 20, 57, 3, 30, 57]

Image(filename='Filter.jpg')

num.collect()

[5, 5, 4, 3, 2, 9, 2]

num.filter(lambda x : x%2 == 0).collect()

[4, 2, 2]

names.collect()

['Bills', 'Mark', 'Brain', 'Mick']

names.filter(lambda x : "B" in x).collect()

['Bills', 'Brain']

Image(filename='Union.jpg')
num.collect()

[5, 5, 4, 3, 2, 9, 2]

num2 = sc.parallelize([1,7,9,4,10,15])
num2.collect()

[1, 7, 9, 4, 10, 15]

num3=num2.union(num)
num3.distinct().collect()

[1, 2, 3, 4, 15, 5, 7, 9, 10]

x = sc.parallelize([1,2,3], 2)
y = sc.parallelize([3,4], 1)

z = x.union(y)
z.collect()

[1, 2, 3, 3, 4]

#Image(filename='Sample.jpg')

# sample: Return a random sample subset RDD of the input RDD

# API: (withReplacement: Boolean, fraction: Double, seed: Long =
Utils.random.nextLong): RDD[T]
# Note This is not guaranteed to provide exactly the fraction
specified of the total count of the given
parallel = sc.parallelize(range(1,10))
parallel.collect()

[1, 2, 3, 4, 5, 6, 7, 8, 9]

parallel.sample(True,.2,).collect()

[]

parallel.sample(True,.2,seed=19).collect()

[2, 4, 6, 9]

parallel.sample(False,.2).collect()

[8]

parallel.sample(True,.2).collect()

[5]

parallel.sample(False,.2,seed=23).collect()

[4, 5]

Transformations larges
Image(filename='GroupBy.jpg')

names.collect()
['Bills', 'Mark', 'Brain', 'Mick']

names_gr = names.groupBy(lambda x : x[0]).collect()

names_gr

[('B', <pyspark.resultiterable.ResultIterable at 0x7f4b6ff16920>),

('M', <pyspark.resultiterable.ResultIterable at 0x7f4b6ffe50f0>)]

for (k,v) in names_gr:

print(k,list(v) )

B ['Bills', 'Brain']
M ['Mark', 'Mick']

aa = sc.parallelize([1, 1, 2, 3, 5, 8])

result = aa.groupBy(lambda x: x % 3).collect()

result

[(0, <pyspark.resultiterable.ResultIterable at 0x7f4b6ffe50c0>),

(1, <pyspark.resultiterable.ResultIterable at 0x7f4b871a0d30>),
(2, <pyspark.resultiterable.ResultIterable at 0x7f4b871a0cd0>)]

for (k,v) in result:

print(k, list(v) )

0 [3]
1 [1, 1]
2 [2, 5, 8]

Image(filename='Intersection.jpg')
num.collect()

[5, 5, 4, 3, 2, 9, 2]

num2.collect()

[1, 7, 9, 4, 10, 15]

num.intersection(num2).collect()

[4, 9]

num2.intersection(num).collect()

[4, 9]

#num privé de num2

num.subtract(num2).collect()

[2, 2, 5, 5, 3]

#num2 privé de num

num2.subtract(num).collect()

[10, 1, 7, 15]

Image(filename='Distinct.jpg')
num.collect()

[5, 5, 4, 3, 2, 9, 2]

num.distinct().collect()

[3, 9, 4, 5, 2]

#Join

Transformation sur les paires (Key, Value)

#retourne le nbr d'occurence de chaque couple
data.countByValue()

defaultdict(int, {(1, 2): 1, (3, 4): 2, (3, 6): 1})

dataStr = sc.parallelize([(1,'mike'),(2,'john'),(3,'rambo'),
(4,'bill')])
dataStr.collect()

[(1, 'mike'), (2, 'john'), (3, 'rambo'), (4, 'bill')]

dataStr.count()

dataStr.countByValue()
defaultdict(int,
{(1, 'mike'): 1, (2, 'john'): 1, (3, 'rambo'): 1, (3,
'bill'): 1})

#tri decroissant et retourne les 2 grands elements

data.top(2)

[(3, 6), (3, 4)]

data.collect()

[(1, 2), (3, 4), (3, 6), (3, 4)]

data.sortByKey().collect()

[(1, 2), (3, 4), (3, 6), (3, 4)]

# lookup : Return all value associated with the given key.

data.lookup(3)

[4, 6, 4]

#affiche les cles

data.keys().collect()

[1, 3, 3, 3]

data.values().collect()

[2, 4, 6, 4]

data.mapValues(lambda a : a*a).collect()

[(1, 4), (3, 16), (3, 36), (3, 16)]

# data.map() no use in Key value

# data.reduce() no use in Key value

Image(filename='ReduceByKey.jpg')
data.collect()

[(1, 2), (3, 4), (3, 6), (3, 4)]

data.reduceByKey(lambda x, y : x+y).collect()

[(1, 2), (3, 14)]

data.reduceByKey(max).collect()

[(1, 2), (3, 6)]

Image(filename='GroupByKey.jpg')
# groupBy: This transformation groups all the rows with the same key
into a single row.
result = data.groupByKey().collect()

result

[(1, <pyspark.resultiterable.ResultIterable at 0x7f4b871a2260>),

(3, <pyspark.resultiterable.ResultIterable at 0x7f4b871a1150>)]

for (k,v) in result:

print(k, list(v))

1 [2]
3 [4, 6, 4]

aa = data.groupByKey().mapValues(sum)

aa.collect()

[(1, 2), (3, 14)]

#equivalent à reduceByKey
bb = data.groupByKey().mapValues(max)

bb.collect()

[(1, 2), (3, 6)]

# reduceByKey = gropupByKey().mapValues(), then what is the difference

??
data.collect()

[(1, 2), (3, 4), (3, 6), (3, 4)]

data.flatMapValues(lambda x: range(1, x)).collect()

[(1, 1),
(3, 1),
(3, 2),
(3, 3),
(3, 1),
(3, 2),
(3, 3),
(3, 4),
(3, 5),
(3, 1),
(3, 2),
(3, 3)]

data.collect()

[(1, 2), (3, 4), (3, 6), (3, 4)]

data2 = sc.parallelize([(3,9)])
data2.collect()

[(3, 9)]

data.subtractByKey(data2).collect()

[(1, 2)]

data2.subtractByKey(data).collect()

[]

##Les actions

Image(filename='RDD_Actions_Transformations.jpg')
Create RDD and their Basic Actions
names =
sc.parallelize(['Adam','Cray','Shaun','Brain','Mark','Christ','Shail',
'Satya','Mark','Norby','Frans','Mark','Bill'])

type(names)

pyspark.rdd.RDD

names.collect()

['Adam',
'Cray',
'Shaun',
'Brain',
'Mark',
'Christ',
'Shail',
'Satya',
'Mark',
'Norby',
'Frans',
'Mark',
'Bill']

type(a)

list
names.countByValue()

defaultdict(int,
{'Adam': 1,
'Cray': 1,
'Shaun': 1,
'Brain': 1,
'Mark': 3,
'Christ': 1,
'Shail': 1,
'Satya': 1,
'Norby': 1,
'Frans': 1,
'Bill': 1})

def f(x): print(x)

a=sc.parallelize([1, 2, 3, 4, 5]).foreach(lambda x : print(x))

type(a)

NoneType

a=sc.parallelize([(1,2),(2,4)])

a.countByValue()

names.collect()

['Adam',
'Cray',
'Shaun',
'Brain',
'Mark',
'Christ',
'Shail',
'Satya',
'Mark',
'Norby',
'Frans',
'Mark',
'Bill']

names.take(5)

['Adam', 'Cray', 'Shaun', 'Brain', 'Mark']

employees = sc.textFile("employees.txt")

type(employees)

pyspark.rdd.RDD
employees.collect()

['Adam',
'Cray',
'Shaun',
'Brain',
'Mark',
'Christ',
'Shail',
'Satya',
'Mark',
'Norby',
'Frans',
'Mark',
'Bill']

employees.first()

'Adam'

employees.count()

13

employees.top(5)

['Shaun', 'Shail', 'Satya', 'Norby', 'Mark']

employees.top(19)

['Shaun',
'Shail',
'Satya',
'Norby',
'Mark',
'Mark',
'Mark',
'Frans',
'Cray',
'Christ',
'Brain',
'Bill',
'Adam']

employees.distinct().count()

11
Autres exemples
num = sc.parallelize([5,5,4,3,2,9,2],9)
num.collect()

[5, 5, 4, 3, 2, 9, 2]

num.take(4)

[5, 5, 4, 3]

num.countByValue()

defaultdict(int, {5: 2, 4: 1, 3: 1, 2: 2, 9: 1})

type(num)

pyspark.rdd.RDD

#GLOM : RDD OF TUPLES

num.glom().collect()

[[], [5], [5], [4], [], [3], [2], [9], [2]]

type(num.glom())

pyspark.rdd.PipelinedRDD

num.max()

num.min()

num.mean()

4.285714285714286

Image(filename='Action_Reduce.jpg')
num.collect()

[5, 5, 4, 3, 2, 9, 2]

num.reduce(lambda a,b: a+b)

30

num.reduce(lambda a,b: a*b)

10800

num.reduce(lambda x,y: x if x > y else y)

def myfun(a,b):
return a*2 + b*2

num.reduce(myfun)

872

num.collect()

[5, 5, 4, 3, 2, 9, 2]

num.takeOrdered(3)

[2, 2, 3]
# fold: the initial value for the accumulated result of each partition
for the op operator,
# and also the initial value for the combine results from different
partitions

num = sc.parallelize([5,5,4,3,2,9,2],2)
num.collect()

[5, 5, 4, 3, 2, 9, 2]

num.glom().collect()

[[5, 5, 4], [3, 2, 9, 2]]

num.reduce(lambda a,b: a+b)

30

num.reduce(lambda a,b: a*b)

10800

num.fold(2,lambda a,b:a+b)

34

num.fold(2,lambda a,b : a*b )

86400

from operator import add

b=sc.parallelize([1, 2, 3, 4, 5])
b.fold(1, add)

17

from operator import add,mul

num3 = sc.parallelize([5,5,4,3,2,9,2]).fold(10,mul)
num3

1080000

b = sc.parallelize(range(1,10))

b.collect()

[1, 2, 3, 4, 5, 6, 7, 8, 9]

#3.Application: Word Count importer le fichier testSpark et compter le nombre de mot.

text = sc.parallelize(["Bonjour les amis ","les amis sont là "],2)

mots=text.flatMap( lambda a: a.split())
#mots.collect()
couples = mots.map(lambda a: (a,1))
couples.collect()
result= couples.reduceByKey(lambda x,y: x+y)
result.collect()

[('les', 2), ('amis', 2), ('sont', 1), ('Bonjour', 1), ('là', 1)]