22061

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 :

import re

print('#################')
print('**************************')
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('**************************')
Q3/ :

import re

print('#################')
print('**************************')
# Charger le fichier texte dans un RDD

# 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('**************************')

Q4/ :

import re

print('#################')
print('**************************')
# 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('**************************')

Q5 :

# Initialiser la session Spark

# Obtenir le contexte Spark

print('#################')
print('Affichage des 10 premiers éléments avec numéro de ligne')
# Charger le fichier texte dans un RDD

# 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('**************************')
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('**************************')

Q2/ :


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

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('**************************')

Q3 :

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('**************************')

Q4/ :


.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('**************************')

Q5/ :


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

.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('**************************')
Q6/ :


.map(lambda line: (line.split('::')[0], 1 if
line.split('::')[2] == '5' else 0)) \
# 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])
f"User ID: : {max_user_5[0]}",
f"Nombre de notes '5' : {max_user_5[1]}"
])
print('**************************')
print('**************************')
print('**************************')
Q7/ :


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

# 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])
"Film le plus souvent noté :",
f"User ID: : {max_movie[0]}",
f"Nombre de notes '5' : {max_movie[1]}"
])
print('**************************')
print('**************************')
print('**************************')

Q8:/


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

.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()
print("Nombre de films qui sont des comédies :",
comedy_movies_count)
f"ombre de films qui sont des comédies : {comedy_movies_count}"
])
print('**************************')
print('**************************')
print('**************************')

Q9/ :


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

.map(lambda line: (line.split('::')[0],
line.split('::')[1]))
# 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])
"Comédie avec le plus d'évaluations :",
f"Titre : {max_comedy[1][0]}",
f"Nombre d'évaluations : {max_comedy[1][1]}"
])
print('**************************')
print('**************************')
print('**************************')

Exercice 3 :
Q1/ :


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

"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}"]))
print('**************************')
print('**************************')
print('**************************')
Q2/ :


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

# 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())
"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()}"
])
print('**************************')
print('**************************')
print('**************************')

Q3/ :



# 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])
print("Le pays avec le plus de stations est :",
country_with_most_stations[0])
print("Nombre de stations :", country_with_most_stations[1])
f"Le pays avec le plus de stations est :
{country_with_most_stations[0]}",
f"Nombre de stations : {country_with_most_stations[1]}"
])
print('**************************')
print('**************************')
print('**************************')
Q4/ :


# 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()
print("Le nombre de pays possédant des stations météo est :",
num_countries_with_stations)

f"Le nombre de pays possédant des stations météo est :
{num_countries_with_stations}"
])
print('**************************')
print('**************************')
print('**************************')

Q5/ :


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


# 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()
print("Le nombre de stations météo en Mauritanie est :",
num_stations_in_mauritania)

f"Le nombre de stations météo en Mauritanie est :
{num_stations_in_mauritania}"
])
print('**************************')
print('**************************')
print('**************************')

22061

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

22061

Transféré par

Droits d'auteur :

Formats disponibles

Compte Rendu du TP3 :

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

from pyspark import *

spark = SparkSession.builder.appName('22061 Spark

# Sauvegarder le nombre de lignes

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

from pyspark import *

spark = SparkSession.builder.appName('22061 Spark

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

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

from pyspark import *

spark = SparkSession.builder.appName('22061 Spark

# Charger le fichier texte dans un RDD

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

# Compter le nombre de répliques de Romeo

# Afficher le nombre de répliques de Romeo

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

from pyspark import *

spark = SparkSession.builder.appName('22061 Spark

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

# Afficher le nombre d'occurrences de "Mantua"

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

# Enregistrer le résultat dans un fichier texte

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

from pyspark import *

# Initialiser la session Spark

# Obtenir le contexte Spark

# Charger le fichier texte dans un RDD

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

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

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

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

from pyspark import SparkContext

# Créer le contexte Spark

print ("debut du programme ")

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

# Charger les fichiers dans les RDDs

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

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

# Convertir la liste en RDD

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

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

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

from pyspark import SparkContext

# Créer le contexte Spark

# Charger les fichiers dans les RDDs

# Compter le nombre de lignes dans chaque RDD

# Afficher le nombre de lignes pour chaque RDD

# Créer un RDD contenant tous les comptages

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

from pyspark import SparkContext

# Créer le contexte Spark

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

# Charger le fichier ratings.dat dans un RDD

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

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

from pyspark import SparkContext

# Créer le contexte Spark

# Charger les fichiers dans les RDDs

# Compter le nombre de films uniques

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

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

from pyspark import SparkContext

# Créer le contexte Spark

print('* The END *')

print('* The END *')

print('* The END *')

print('* The END *')

print('* The END *')

print('* The END *')

print('* The END *')

print('* The BEGINING *')

print('* The END *')

print('* The END *')

print('* The BEGINING *')

print('* The END *')

print('* The BEGINING *')

print('* The END *')

print('* The BEGINING *')

print('* The END *')

print('* The BEGINING *')

print('* The END *')

print('* The BEGINING *')

print('* The END *')

print('* The BEGINING *')

print('* The END *')

print('* The END *')

print('* The END *')

print('* The BEGINING *')