ajout exercices, corrections diverses, glossaire

- Ajout des 10 TPs d'évaluation (sans PDF)
- Création GLOSSAIRE.md et AMELIORATIONS.md
- Corrections f-strings, eval(), sommaires

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

representation_construits/evaluation/TP04_Netflix_aide.md

@@ -0,0 +1,232 @@
+# Aide - TP04 Netflix
+
+## Rappels utiles
+
+### Differencier films et series
+```python
+contenu = catalogue[0]
+
+if contenu["type"] == "serie":
+    print(contenu["saisons"], "saisons")
+else:
+    print("Duree:", contenu["duree"], "min")
+```
+
+### Verifier si un element est dans une liste
+```python
+genres = ["SF", "Action"]
+if "SF" in genres:
+    print("C'est de la science-fiction")
+```
+
+### Joindre une liste en chaine
+```python
+genres = ["SF", "Action", "Thriller"]
+genres_str = ", ".join(genres)  # "SF, Action, Thriller"
+```
+
+---
+
+## Exercice 1
+
+### 1.1 - Affichage formate
+- Films : affichez la duree en heures:minutes (`duree // 60` et `duree % 60`)
+- Series : affichez le nombre de saisons et la duree moyenne par episode
+- Genres : `", ".join(contenu["genre"])` pour les separer par des virgules
+
+```python
+def afficher_contenu(contenu):
+    print(contenu["titre"], "(", contenu["annee"], ")")
+    print("Genres:", ", ".join(contenu["genre"]))
+
+    if contenu["type"] == "film":
+        heures = contenu["duree"] // 60
+        minutes = contenu["duree"] % 60
+        print("Duree:", heures, "h", minutes, "min")
+    else:
+        print("Saisons:", contenu["saisons"])
+```
+
+### 1.2 - Statistiques
+```python
+nb_films = 0
+nb_series = 0
+for c in catalogue:
+    if c["type"] == "film":
+        nb_films = nb_films + 1
+    else:
+        nb_series = nb_series + 1
+```
+
+Pour les genres uniques :
+```python
+tous_genres = []
+for c in catalogue:
+    for g in c["genre"]:
+        if g not in tous_genres:
+            tous_genres.append(g)
+genres_tries = sorted(tous_genres)
+```
+
+### 1.3 - Recherche par criteres
+```python
+def rechercher(catalogue, type_contenu, genre, note_min):
+    resultats = []
+
+    for c in catalogue:
+        # Verifier chaque critere
+        if type_contenu is not None and c["type"] != type_contenu:
+            continue
+        if genre is not None and genre not in c["genre"]:
+            continue
+        if note_min is not None and c["note"] < note_min:
+            continue
+
+        resultats.append(c)
+
+    return resultats
+```
+
+---
+
+## Exercice 2
+
+### 2.1 - Temps de visionnage
+```python
+def temps_visionne(hist, cat):
+    total_minutes = 0
+
+    for h in hist:
+        # Trouver le contenu dans le catalogue
+        contenu = None
+        for c in cat:
+            if c["titre"] == h["titre"]:
+                contenu = c
+                break
+
+        if contenu == None:
+            continue
+
+        if contenu["type"] == "serie":
+            total_minutes = total_minutes + h["episodes_vus"] * contenu["duree_moy"]
+        else:
+            total_minutes = total_minutes + contenu["duree"]
+
+    heures = total_minutes // 60
+    minutes = total_minutes % 60
+    return total_minutes, str(heures) + "h" + str(minutes)
+```
+
+### 2.2 - Profil preferences
+- Comptez les genres ponderes par les notes utilisateur
+- Utilisez un dictionnaire `{genre: score_total}`
+- Triez par score decroissant
+
+```python
+scores_genres = {}
+for h in historique:
+    # Trouver le contenu
+    for c in catalogue:
+        if c["titre"] == h["titre"]:
+            for genre in c["genre"]:
+                if genre not in scores_genres:
+                    scores_genres[genre] = 0
+                scores_genres[genre] = scores_genres[genre] + h["note"]
+            break
+```
+
+### 2.3 - Gestion watchlist
+```python
+def trier_watchlist(wl, cat, critere):
+    # Creer une liste avec les infos completes
+    avec_infos = []
+    for titre in wl:
+        for c in cat:
+            if c["titre"] == titre:
+                avec_infos.append(c)
+                break
+
+    # Trier selon le critere
+    if critere == "note":
+        avec_infos = sorted(avec_infos, key=lambda x: x["note"], reverse=True)
+    elif critere == "annee":
+        avec_infos = sorted(avec_infos, key=lambda x: x["annee"], reverse=True)
+
+    # Renvoyer juste les titres
+    titres = []
+    for c in avec_infos:
+        titres.append(c["titre"])
+    return titres
+```
+
+---
+
+## Exercice 3 (Bonus)
+
+### 3.1 - Recommandations similaires
+```python
+def similarite(c1, c2):
+    score = 0
+    # Genres en commun
+    for g in c1["genre"]:
+        if g in c2["genre"]:
+            score = score + 2
+    # Meme type
+    if c1["type"] == c2["type"]:
+        score = score + 1
+    # Meme decennie
+    if c1["annee"] // 10 == c2["annee"] // 10:
+        score = score + 1
+    return score
+```
+
+### 3.2 - Recommandations personnalisees
+1. Calculez le profil utilisateur (genres preferes, note moyenne)
+2. Pour chaque contenu non vu, calculez un score
+3. Triez par score decroissant
+
+### 3.3 - Soiree cinema
+C'est un probleme d'optimisation (type "sac a dos") :
+```python
+def soiree_cinema(cat, duree_max, genres_voulus):
+    # Filtrer les contenus valides
+    valides = []
+    for c in cat:
+        for g in c["genre"]:
+            if g in genres_voulus:
+                valides.append(c)
+                break
+
+    # Trier par note decroissante
+    valides = sorted(valides, key=lambda x: x["note"], reverse=True)
+
+    selection = []
+    duree_totale = 0
+    a_serie = False
+
+    for c in valides:
+        if c["type"] == "film":
+            duree_c = c["duree"]
+        else:
+            duree_c = c["duree_moy"] * 3
+
+        if c["type"] == "serie" and a_serie:
+            continue  # Deja une serie
+
+        if duree_totale + duree_c <= duree_max:
+            selection.append(c)
+            duree_totale = duree_totale + duree_c
+            if c["type"] == "serie":
+                a_serie = True
+
+    return selection, duree_totale
+```
+
+---
+
+## Pieges a eviter
+
+1. **Films vs series** : les films ont `duree`, les series ont `duree_moy` et `saisons`
+2. **Genre est une liste** : utilisez `in` pour verifier si un genre est present
+3. **Contenu non trouve** : verifiez que le titre existe avant d'acceder a ses proprietes
+4. **Tri stable** : si deux elements ont le meme score, leur ordre relatif est conserve