Florian/1ereNSI
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
09bf5d071f53686cbfa8784c37229b71bb158a06
1ereNSI/representation_construits/evaluation/TP01_Spotify.ipynb
Florian Mathieu 1290ccf453 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>
2026-01-29 23:37:26 +01:00

477 lines
15 KiB
Plaintext
Raw Blame History

{
"cells": [
{
"cell_type": "markdown",
"id": "cell-0",
"metadata": {},
"source": [
"# TP Évaluation - Gestion de Playlists Spotify\n",
"\n",
"**Durée : 1h30**\n",
"\n",
"**Nom :** \n",
"\n",
"**Prénom :**\n",
"\n",
"---\n",
"\n",
"Dans ce TP, vous allez manipuler des structures de données Python pour gérer des playlists musicales.\n",
"\n",
"**Compétences évaluées :**\n",
"- Manipulation de listes et dictionnaires\n",
"- Parcours et filtrage de données\n",
"- Écriture de fonctions"
]
},
{
"cell_type": "markdown",
"id": "cell-1",
"metadata": {},
"source": [
"## Données initiales\n",
"\n",
"Voici les données avec lesquelles vous allez travailler. **Exécutez cette cellule avant de commencer.**"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-2",
"metadata": {},
"outputs": [],
"source": [
"# Base de données de chansons\n",
"# Chaque chanson est un dictionnaire avec : titre, artiste, duree (en secondes), annee, streams\n",
"catalogue = [\n",
" {\"titre\": \"Blinding Lights\", \"artiste\": \"The Weeknd\", \"duree\": 203, \"annee\": 2020, \"streams\": 3500000000},\n",
" {\"titre\": \"Shape of You\", \"artiste\": \"Ed Sheeran\", \"duree\": 234, \"annee\": 2017, \"streams\": 3400000000},\n",
" {\"titre\": \"Dance Monkey\", \"artiste\": \"Tones and I\", \"duree\": 210, \"annee\": 2019, \"streams\": 2800000000},\n",
" {\"titre\": \"Rockstar\", \"artiste\": \"Post Malone\", \"duree\": 218, \"annee\": 2017, \"streams\": 2700000000},\n",
" {\"titre\": \"One Dance\", \"artiste\": \"Drake\", \"duree\": 173, \"annee\": 2016, \"streams\": 2600000000},\n",
" {\"titre\": \"Sunflower\", \"artiste\": \"Post Malone\", \"duree\": 158, \"annee\": 2018, \"streams\": 2500000000},\n",
" {\"titre\": \"Closer\", \"artiste\": \"The Chainsmokers\", \"duree\": 244, \"annee\": 2016, \"streams\": 2400000000},\n",
" {\"titre\": \"Starboy\", \"artiste\": \"The Weeknd\", \"duree\": 230, \"annee\": 2016, \"streams\": 2300000000},\n",
" {\"titre\": \"Perfect\", \"artiste\": \"Ed Sheeran\", \"duree\": 263, \"annee\": 2017, \"streams\": 2200000000},\n",
" {\"titre\": \"Heat Waves\", \"artiste\": \"Glass Animals\", \"duree\": 239, \"annee\": 2020, \"streams\": 2100000000},\n",
" {\"titre\": \"Bad Guy\", \"artiste\": \"Billie Eilish\", \"duree\": 194, \"annee\": 2019, \"streams\": 2000000000},\n",
" {\"titre\": \"Levitating\", \"artiste\": \"Dua Lipa\", \"duree\": 203, \"annee\": 2020, \"streams\": 1900000000},\n",
" {\"titre\": \"Save Your Tears\", \"artiste\": \"The Weeknd\", \"duree\": 216, \"annee\": 2020, \"streams\": 1800000000},\n",
" {\"titre\": \"Thinking Out Loud\", \"artiste\": \"Ed Sheeran\", \"duree\": 281, \"annee\": 2014, \"streams\": 1700000000},\n",
" {\"titre\": \"Stay\", \"artiste\": \"The Kid LAROI\", \"duree\": 141, \"annee\": 2021, \"streams\": 1600000000}\n",
"]\n",
"\n",
"# Playlist de l'utilisateur (initialement vide)\n",
"ma_playlist = []"
]
},
{
"cell_type": "markdown",
"id": "cell-3",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 1 - Exploration du catalogue (25 min)\n",
"\n",
"### 1.1 Affichage formaté (4 pts)\n",
"\n",
"Écrivez une fonction `afficher_chanson(chanson)` qui prend un dictionnaire représentant une chanson et affiche ses informations.\n",
"\n",
"Exemple de sortie attendue :\n",
"```\n",
"Blinding Lights - The Weeknd (2020) | 3:23\n",
"```\n",
"\n",
"*Aide : la durée est en secondes. Pour convertir : minutes = duree // 60, secondes = duree % 60*"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-4",
"metadata": {},
"outputs": [],
"source": [
"def afficher_chanson(chanson):\n",
" # Récupérer les informations\n",
" titre = chanson[\"titre\"]\n",
" artiste = chanson[\"artiste\"]\n",
" annee = chanson[\"annee\"]\n",
" duree = chanson[\"duree\"]\n",
" \n",
" # Convertir la durée en minutes:secondes\n",
" minutes = duree // 60\n",
" secondes = duree % 60\n",
" \n",
" # Afficher (compléter le print)\n",
" # Votre code ici\n",
" pass\n",
"\n",
"# Test\n",
"afficher_chanson(catalogue[0])"
]
},
{
"cell_type": "markdown",
"id": "cell-5",
"metadata": {},
"source": [
"### 1.2 Statistiques de base (4 pts)\n",
"\n",
"Écrivez une fonction `statistiques_catalogue(liste_chansons)` qui renvoie un dictionnaire contenant :\n",
"- `\"nombre\"` : le nombre total de chansons\n",
"- `\"duree_totale\"` : la durée totale en secondes\n",
"- `\"streams_total\"` : le nombre total de streams"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-6",
"metadata": {},
"outputs": [],
"source": [
"def statistiques_catalogue(liste_chansons):\n",
" nombre = 0\n",
" duree_totale = 0\n",
" streams_total = 0\n",
" \n",
" for chanson in liste_chansons:\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return {\n",
" \"nombre\": nombre,\n",
" \"duree_totale\": duree_totale,\n",
" \"streams_total\": streams_total\n",
" }\n",
"\n",
"# Test\n",
"stats = statistiques_catalogue(catalogue)\n",
"print(\"Nombre de chansons :\", stats[\"nombre\"])\n",
"print(\"Duree totale :\", stats[\"duree_totale\"], \"secondes\")\n",
"print(\"Streams total :\", stats[\"streams_total\"])"
]
},
{
"cell_type": "markdown",
"id": "cell-7",
"metadata": {},
"source": [
"### 1.3 Liste des artistes (4 pts)\n",
"\n",
"Écrivez une fonction `artistes_uniques(liste_chansons)` qui renvoie la **liste sans doublons** de tous les artistes présents dans le catalogue, triée par ordre alphabétique.\n",
"\n",
"*Aide : vous pouvez utiliser `liste.sort()` pour trier une liste, et vérifier si un élément est déjà dans la liste avec `if element not in liste`*"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-8",
"metadata": {},
"outputs": [],
"source": [
"def artistes_uniques(liste_chansons):\n",
" artistes = []\n",
" \n",
" for chanson in liste_chansons:\n",
" artiste = chanson[\"artiste\"]\n",
" # Ajouter l'artiste s'il n'est pas déjà dans la liste\n",
" # Votre code ici\n",
" pass\n",
" \n",
" # Trier la liste\n",
" artistes.sort()\n",
" return artistes\n",
"\n",
"# Test\n",
"print(\"Artistes :\", artistes_uniques(catalogue))"
]
},
{
"cell_type": "markdown",
"id": "cell-9",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 2 - Gestion de playlist (35 min)\n",
"\n",
"### 2.1 Recherche de chansons (5 pts)\n",
"\n",
"Écrivez une fonction `rechercher_par_artiste(liste_chansons, artiste)` qui renvoie la liste des chansons d'un artiste donné."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-10",
"metadata": {},
"outputs": [],
"source": [
"def rechercher_par_artiste(liste_chansons, artiste):\n",
" resultats = []\n",
" \n",
" for chanson in liste_chansons:\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return resultats\n",
"\n",
"# Test\n",
"print(\"Chansons de The Weeknd :\")\n",
"for c in rechercher_par_artiste(catalogue, \"The Weeknd\"):\n",
" afficher_chanson(c)"
]
},
{
"cell_type": "markdown",
"id": "cell-11",
"metadata": {},
"source": [
"### 2.2 Recherche par année (5 pts)\n",
"\n",
"Écrivez une fonction `rechercher_par_annee(liste_chansons, annee)` qui renvoie la liste des chansons d'une année donnée."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-12",
"metadata": {},
"outputs": [],
"source": [
"def rechercher_par_annee(liste_chansons, annee):\n",
" resultats = []\n",
" \n",
" for chanson in liste_chansons:\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return resultats\n",
"\n",
"# Test\n",
"print(\"Chansons de 2020 :\")\n",
"for c in rechercher_par_annee(catalogue, 2020):\n",
" afficher_chanson(c)"
]
},
{
"cell_type": "markdown",
"id": "cell-13",
"metadata": {},
"source": [
"### 2.3 Ajouter et retirer des chansons (6 pts)\n",
"\n",
"Écrivez deux fonctions :\n",
"\n",
"1. `ajouter_a_playlist(playlist, chanson)` : ajoute une chanson à la playlist **si elle n'y est pas déjà** (vérification par le titre). Renvoie `True` si l'ajout a réussi, `False` sinon.\n",
"\n",
"2. `retirer_de_playlist(playlist, titre)` : retire la chanson ayant ce titre de la playlist. Renvoie `True` si la suppression a réussi, `False` si la chanson n'était pas dans la playlist."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-14",
"metadata": {},
"outputs": [],
"source": [
"def ajouter_a_playlist(playlist, chanson):\n",
" # Vérifier si la chanson est déjà dans la playlist\n",
" for c in playlist:\n",
" if c[\"titre\"] == chanson[\"titre\"]:\n",
" return False\n",
" \n",
" # Si on arrive ici, la chanson n'est pas dans la playlist\n",
" # Votre code ici\n",
" pass\n",
"\n",
"def retirer_de_playlist(playlist, titre):\n",
" # Chercher la chanson avec ce titre\n",
" for i in range(len(playlist)):\n",
" if playlist[i][\"titre\"] == titre:\n",
" # Votre code ici (utiliser del ou pop)\n",
" pass\n",
" \n",
" return False\n",
"\n",
"# Tests\n",
"ma_playlist = []\n",
"print(ajouter_a_playlist(ma_playlist, catalogue[0])) # True\n",
"print(ajouter_a_playlist(ma_playlist, catalogue[0])) # False (deja present)\n",
"print(ajouter_a_playlist(ma_playlist, catalogue[1])) # True\n",
"print(\"Playlist :\", len(ma_playlist), \"chansons\")\n",
"print(retirer_de_playlist(ma_playlist, \"Blinding Lights\")) # True\n",
"print(retirer_de_playlist(ma_playlist, \"Blinding Lights\")) # False\n",
"print(\"Playlist :\", len(ma_playlist), \"chansons\")"
]
},
{
"cell_type": "markdown",
"id": "cell-15",
"metadata": {},
"source": [
"### 2.4 Top artistes (6 pts)\n",
"\n",
"Écrivez une fonction `compter_streams_par_artiste(liste_chansons)` qui renvoie un **dictionnaire** où les clés sont les noms d'artistes et les valeurs sont leur nombre total de streams.\n",
"\n",
"*Aide : utilisez `dico.get(cle, 0)` pour récupérer une valeur avec une valeur par défaut de 0 si la clé n'existe pas*"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-16",
"metadata": {},
"outputs": [],
"source": [
"def compter_streams_par_artiste(liste_chansons):\n",
" streams_par_artiste = {}\n",
" \n",
" for chanson in liste_chansons:\n",
" artiste = chanson[\"artiste\"]\n",
" streams = chanson[\"streams\"]\n",
" \n",
" # Ajouter les streams au total de l'artiste\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return streams_par_artiste\n",
"\n",
"# Test\n",
"streams = compter_streams_par_artiste(catalogue)\n",
"print(\"Streams par artiste :\")\n",
"for artiste, total in streams.items():\n",
" print(\" \", artiste, \":\", total)"
]
},
{
"cell_type": "markdown",
"id": "cell-17",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 3 - Bonus (20 min)\n",
"\n",
"### 3.1 Chanson la plus populaire (4 pts)\n",
"\n",
"Écrivez une fonction `chanson_plus_populaire(liste_chansons)` qui renvoie la chanson (dictionnaire) ayant le plus de streams."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-18",
"metadata": {},
"outputs": [],
"source": [
"def chanson_plus_populaire(liste_chansons):\n",
" if len(liste_chansons) == 0:\n",
" return None\n",
" \n",
" meilleure = liste_chansons[0]\n",
" \n",
" for chanson in liste_chansons:\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return meilleure\n",
"\n",
"# Test\n",
"top = chanson_plus_populaire(catalogue)\n",
"print(\"Chanson la plus populaire :\")\n",
"afficher_chanson(top)"
]
},
{
"cell_type": "markdown",
"id": "cell-19",
"metadata": {},
"source": [
"### 3.2 Trier par streams (4 pts)\n",
"\n",
"Écrivez une fonction `trier_par_streams(liste_chansons)` qui renvoie une **nouvelle liste** des chansons triées par nombre de streams décroissant.\n",
"\n",
"*Aide : utilisez `sorted(liste, key=..., reverse=True)`. La clé peut être une fonction lambda : `lambda c: c[\"streams\"]`*"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-20",
"metadata": {},
"outputs": [],
"source": [
"def trier_par_streams(liste_chansons):\n",
" # Votre code ici\n",
" pass\n",
"\n",
"# Test\n",
"print(\"Top 5 des chansons :\")\n",
"top5 = trier_par_streams(catalogue)[:5]\n",
"for c in top5:\n",
" afficher_chanson(c)"
]
},
{
"cell_type": "markdown",
"id": "cell-21",
"metadata": {},
"source": [
"### 3.3 Créer une playlist automatique (6 pts)\n",
"\n",
"Écrivez une fonction `creer_playlist_auto(liste_chansons, duree_max)` qui crée une playlist en ajoutant les chansons les plus populaires tant que la durée totale ne dépasse pas `duree_max` (en secondes).\n",
"\n",
"Renvoie la playlist créée."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-22",
"metadata": {},
"outputs": [],
"source": [
"def creer_playlist_auto(liste_chansons, duree_max):\n",
" # Trier par streams décroissant\n",
" chansons_triees = trier_par_streams(liste_chansons)\n",
" \n",
" playlist = []\n",
" duree_actuelle = 0\n",
" \n",
" for chanson in chansons_triees:\n",
" # Vérifier si on peut ajouter cette chanson\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return playlist\n",
"\n",
"# Test : playlist de 10 minutes max (600 secondes)\n",
"playlist_auto = creer_playlist_auto(catalogue, 600)\n",
"print(\"Playlist automatique :\")\n",
"duree_totale = 0\n",
"for c in playlist_auto:\n",
" afficher_chanson(c)\n",
" duree_totale = duree_totale + c[\"duree\"]\n",
"print(\"Duree totale :\", duree_totale, \"secondes\")"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"name": "python",
"version": "3.9.0"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
Reference in New Issue View Git Blame Copy Permalink