Compte Rendu du TP3 :

22061

Exercice 1 :

Q1/ le nombre de ligne dans le fichier romeoetjuliette.txt est :

from pyspark import *

from pyspark.sql import SparkSession

spark = SparkSession.builder.appName('22061 Spark

Apps').getOrCreate()

sc = spark.sparkContext

print('#################')
print('le nombre de ligne dans le fichier ')
print('**************************')

file_in = sc.textFile('romeoetjuliette.txt')

num_lines = file_in.count()
print('Number of lines in file : {}'.format(num_lines))

num_lines_rdd = sc.parallelize([num_lines])

# Sauvegarder le nombre de lignes

num_lines_rdd.saveAsTextFile("hdfs://192.168.60.50:9000/output/tp
3/22061/exo1/Q1")

print('**************************')
print('**************************')
print('**************************')

print('*** The END ***')

Q2/ le nombre de mot dans le fichier romeoetjuliette.txt :

from pyspark import *

from pyspark.sql import SparkSession
import re

spark = SparkSession.builder.appName('22061 Spark

Apps').getOrCreate()

sc = spark.sparkContext

print('#################')
print('le nombre de ligne dans le fichier ')
print('**************************')

file_in = sc.textFile('romeoetjuliette.txt')

def split_function(line):
words = re.findall(r'\b\w+\b', line)
return words

words = file_in.flatMap(split_function)

num_words = words.count()

print("Nombre de mots dans le fichier:", num_words)

num_words_rdd = sc.parallelize([num_words])
num_words_rdd.saveAsTextFile("output/tp3/22061/exo1/Q2")

print('**************************')
print('**************************')
print('**************************')

print('*** The END ***')

Q3/ :

from pyspark import *

from pyspark.sql import SparkSession
import re

spark = SparkSession.builder.appName('22061 Spark

Apps').getOrCreate()

sc = spark.sparkContext
print('#################')
print('le nombre de ligne dans le fichier ')
print('**************************')

# Charger le fichier texte dans un RDD

file_in = sc.textFile('romeoetjuliette.txt')

# Filtrer les lignes qui commencent par le nom "Romeo"

lines_with_romeo = file_in.filter(lambda line:
line.startswith("Romeo"))

# Compter le nombre de répliques de Romeo

num_lines_with_romeo = lines_with_romeo.count()

# Afficher le nombre de répliques de Romeo

print("Nombre de répliques de Romeo dans la pièce:",
num_lines_with_romeo)

num_lines_with_romeo_rdd = sc.parallelize([num_lines_with_romeo])

num_lines_with_romeo_rdd.saveAsTextFile("output/tp3/22061/exo1/Q3
")

print('**************************')
print('**************************')
print('**************************')

print('*** The END ***')

Q4/ :

from pyspark import *

from pyspark.sql import SparkSession
import re

spark = SparkSession.builder.appName('22061 Spark

Apps').getOrCreate()

sc = spark.sparkContext

print('#################')

print('**************************')

file_in = sc.textFile('romeoetjuliette.txt')

# Diviser chaque ligne en mots et filtrer pour ne garder que

"Mantua"
word_mantua_count = file_in.flatMap(lambda line: line.split()) \
.filter(lambda word: word == "Mantua")
\
.count()

# Afficher le nombre d'occurrences de "Mantua"

print("Nombre d'occurrences de 'Mantua' dans la pièce:",
word_mantua_count)

# Créer un RDD à partir du comptage pour pouvoir l'enregistrer

word_mantua_rdd = sc.parallelize([("Nombre d'occurrences de
'Mantua'", word_mantua_count)])

# Enregistrer le résultat dans un fichier texte

word_mantua_rdd.saveAsTextFile("output/tp3/22061/exo1/Q4")

print('**************************')
print('**************************')
print('**************************')

print('*** The END ***')

Q5 :

from pyspark import *

from pyspark.sql import SparkSession

# Initialiser la session Spark

spark = SparkSession.builder.appName('22061 Spark
Apps').getOrCreate()

# Obtenir le contexte Spark

sc = spark.sparkContext

print('#################')
print('Affichage des 10 premiers éléments avec numéro de ligne')

# Charger le fichier texte dans un RDD

file_in = sc.textFile('romeoetjuliette.txt')

# Créer un RDD contenant un tuple (numéro de ligne, contenu de la

ligne)
# en utilisant la fonction zipWithIndex()
rdd_with_index = file_in.zipWithIndex().map(lambda x: (x[1] + 1,
x[0])) # Ajouter 1 pour obtenir un numéro de ligne commençant à
1

# Afficher les 10 premiers éléments dans la console

for line_number, line_content in rdd_with_index.take(10):
print(f"Line {line_number}: {line_content}")

# Sauvegarder les 10 premiers éléments dans un fichier de sortie

sc.parallelize(rdd_with_index.take(10)) \
.map(lambda x: f"Line {x[0]}: {x[1]}") \
.saveAsTextFile("output/tp3/22061/exo1/Q5")
print('**************************')
print('**************************')
print('**************************')

print('*** The END ***')

Exercice 2 :

Q1 :

from pyspark import SparkContext

# Créer le contexte Spark

sc = SparkContext("local", "Exercise2")

print ("debut du programme ")

print("*******************")
print("###################")

print ("le sauvegarde a ete fait avec succes ")

# Définir la fonction pour séparer les éléments
def sep_fun(x):
return x.split('::')

# Charger les fichiers dans les RDDs

movies_rdd = sc.textFile("movies.dat") \
.map(sep_fun)
ratings_rdd = sc.textFile("ratings.dat") \
.map(sep_fun)
users_rdd = sc.textFile("users.dat") \
.map(sep_fun)

# Prendre les 5 premiers éléments de chaque RDD et les mettre

dans une liste
movies_first_5 = movies_rdd.take(5)
ratings_first_5 = ratings_rdd.take(5)
users_first_5 = users_rdd.take(5)

# Créer une liste contenant les listes des 5 premiers éléments de

chaque RDD
output_list = [movies_first_5, ratings_first_5, users_first_5]

# Convertir la liste en RDD

output_rdd = sc.parallelize(output_list)

# Écrire les 5 premiers éléments de chaque RDD dans le dossier de

sortie
output_rdd.saveAsTextFile("output/tp3/22061/exo2/Q1")

print ("le sauvegarde a ete fait avec succes ")

print('**************************')
print('**************************')
print('**************************')

print('*** The END ***')

Q2/ :

from pyspark import SparkContext

from pyspark.sql import SparkSession

# Créer le contexte Spark

sc = SparkContext("local", "Exercise2")

# Charger les fichiers dans les RDDs

movies_rdd = sc.textFile("movies.dat").map(lambda x:
x.split('::'))
ratings_rdd = sc.textFile("ratings.dat").map(lambda x:
x.split('::'))
users_rdd = sc.textFile("users.dat").map(lambda x: x.split('::'))

# Compter le nombre de lignes dans chaque RDD

movies_count = movies_rdd.count()
ratings_count = ratings_rdd.count()
users_count = users_rdd.count()

# Afficher le nombre de lignes pour chaque RDD

print("Nombre de lignes dans movies_rdd:", movies_count)
print("Nombre de lignes dans ratings_rdd:", ratings_count)
print("Nombre de lignes dans users_rdd:", users_count)
movies_count_str = str(movies_count)
ratings_count_str = str(ratings_count)
users_count_str = str(users_count)

# Créer un RDD contenant tous les comptages

counts_rdd = sc.parallelize([
("Nombre de lignes dans movies_rdd", movies_count_str),
("Nombre de lignes dans ratings_rdd", ratings_count_str),
("Nombre de lignes dans users_rdd", users_count_str)
])

counts_rdd.saveAsTextFile("output/tp3/22061/exo2/Q2")

print('**************************')
print('**************************')
print('**************************')

print('*** The END ***')

Q3 :

from pyspark import SparkContext

# Créer le contexte Spark

sc = SparkContext("local", "Exercise3_Q3")

print('*** The BEGINING ***')

print('**************************')
print('**************************')
print('**************************')

# Charger le fichier ratings.dat dans un RDD

ratings_rdd = sc.textFile("ratings.dat")

# Filtrer les lignes pour ne garder que celles avec la note '1'
et compter leur nombre
rating_1_count = ratings_rdd.filter(lambda line:
line.split("::")[2] == '1').count()

# Afficher le nombre de fois que la note '1' a été donnée

print("Le nombre de fois que la note '1' a été donnée :",
rating_1_count)
rating_1_count_rdd = sc.parallelize(["Nombre d'occurrences de
'Mantua'", rating_1_count])
rating_1_count_rdd.saveAsTextFile("output/tp3/22061/exo2/Q3")
print("le sauvegarde a ete fait avec succes")

print('**************************')
print('**************************')
print('**************************')

print('*** The END ***')

Q4/ :

from pyspark import SparkContext

# Créer le contexte Spark

sc = SparkContext("local", "Exercise2_Q4")

# Charger les fichiers dans les RDDs

ratings_rdd = sc.textFile("ratings.dat") \
.map(lambda line: line.split('::')[1]) \
.distinct()

# Compter le nombre de films uniques

unique_movies_count = ratings_rdd.count()

# Afficher le résultat
print("Nombre de films uniques évalués :", unique_movies_count)

unique_movies_count_rdd = sc.parallelize([("Nombre de lignes dans

movies_rdd", unique_movies_count)])

unique_movies_count_rdd.saveAsTextFile("output/tp3/22061/exo2/Q4"
)

print('**************************')
print('**************************')
print('**************************')

print('*** The END ***')

Q5/ :

from pyspark import SparkContext

# Créer le contexte Spark

sc = SparkContext("local", "Exercise2_Q5")

print('*** The BEGINING ***')

print('**************************')
print('**************************')
print('**************************')

# Charger les fichiers dans les RDDs

ratings_rdd = sc.textFile("ratings.dat") \
.map(lambda line: (line.split('::')[0], 1)) \
.reduceByKey(lambda a, b: a + b)

# Trouver l'utilisateur avec le plus grand nombre d'évaluations

max_user = ratings_rdd.max(lambda x: x[1])

# Afficher l'ID utilisateur et le nombre d'évaluations

print("Utilisateur avec le plus grand nombre d'évaluations :")
print("User ID:", max_user[0])
print("Nombre d'évaluations:", max_user[1])

results_rdd = sc.parallelize([
f"User ID: : {max_user[0]}",
f"Nombre d'évaluations: : {max_user[1]}"
])

results_rdd.saveAsTextFile("output/tp3/22061/exo2/Q5")

print('**************************')
print('**************************')
print('**************************')
 print('*** The END ***')

Q6/ :

from pyspark import SparkContext

# Créer le contexte Spark

sc = SparkContext("local", "Exercise2_Q6")

# Charger les fichiers dans les RDDs

ratings_rdd = sc.textFile("ratings.dat") \
.map(lambda line: (line.split('::')[0], 1 if
line.split('::')[2] == '5' else 0)) \
.reduceByKey(lambda a, b: a + b)

# Trouver l'utilisateur avec le plus grand nombre de notes "5"

max_user_5 = ratings_rdd.max(lambda x: x[1])

# Afficher l'ID utilisateur et le nombre de notes "5"

print("Utilisateur avec le plus grand nombre de notes '5' :")
print("User ID:", max_user_5[0])
print("Nombre de notes '5':", max_user_5[1])

results_rdd = sc.parallelize([
f"User ID: : {max_user_5[0]}",
f"Nombre de notes '5' : {max_user_5[1]}"
])
 results_rdd.saveAsTextFile("output/tp3/22061/exo2/Q6")

print('**************************')
print('**************************')
print('**************************')

print('*** The END ***')

Q7/ :

from pyspark import SparkContext

# Créer le contexte Spark

sc = SparkContext("local", "Exercise2_Q7")

print('*** The BEGINING ***')

print('**************************')
print('**************************')
print('**************************')

# Charger les fichiers dans les RDDs

ratings_rdd = sc.textFile("ratings.dat") \
.map(lambda line: (line.split('::')[1], 1)) \
.reduceByKey(lambda a, b: a + b)
# Trouver le film le plus souvent noté
max_movie = ratings_rdd.max(lambda x: x[1])

# Afficher le movieID et le nombre d'évaluations

print("Film le plus souvent noté :")
print("Movie ID:", max_movie[0])
print("Nombre d'évaluations:", max_movie[1])

results_rdd = sc.parallelize([
"Film le plus souvent noté :",
f"User ID: : {max_movie[0]}",
f"Nombre de notes '5' : {max_movie[1]}"
])

results_rdd.saveAsTextFile("output/tp3/22061/exo2/Q7")

print('**************************')
print('**************************')
print('**************************')

print('*** The END ***')

Q8:/

from pyspark import SparkContext

# Créer le contexte Spark

sc = SparkContext("local", "Exercise2_Q8")

print('*** The BEGINING ***')

print('**************************')
print('**************************')
print('**************************')

# Charger les fichiers dans les RDDs

movies_rdd = sc.textFile("movies.dat") \
.map(lambda line: (line.split('::')[0],
line.split('::')[2])) \
.filter(lambda movie: 'Comedy' in movie[1])

# Compter le nombre de films qui sont des comédies

comedy_movies_count = movies_rdd.count()

# Afficher le résultat
print("Nombre de films qui sont des comédies :",
comedy_movies_count)

results_rdd = sc.parallelize([
f"ombre de films qui sont des comédies : {comedy_movies_count}"
])

results_rdd.saveAsTextFile("output/tp3/22061/exo2/Q8")

print('**************************')
print('**************************')
print('**************************')

print('*** The END ***')

Q9/ :

from pyspark import SparkContext

# Créer le contexte Spark

sc = SparkContext("local", "Exercise2_Q9")

print('*** The BEGINING ***')

print('**************************')
print('**************************')
print('**************************')

# Charger les fichiers dans les RDDs

movies_rdd = sc.textFile("movies.dat") \
.map(lambda line: (line.split('::')[0],
line.split('::')[1]))

ratings_rdd = sc.textFile("ratings.dat") \
.map(lambda line: (line.split('::')[1], 1)) \
.reduceByKey(lambda a, b: a + b)

# Joindre les RDDs sur movieID

joined_rdd = movies_rdd.join(ratings_rdd)

# Filtrer les comédies et trouver celle avec le plus

d'évaluations
max_comedy = joined_rdd.filter(lambda x: 'Comedy' in x[1][0]) \
.max(lambda x: x[1][1])

# Afficher le titre de la comédie et le nombre d'évaluations

print("Comédie avec le plus d'évaluations :")
print("Titre:", max_comedy[1][0])
print("Nombre d'évaluations:", max_comedy[1][1])

results_rdd = sc.parallelize([
"Comédie avec le plus d'évaluations :",
f"Titre : {max_comedy[1][0]}",
f"Nombre d'évaluations : {max_comedy[1][1]}"
])

results_rdd.saveAsTextFile("output/tp3/22061/exo2/Q9")

print('**************************')
print('**************************')
print('**************************')

print('*** The END ***')

Exercice 3 :

Q1/ :

from pyspark import SparkContext

# Créer le contexte Spark

sc = SparkContext("local", "Exercise3_Q1")

print('*** The BEGINING ***')

print('**************************')
print('**************************')

# Charger le fichier dans un RDD

stations_rdd = sc.textFile("isd-history.txt")

# Filtrer les lignes contenant des en-têtes

header = stations_rdd.first()
stations_rdd = stations_rdd.filter(lambda line: line != header)

# Fonction pour déterminer l'hémisphère en fonction de la

latitude

def hemisphere(latitude):
latitude = latitude.strip('"') # Supprimer les guillemets
entourant la latitude
if latitude: # Vérifier si la latitude n'est pas vide après
suppression des guillemets
latitude = float(latitude) # Convertir en flottant
if latitude >= 0:
return "Northern Hemisphere"
else:
return "Southern Hemisphere"
else:
return "Invalid Latitude"
# Mapper chaque ligne à l'hémisphère correspondant
hemisphere_count_rdd = stations_rdd.map(lambda line:
(hemisphere(line.split(',')[6]), 1))

# Réduire pour compter le nombre de stations dans chaque

hémisphère
hemisphere_counts = hemisphere_count_rdd.reduceByKey(lambda a, b:
a + b).collect()

# Afficher les résultats

print("Nombre de stations dans l'hémisphère nord et dans
l'hémisphère sud :")
for hemisphere, count in hemisphere_counts:
print(hemisphere, ":", count)

# Sauvegarder les résultats

results_rdd = sc.parallelize([
 "Nombre de stations dans l'hémisphère nord et dans
l'hémisphère sud :"
])
for hemisphere, count in hemisphere_counts:
results_rdd =
results_rdd.union(sc.parallelize([f"{hemisphere}: {count}"]))

results_rdd.saveAsTextFile("output/tp3/22061/exo3/Q1")

print('**************************')
print('**************************')
print('**************************')

print('*** The END ***')

Q2/ :

from pyspark import SparkContext

# Créer le contexte Spark

sc = SparkContext("local", "Exercise3_Q2")

print('*** The BEGINING ***')

print('**************************')
print('**************************')
print('**************************')

# Charger le fichier dans un RDD

stations_rdd = sc.textFile("isd-history.txt")

# Filtrer les lignes contenant des valeurs non numériques pour

les années
def is_valid_year(year):
return year.isdigit()

# Filtrer les lignes contenant des années valides

filtered_rdd = stations_rdd.filter(lambda line:
is_valid_year(line.split(',')[9]) and
is_valid_year(line.split(',')[10]))

# Vérifier si l'RDD filtré est vide

if filtered_rdd.isEmpty():
print("Aucune donnée valide trouvée dans le RDD.")
else:
station_with_max_years_diff = filtered_rdd.map(lambda line:
(line.split(',')[0], (int(line.split(',')[9]),
int(line.split(',')[10])))) \
.map(lambda x:
(x[0], abs(x[1][1] - x[1][0]))) \
.max(lambda x:
x[1])

# Afficher les résultats

print("Station avec le plus grand écart d'années :")
print("Identifiant de la station :",
station_with_max_years_diff[0].strip())
print("Nom de la station :",
station_with_max_years_diff[0].strip())

results_rdd = sc.parallelize([
"Station avec le plus grand écart d'années :",
f"Identifiant de la station :
{station_with_max_years_diff[0].strip()}",
f"Nom de la station :
{station_with_max_years_diff[0].strip()}"
])

results_rdd.saveAsTextFile("output/tp3/22061/exo3/Q2")

print('**************************')
print('**************************')
print('**************************')

print('*** The END ***')

Q3/ :

from pyspark import SparkContext

# Créer le contexte Spark

sc = SparkContext("local", "Exercise3_Q3")

# Charger le fichier dans un RDD

stations_rdd = sc.textFile("isd-history.txt")

# Filtrer les lignes contenant des en-têtes

header = stations_rdd.first()
stations_rdd = stations_rdd.filter(lambda line: line != header)

# Mapper chaque ligne pour extraire le pays

stations_by_country = stations_rdd.map(lambda line:
(line.split(',')[3], 1))

# Réduire pour compter le nombre de stations par pays

stations_count_by_country =
stations_by_country.reduceByKey(lambda x, y: x + y)

# Trouver le pays avec le plus grand nombre de stations

country_with_most_stations = stations_count_by_country.max(lambda
x: x[1])

# Afficher le résultat
print("Le pays avec le plus de stations est :",
country_with_most_stations[0])
print("Nombre de stations :", country_with_most_stations[1])
# Sauvegarder les résultats
results_rdd = sc.parallelize([
f"Le pays avec le plus de stations est :
{country_with_most_stations[0]}",
f"Nombre de stations : {country_with_most_stations[1]}"
])

results_rdd.saveAsTextFile("output/tp3/22061/exo3/Q3")

print('**************************')
print('**************************')
print('**************************')

print('*** The END ***')

Q4/ :

from pyspark import SparkContext

# Créer le contexte Spark

sc = SparkContext("local", "Exercise3_Q4")

# Charger le fichier dans un RDD

stations_rdd = sc.textFile("isd-history.txt")
# Filtrer les lignes contenant des en-têtes
header = stations_rdd.first()
stations_rdd = stations_rdd.filter(lambda line: line != header)

# Mapper chaque ligne pour extraire le pays

countries_rdd = stations_rdd.map(lambda line: line.split(',')[3])

# Supprimer les doublons pour obtenir une liste unique de pays

unique_countries_rdd = countries_rdd.distinct()

# Compter le nombre de pays

num_countries_with_stations = unique_countries_rdd.count()

# Afficher le résultat
print("Le nombre de pays possédant des stations météo est :",
num_countries_with_stations)

# Sauvegarder les résultats

results_rdd = sc.parallelize([
f"Le nombre de pays possédant des stations météo est :
{num_countries_with_stations}"
])

results_rdd.saveAsTextFile("output/tp3/22061/exo3/Q4")

print('**************************')
print('**************************')
print('**************************')

print('*** The END ***')

Q5/ :

from pyspark import SparkContext

# Créer le contexte Spark

sc = SparkContext("local", "Exercise3_Q5")

print('*** The BEGINING ***')

print('**************************')
print('**************************')
print('**************************')

# Charger le fichier dans un RDD

stations_rdd = sc.textFile("isd-history.txt")

# Filtrer les lignes contenant des en-têtes

header = stations_rdd.first()
stations_rdd = stations_rdd.filter(lambda line: line != header)

# Filtrer les lignes correspondant à la Mauritanie

stations_in_mauritania_rdd = stations_rdd.filter(lambda line:
line.split(',')[3] == "Mauritania")

# Compter le nombre de stations en Mauritanie

num_stations_in_mauritania = stations_in_mauritania_rdd.count()

# Afficher le résultat
print("Le nombre de stations météo en Mauritanie est :",
num_stations_in_mauritania)

# Sauvegarder les résultats

results_rdd = sc.parallelize([
f"Le nombre de stations météo en Mauritanie est :
{num_stations_in_mauritania}"
])

results_rdd.saveAsTextFile("output/tp3/22061/exo3/Q5")

print('**************************')
print('**************************')
print('**************************')

print('*** The END ***')