Analyse d'un réseau social - Gestion des publications et hashtags
On modélise un petit réseau social. Chaque utilisateur est associé à la liste de ses publications :
reseau = {
"Amina": [
("p1", ["python", "ia"], 15),
("p2", ["math"], 8)
],
"Youssef": [
("p3", ["python", "reseaux"], 12)
],
"Sara": [
("p4", ["ia"], 20),
("p5", ["python", "math"], 5)
],
"Hamza": []
}
Chaque tuple représente une publication :
(id, liste_hashtags, nombre_likes)
Écrire une fonction hashtags_utilisateur(reseau, nom) qui retourne l'ensemble des hashtags utilisés par nom.
def hashtags_utilisateur(reseau, nom):
if nom not in reseau:
return set()
hashtags = set()
for pid, tags, likes in reseau[nom]:
for tag in tags:
hashtags.add(tag)
return hashtags
Écrire une fonction likes_total(reseau, nom) qui retourne le nombre total de likes obtenus par nom.
def likes_total(reseau, nom):
if nom not in reseau:
return 0
total = 0
for pid, tags, likes in reseau[nom]:
total += likes
return total
Écrire une fonction publication_max(reseau, nom) qui retourne l'identifiant de la publication ayant le plus de likes pour nom. (Si aucune publication → retourner None)
def publication_max(reseau, nom):
if nom not in reseau or not reseau[nom]:
return None
max_likes = -1
max_id = None
for pid, tags, likes in reseau[nom]:
if likes > max_likes:
max_likes = likes
max_id = pid
return max_id
Écrire tous_hashtags(reseau) qui retourne l'ensemble de tous les hashtags utilisés sur le réseau.
def tous_hashtags(reseau):
tous = set()
for utilisateur, publications in reseau.items():
for pid, tags, likes in publications:
for tag in tags:
tous.add(tag)
return tous
Écrire utilisateurs_par_hashtag(reseau, tag) qui retourne la liste triée des utilisateurs ayant utilisé le hashtag tag.
def utilisateurs_par_hashtag(reseau, tag):
utilisateurs = []
for nom, publications in reseau.items():
for pid, tags, likes in publications:
if tag in tags:
utilisateurs.append(nom)
break # Un utilisateur n'est ajouté qu'une fois
utilisateurs.sort()
return utilisateurs
Écrire hashtags_communs(reseau, u1, u2) qui retourne l'ensemble des hashtags communs à deux utilisateurs.
def hashtags_communs(reseau, u1, u2):
if u1 not in reseau or u2 not in reseau:
return set()
return hashtags_utilisateur(reseau, u1) & hashtags_utilisateur(reseau, u2)
Écrire utilisateur_plus_actif(reseau) qui retourne l'utilisateur ayant publié le plus de posts (égalité → plus petit nom lexicographiquement).
def utilisateur_plus_actif(reseau):
max_posts = -1
plus_actif = None
for nom, publications in reseau.items():
nb_posts = len(publications)
if nb_posts > max_posts:
max_posts = nb_posts
plus_actif = nom
elif nb_posts == max_posts:
if plus_actif is None or nom < plus_actif:
plus_actif = nom
return plus_actif
Écrire meilleur_influenceur(reseau) qui retourne l'utilisateur ayant le plus grand total de likes.
def meilleur_influenceur(reseau):
max_likes = -1
meilleur = None
for nom, publications in reseau.items():
total = likes_total(reseau, nom)
if total > max_likes:
max_likes = total
meilleur = nom
elif total == max_likes:
if meilleur is None or nom < meilleur:
meilleur = nom
return meilleur
Écrire dictionnaire_likes(reseau) qui retourne un dictionnaire associant à chaque utilisateur son total de likes.
def dictionnaire_likes(reseau):
dico = {}
for nom, publications in reseau.items():
total = likes_total(reseau, nom)
dico[nom] = total
return dico
Écrire index_hashtags(reseau) qui construit un dictionnaire associant à chaque hashtag l'ensemble des utilisateurs qui l'ont utilisé.
def index_hashtags(reseau):
index = {}
for nom, publications in reseau.items():
for pid, tags, likes in publications:
for tag in tags:
if tag not in index:
index[tag] = set()
index[tag].add(nom)
return index
Écrire filtrer_populaires(reseau, seuil) qui retourne un nouveau dictionnaire ne contenant que les publications ayant au moins seuil likes.
def filtrer_populaires(reseau, seuil):
nouveau = {}
for nom, publications in reseau.items():
pop = []
for pid, tags, likes in publications:
if likes >= seuil:
pop.append((pid, tags, likes))
if pop: # On garde l'utilisateur seulement s'il a des publications populaires
nouveau[nom] = pop
return nouveau
Écrire suggestions(reseau, nom) qui retourne l'ensemble des hashtags utilisés par les autres utilisateurs mais jamais utilisés par nom.
def suggestions(reseau, nom):
if nom not in reseau:
return set()
# Hashtags utilisés par l'utilisateur
mes_tags = hashtags_utilisateur(reseau, nom)
# Hashtags utilisés par les autres utilisateurs
autres_tags = set()
for user, publications in reseau.items():
if user != nom:
autres_tags.update(hashtags_utilisateur(reseau, user))
# Hashtags que l'utilisateur n'a jamais utilisés
return autres_tags - mes_tags
Discussion (0)
Soyez le premier à laisser un commentaire !
Laisser un commentaire
Votre commentaire sera visible après modération.