1ereNSI/representation_construits/evaluation/TP04_Netflix_aide.md

# 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