Florian/1ereNSI
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ajout exercices, corrections diverses, glossaire

Browse Source 
- 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>
This commit is contained in:
Florian Mathieu
2026-01-29 23:37:26 +01:00
parent 66323aac75
commit 616dd49e8c
43 changed files with 8682 additions and 42 deletions
Download Patch File Download Diff File Expand all files Collapse all files

325
AMELIORATIONS.md Normal file
View File

@@ -0,0 +1,325 @@
# Récapitulatif des améliorations possibles - Cours NSI Première
> Analyse complète du contenu pédagogique, chapitre par chapitre.
---
## Vue d'ensemble
Le cours est globalement **très complet et bien structuré**. Il couvre l'ensemble du programme officiel avec des exemples concrets et des projets motivants (Pokédex, Spotify, Minecraft, etc.). Voici les points d'amélioration identifiés.
---
## 1. Représentation de base
### Chapitre 1 - Entiers naturels
**Points forts** : Progression logique base 10 → base 2 → hexadécimal, exercices ludiques (films en binaire, recette de cuisine).
**Améliorations réalisées** :
- [x] Niveaux de difficulté ajoutés aux exercices (⭐ à ⭐⭐⭐)
**Améliorations possibles** :
- [ ] Ajouter des exercices Python pratiques (fonctions `bin()`, `hex()`, `int()`)
- [ ] Ajouter une section sur la fonction `format()` pour les conversions
- [ ] Les tableaux "À faire vous-même" pourraient avoir une correction en annexe
### Chapitre 2 - Entiers relatifs
**Points forts** : Explication claire du complément à 2, exemple numpy pour l'overflow.
**Améliorations possibles** :
- [ ] Ajouter un schéma visuel de la "roue" des entiers signés
- [ ] Exercices de conversion avec correction
- [ ] Exemple concret d'overflow avec conséquences réelles (bug du missile Patriot mentionné dans chapitre 3)
### Chapitre 3 - Flottants
**Points forts** : Très complet, lien avec IEEE 754, bons exercices Python.
**Améliorations possibles** :
- [ ] Le lien avec le bug du Patriot (dans exercices/PATRIOT/) pourrait être intégré dans le cours principal
- [ ] Ajouter un outil interactif de visualisation IEEE 754 (lien externe)
### Chapitre 4 - Booléens
**Points forts** : Très complet, lien vers NANDGAME, tables de vérité claires.
**Améliorations possibles** :
- [x] ~~Les fichiers PYTHON.md et KARNAUGH.md non liés~~ ✅ Sommaire ajouté
- [ ] Ajouter des exercices Python sur les opérateurs `and`, `or`, `not`
- [ ] Lier vers un simulateur de circuits logiques en ligne
### Chapitre 5 - Texte/Encodage
**Points forts** : Bon historique, distinction ASCII/ISO-8859-1/UTF-8 claire.
**Améliorations possibles** :
- [ ] Le cours est assez court comparé aux autres chapitres
- [ ] Ajouter des exercices Python avec `ord()`, `chr()`, `.encode()`, `.decode()`
- [ ] L'activité "débranchée" sur les systèmes historiques (Baudot, Morse) pourrait être mieux intégrée
- [ ] Manque la correction du TD
---
## 2. Représentation des types construits
### Chapitre 1 - Listes, tuples, itérations
**Points forts** : Contenu très complet, tableaux récapitulatifs utiles.
**Améliorations possibles** :
- [ ] **Incohérence** : `namedtuple` est enseigné ici mais retiré des évaluations → clarifier si c'est au programme ou bonus
- [x] ~~Les f-strings sont utilisées~~ → Corrigé, remplacées par print() avec virgules
- [ ] Le TP Mastermind est bien conçu mais manque une correction
### Chapitre 2 - Dictionnaires
**Points forts** : Clair et progressif, bonne explication de `.get()`.
**Améliorations possibles** :
- [ ] Ajouter plus d'exemples de cas d'usage concrets
- [ ] Lier vers les exercices Pokédex mentionnés dans le dossier `exercices/`
### Chapitre 3 - Structures imbriquées
**Points forts** : Bon exemple avec les personnages du Seigneur des Anneaux.
**Améliorations possibles** :
- [ ] Chapitre très court (105 lignes) comparé aux autres
- [ ] Ajouter plus d'exemples et d'exercices
- [ ] Les compréhensions sont enseignées mais retirées des évaluations → clarifier le niveau attendu
### Évaluations (TP01-TP10)
**Points forts** : Excellente variété de thèmes, squelettes bien structurés, fichiers d'aide adaptés.
**Améliorations possibles** :
- [ ] Créer un corrigé pour chaque TP (pour l'enseignant)
- [ ] Ajouter un barème indicatif dans chaque TP
---
## 3. Programmation Python
### Structure générale
- [x] ~~Les README ne contenaient que des instructions~~ ✅ Mémos complets ajoutés
**Améliorations réalisées** :
- [x] ~~Ajouter un résumé/mémo dans chaque README~~ ✅ Fait pour les 4 chapitres
- [ ] Créer un fichier `MEMO.md` récapitulant toute la syntaxe Python (optionnel)
### Chapitre 1 - Variables ✅
- [x] Types de base (int, float, str)
- [x] Opérateurs arithmétiques
- [x] Fonctions utiles (print, type, len, input)
- [x] Conversion de types
- [x] Règles de nommage
### Chapitre 2 - Conditionnelles ✅
- [x] Structure if/elif/else
- [x] Opérateurs de comparaison
- [x] Opérateurs logiques (and, or, not)
- [x] Exemple complet
### Chapitre 3 - Boucles ✅
- [x] Boucle for et range()
- [x] Boucle while
- [x] Comparaison for vs while
- [x] Attention aux boucles infinies
### Chapitre 4 - Fonctions ✅
- [x] Définition et appel
- [x] Paramètres et return
- [x] Valeurs par défaut
- [x] Portée des variables
- [x] Docstrings
---
## 4. Algorithmes
### Introduction aux algorithmes
**Points forts** : Bonne explication historique (Al-Khwarizmi), règles claires.
**Améliorations possibles** :
- [ ] Le cours est très théorique (règles 0-11) → ajouter plus d'exemples pratiques
- [ ] Les images d'algorigrammes pourraient avoir des légendes explicatives
### Algorithmes de tri
**Points forts** : Excellentes illustrations (GIF, schémas), preuves de correction.
**Améliorations possibles** :
- [ ] Ajouter le tri à bulles (souvent demandé)
- [ ] Comparaison visuelle des performances avec différentes tailles de tableaux
- [ ] Le lien vers le simulateur est très bien, le mettre plus en évidence
### Recherche dichotomique
**Points forts** : Explication claire, complexité bien détaillée.
**Améliorations possibles** :
- [ ] Ajouter une version récursive de l'algorithme
- [ ] Exercice : trouver la racine carrée par dichotomie
### Parcours séquentiel (PARCOURS.md)
- [ ] Vérifier que ce fichier existe et est complet
---
## 5. Algorithmes gloutons
**Points forts** : Excellents exemples (rendu de monnaie, sac à dos, voyageur de commerce), code Python complet.
**Améliorations possibles** :
- [ ] L'exemple de Didier Deschamps est amusant mais pourrait être mis à jour
- [ ] Ajouter un exercice sur le problème du planning (interval scheduling)
- [ ] Visualisation graphique pour le problème du voyageur
---
## 6. K-NN
**Points forts** : Bon exemple avec les Pokémon, graphiques explicatifs.
**Améliorations possibles** :
- [x] ~~Manque l'implémentation Python~~ → Existe déjà dans IMPLEMENTATION.md (très complète !)
- [x] ~~Les fichiers non liés depuis le README~~ → Sommaire ajouté au README
- [ ] Ajouter un TP complet avec scikit-learn ou implémentation manuelle
---
## 7. Architecture
### Structure générale
- [x] ~~Le fichier `architecture/README.md` n'existait pas~~ → Créé avec sommaire complet
**Améliorations possibles** :
- [ ] Ajouter un schéma récapitulatif de l'architecture d'un ordinateur
- [ ] Vérifier que l'image `assets/bo.png` existe
### Von Neumann
**Points forts** : Très complet, historique intéressant, pipeline expliqué.
**Améliorations possibles** :
- [ ] Lien vers le fichier MEMOIRE.md et TURING.md depuis le README
- [ ] Ajouter des exercices pratiques
### OS / Linux
- [ ] Vérifier que les notebooks `terminus.ipynb` et `tp_linux.ipynb` fonctionnent en standalone
### M999
- [ ] Vérifier la cohérence des instructions entre les deux fichiers d'instructions
---
## 8. Réseaux
### Adressage IP
**Points forts** : Excellente "méthode magique" pour les calculs, exercices progressifs.
**Améliorations possibles** :
- [ ] Ajouter la correction (mentionnée mais non vérifiée)
- [ ] Section IPv6 pourrait être développée
### TCP
- [ ] Vérifier le contenu du notebook et du README
### DNS
- [ ] Vérifier le contenu du notebook
### Filius (TP pratiques)
**Points forts** : 4 séances progressives, bien structuré.
**Améliorations possibles** :
- [ ] Ajouter des captures d'écran de Filius dans les README des séances
- [ ] Créer un fichier de solution pour chaque séance
---
## 9. Web
### Introduction
**Points forts** : Bonne liste de ressources, historique intéressant.
### HTML
**Points forts** : Très complet (580 lignes), structure exemplaire, nombreux exercices.
**Améliorations possibles** :
- [ ] Modèle à suivre pour les autres chapitres !
### CSS
- [ ] Vérifier que le contenu est aussi complet que HTML
- [ ] Ajouter Flexbox et Grid (mentionnés dans les ressources)
### JavaScript
- [ ] Vérifier le niveau de détail
- [ ] Adapter au programme (manipulation DOM basique)
---
## 10. Données en table
**Points forts** : Bon exemple avec les tortues ninja, code CSV clair.
**Améliorations possibles** :
- [x] ~~Le code utilisait `eval()` dans `vers_csv()`~~ → Fonction réécrite proprement
- [x] ~~Les fichiers FUSION.md, MANIPULATION.md, PANDAS.md non liés~~ ✅ Sommaire ajouté
- [ ] Ajouter des exercices avec de vrais fichiers CSV (données ouvertes)
---
## 11. Incohérences à harmoniser
| Élément | Dans le cours | Dans les évaluations | Statut |
|---------|---------------|---------------------|--------|
| f-strings | ~~Utilisées~~ | Retirées | ✅ Corrigé - remplacées par print() |
| namedtuple | Enseigné (chap 1) | Retiré | ⚠️ Clarifier si bonus ou programme |
| Compréhensions | Enseignées (chap 3) | Retirées | ⚠️ Clarifier si bonus ou programme |
| `**kwargs` | Présent dans certains exemples | Retiré | À vérifier |
---
## 12. Améliorations générales
### Documentation
- [ ] Ajouter un fichier `MEMO_PYTHON.md` récapitulant toute la syntaxe Python de première
- [x] ~~Créer un glossaire des termes techniques~~ ✅ `GLOSSAIRE.md` créé (70+ termes)
### Exercices
- [ ] Systématiser les fichiers `CORRECTION.md` pour tous les exercices
- [x] ~~Ajouter un niveau de difficulté (⭐ à ⭐⭐⭐)~~ ✅ Niveaux ajoutés aux exercices
### Projets
- [ ] Documenter les projets mentionnés (Pokédex, Zoo, Calculatrice, Choipeaux)
- [ ] Ajouter des exemples de rendus attendus
### Accessibilité
- [ ] Vérifier que toutes les images ont un texte alternatif
- [ ] Ajouter des transcriptions pour les vidéos
### Liens
- [ ] Vérifier que tous les liens externes fonctionnent encore
- [ ] Certaines ressources mentionnées (FlexboxFroggy, etc.) pourraient avoir des alternatives locales
---
## Priorités suggérées
### Haute priorité ✅ CORRIGÉ
1. ~~Créer le `architecture/README.md` manquant~~ ✅ Créé
2. ~~Ajouter l'implémentation Python de KNN~~ ✅ Déjà existant dans IMPLEMENTATION.md, sommaire ajouté au README
3. ~~Harmoniser f-strings entre cours et évaluations~~ ✅ Toutes les f-strings remplacées par print() avec virgules
4. ~~Remplacer `eval()` dans donnees_en_table~~ ✅ Fonction réécrite proprement
### Moyenne priorité ✅ CORRIGÉ
1. ~~Ajouter des résumés dans les README de programmation~~ ✅ Mémos ajoutés aux 4 chapitres
2. Compléter les corrections manquantes → Corrections manquantes identifiées (voir ci-dessous)
3. ~~Lier les fichiers non référencés~~ ✅ Sommaires ajoutés (booléens, KNN, données en table)
### Basse priorité ✅ CORRIGÉ
1. Ajouter plus de ressources visuelles → À faire au fil du temps
2. ~~Créer le glossaire~~ ✅ GLOSSAIRE.md créé avec 70+ termes
3. ~~Ajouter les niveaux de difficulté aux exercices~~ ✅ Niveaux ajoutés (⭐ à ⭐⭐⭐)
### Corrections manquantes identifiées
Les fichiers d'exercices suivants n'ont pas de correction associée :
- `representation_base/chapitre_1/EXERCICES.md` et `EXERCICES_2.md`
- `representation_base/chapitre_2/EXERCICES.md`
- `gloutons/EXERCICES.md`
- `knn/EXERCICES.md`
---
*Document généré le 29/01/2026*
*Analyse effectuée par Claude Code*

223
GLOSSAIRE.md Normal file
View File

@@ -0,0 +1,223 @@
# Glossaire NSI Première
> Lexique des termes techniques utilisés dans le cours de Numérique et Sciences Informatiques.
---
## A
**Adresse IP** : Identifiant numérique unique attribué à chaque appareil connecté à un réseau utilisant le protocole IP. Exemple : 192.168.1.1
**Affectation** : Action d'attribuer une valeur à une variable. En Python : `x = 5`
**Algorithme** : Séquence finie d'instructions permettant de résoudre un problème. Du nom du mathématicien Al-Khwarizmi.
**ASCII** : American Standard Code for Information Interchange. Table de correspondance entre caractères et nombres (0-127).
---
## B
**Binaire** : Système de numération en base 2, utilisant uniquement les chiffres 0 et 1.
**Bit** : Binary digit. Plus petite unité d'information, valant 0 ou 1.
**Booléen** : Type de variable ne pouvant prendre que deux valeurs : Vrai (True) ou Faux (False).
**Boucle** : Structure de contrôle permettant de répéter des instructions. Boucle `for` (bornée) ou `while` (non bornée).
**Bus** : Canal de communication permettant le transfert de données entre les composants d'un ordinateur.
---
## C
**Classe (KNN)** : Catégorie ou groupe auquel appartient un élément dans un problème de classification.
**Clé (dictionnaire)** : Identifiant unique permettant d'accéder à une valeur dans un dictionnaire.
**Compléxité** : Mesure de l'efficacité d'un algorithme en fonction de la taille des données (temps ou espace).
**Complément à 2** : Méthode de représentation des entiers relatifs en binaire.
**Concaténation** : Mise bout à bout de chaînes de caractères. En Python : `"Bon" + "jour"` → `"Bonjour"`
**CPU** : Central Processing Unit. Processeur, "cerveau" de l'ordinateur qui exécute les instructions.
**CSV** : Comma Separated Values. Format de fichier texte où les données sont séparées par des virgules.
---
## D
**Dictionnaire** : Structure de données associant des clés à des valeurs. En Python : `{"nom": "Alice", "age": 17}`
**Distance euclidienne** : Mesure de la distance entre deux points dans un espace. √((x₂-x₁)² + (y₂-y₁)²)
**DNS** : Domain Name System. Système traduisant les noms de domaine en adresses IP.
**Docstring** : Chaîne de documentation d'une fonction Python, entre triple guillemets.
---
## E
**Encodage** : Représentation des caractères sous forme numérique (ASCII, UTF-8...).
**Enregistrement** : Ligne d'une table de données, ensemble de valeurs pour différents attributs.
**Entier relatif** : Nombre entier pouvant être positif, négatif ou nul.
---
## F
**Flottant** : Nombre à virgule (décimal). En Python : type `float`.
**Fonction** : Bloc de code réutilisable, défini par `def`, pouvant prendre des paramètres et renvoyer une valeur.
---
## G
**Glouton (algorithme)** : Algorithme qui fait le meilleur choix local à chaque étape, sans revenir en arrière.
---
## H
**Hashable** : Propriété d'un objet pouvant servir de clé dans un dictionnaire (immutable).
**Hexadécimal** : Système de numération en base 16 (0-9, A-F).
**HTML** : HyperText Markup Language. Langage de balisage pour structurer les pages web.
**HTTP** : HyperText Transfer Protocol. Protocole de communication pour le web.
---
## I
**Immutable** : Objet dont la valeur ne peut pas être modifiée après création (tuple, str).
**Indentation** : Espaces en début de ligne définissant les blocs de code en Python.
**Indice** : Position d'un élément dans une séquence. Commence à 0 en Python.
**Invariant de boucle** : Propriété vraie avant et après chaque itération d'une boucle.
**IP** : Internet Protocol. Protocole d'adressage des machines sur un réseau.
**Itération** : Répétition d'un bloc d'instructions dans une boucle.
---
## K
**KNN** : K-Nearest Neighbors. Algorithme de classification basé sur les k plus proches voisins.
---
## L
**Liste** : Structure de données ordonnée et modifiable. En Python : `[1, 2, 3]`
**Logarithme** : log₂(n) = nombre de divisions par 2 pour atteindre 1. Complexité de la recherche dichotomique.
---
## M
**Machine de Turing** : Modèle théorique de calcul, base de l'informatique moderne.
**Masque de sous-réseau** : Valeur définissant la partie réseau et la partie hôte d'une adresse IP.
**Mutable** : Objet dont la valeur peut être modifiée après création (liste, dictionnaire).
---
## O
**Octet** : Groupe de 8 bits. Peut représenter 256 valeurs (0 à 255).
**Opérateur** : Symbole effectuant une opération (+, -, *, /, //, %, **, ==, !=, <, >...).
**Overflow** : Dépassement de capacité quand un nombre dépasse la valeur maximale représentable.
---
## P
**Paramètre** : Variable définie dans la signature d'une fonction, recevant une valeur lors de l'appel.
**Pipeline** : Technique d'exécution parallèle des étapes d'instruction dans un processeur.
**Protocole** : Ensemble de règles définissant la communication entre machines.
---
## R
**RAM** : Random Access Memory. Mémoire vive, stockage temporaire des données en cours d'utilisation.
**Recherche dichotomique** : Algorithme de recherche divisant l'espace de recherche par 2 à chaque étape. Complexité O(log n).
**Registre** : Mémoire très rapide intégrée au processeur.
**Return** : Instruction renvoyant une valeur depuis une fonction et mettant fin à son exécution.
**Routage** : Processus de détermination du chemin des paquets de données sur un réseau.
---
## S
**Séquence** : Structure de données ordonnée (liste, tuple, chaîne).
**Slice (tranche)** : Extraction d'une partie de séquence. `liste[1:4]` → éléments d'indice 1, 2, 3.
**Sous-réseau** : Division d'un réseau IP en parties plus petites.
---
## T
**Table de vérité** : Tableau listant toutes les combinaisons d'entrées et sorties d'une fonction logique.
**TCP** : Transmission Control Protocol. Protocole assurant la transmission fiable des données.
**Tri par insertion** : Algorithme de tri insérant chaque élément à sa place dans la partie triée.
**Tri par sélection** : Algorithme de tri sélectionnant le minimum et le plaçant en début.
**Tuple** : Structure de données ordonnée et non modifiable. En Python : `(1, 2, 3)`
**Type** : Nature d'une donnée (int, float, str, bool, list, dict, tuple...).
---
## U
**UTF-8** : Unicode Transformation Format 8-bit. Encodage universel des caractères.
**URL** : Uniform Resource Locator. Adresse d'une ressource sur le web.
---
## V
**Variable** : Espace mémoire nommé contenant une valeur d'un certain type.
**Variant de boucle** : Expression dont la valeur décroît à chaque itération, garantissant la terminaison.
**Von Neumann** : Architecture informatique avec mémoire unique pour données et instructions.
---
## W
**While** : Boucle non bornée s'exécutant tant qu'une condition est vraie.
---
*Document de référence pour le cours NSI Première - Lycée Charlotte Perriand*

1
README.md
View File

@@ -64,6 +64,7 @@ Les fichiers `.ipynb` peuvent être ouverts avec :
- 📄 [Programme officiel NSI Première](programme_première.pdf)
- 📄 [Programme officiel NSI Terminale](programme_terminale.pdf)
- 📋 [Progression détaillée](PROGRESSION.md)
- 📖 [Glossaire](GLOSSAIRE.md) (lexique des termes techniques)
- 📂 [Ressources complémentaires](ressources/) (vidéos, PDF, liens utiles)
## Licence

65
architecture/README.md Normal file
View File

@@ -0,0 +1,65 @@
# Architecture des ordinateurs
> Comment fonctionne un ordinateur ? De la machine de Turing aux processeurs modernes, ce chapitre explore les fondements de l'informatique.
---------
## Le programme
![bo](assets/bo.png)
---------
## Sommaire
| Chapitre | Description |
|----------|-------------|
| [Historique](historique/) | Histoire de l'informatique, des premiers calculateurs aux ordinateurs modernes |
| [Architecture Von Neumann](von_Neumann/) | Le modèle fondateur de l'architecture des ordinateurs |
| [Mémoire](von_Neumann/MEMOIRE.md) | Les différents types de mémoire |
| [Machine de Turing](von_Neumann/TURING.md) | Le concept théorique à l'origine de l'informatique |
| [Systèmes d'exploitation](os/) | Linux, la ligne de commande et l'arborescence des fichiers |
| [Simulateur M999](M999/) | Découverte du fonctionnement d'un processeur simplifié |
---------
## Introduction
Un ordinateur est une machine capable d'exécuter des instructions de manière automatique. Mais comment fonctionne-t-il réellement ?
Pour comprendre cela, nous allons étudier :
1. **L'histoire de l'informatique** : des premières machines à calculer aux ordinateurs modernes
2. **L'architecture Von Neumann** : le modèle qui définit encore aujourd'hui la structure de nos ordinateurs
3. **Les systèmes d'exploitation** : le logiciel qui fait le lien entre le matériel et les applications
### Les composants principaux
Un ordinateur est composé de :
- **Le processeur (CPU)** : le "cerveau" qui exécute les instructions
- **La mémoire (RAM)** : stockage temporaire des données en cours d'utilisation
- **Le stockage (SSD/HDD)** : stockage permanent des données
- **Les périphériques d'entrée/sortie** : clavier, souris, écran, etc.
### Ordre conseillé
1. Commencez par l'[historique](historique/) pour comprendre l'évolution
2. Étudiez l'[architecture Von Neumann](von_Neumann/) pour comprendre le fonctionnement
3. Pratiquez avec le [simulateur M999](M999/)
4. Découvrez les [systèmes d'exploitation](os/) et Linux
---------
## Travaux pratiques
- **TP Linux** : Découverte de la ligne de commande (`os/tp_linux.ipynb`)
- **TP M999** : Programmation en assembleur simplifié (`M999/`)
---------
Auteur : Florian Mathieu
Licence CC BY NC
<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a> <br />Ce cours est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Licence Creative Commons Attribution - Pas d'Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International</a>.

BIN
architecture/os/outils_linux.jpeg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 195 KiB

1
assets/web.svg Normal file
View File

@@ -0,0 +1 @@
<?xml version="1.0" ?><svg viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><defs><style>.cls-1,.cls-2{fill:none;}.cls-2{stroke:#000;stroke-linecap:round;stroke-linejoin:round;}</style></defs><g data-name="Layer 2" id="Layer_2"><g id="Workspace"><rect class="cls-1" height="24" width="24"/><path class="cls-2" d="M18.54,14.5a7,7,0,0,1-13.08,0"/><path class="cls-2" d="M5.46,9.5a7,7,0,0,1,13.08,0"/><line class="cls-2" x1="5.46" x2="18.54" y1="9.5" y2="9.5"/><line class="cls-2" x1="5.46" x2="18.54" y1="14.5" y2="14.5"/><polyline class="cls-2" points="4 11 5 13 6 11 7 13 8 11"/><polyline class="cls-2" points="10 11 11 13 12 11 13 13 14 11"/><polyline class="cls-2" points="16 11 17 13 18 11 19 13 20 11"/><path class="cls-2" d="M14.68,9.5A9.21,9.21,0,0,0,12,5,9.18,9.18,0,0,0,9.33,9.47"/><path class="cls-2" d="M9.32,14.5A9.21,9.21,0,0,0,12,19a9.21,9.21,0,0,0,2.68-4.5"/></g></g></svg>
Side by Side

After

Width:  |  Height:  |  Size: 893 B

23
donnees_en_table/README.md
View File

@@ -4,10 +4,18 @@
![meme](assets/meme.gif)
> Le format CSV est fréquemment utilisé pour échanger des données traitées à l'aide de tableurs ou de logiciels de traitement de bases de données. Ici, notre objectif sera d'apprendre à importer et exporter des données dans Python à l'aide du format CSV.
## Sommaire
| Chapitre | Description |
|----------|-------------|
| [Cours principal](#apport-de-connaissances) | Fichiers CSV, enregistrements, import/export |
| [Manipulation de tables](MANIPULATION.md) | Recherche, filtrage et tri de données |
| [Fusion de tables](FUSION.md) | Jointure et fusion de données |
| [Introduction à Pandas](PANDAS.md) | Utilisation de la bibliothèque Pandas |
| [Exercices](Exercices/) | Exercices d'application |
En informatique, il est courant de traiter d'importantes quantités d'informations, c'est d'ailleurs le modèle économique de bon nombre de sites et services que vous utilisez quotidiennement : *réseaux sociaux, magasins en ligne, cabinets d'analyses...*
> **Contenu**: Définition d'un fichier CSV, de données en table, recherche dans une table, fonction de tri <br>**Compétences**: Savoir exporter et importer des données dans un programme Python depuis un fichier CSV
@@ -147,17 +155,20 @@ resultat = [['Prenom', 'DS1', 'DS2', 'Projet'], ['Michelangelo', '12', '14', 'B'
### <span style = "color : green">Export d'un fichier CSV </span>
Pour exporter une table vers un **fichier CSV** - *comprendre, créer un fichier csv depuis une table python* - on va entrer le nom de la table sous forme de chaine de caracteres. On donnera l'ordre des colonnes sous forme de liste d'attributs.
Pour exporter une table vers un **fichier CSV** - *comprendre, créer un fichier csv depuis une table python* - on passe la table directement en paramètre, ainsi que le nom du fichier et l'ordre des colonnes.
```python
def vers_csv(nom, ordre):
with open(nom + '.csv', 'w') as fic:
def vers_csv(table, nom_fichier, ordre):
with open(nom_fichier + '.csv', 'w') as fic:
dic = csv.DictWriter(fic, fieldnames = ordre)
table = eval(nom)
dic.writeheader() # première ligne, celle des attributs
for ligne in table:
dic.writerow(ligne) # ajoute les lignes de la table
return None
# Exemple d'utilisation
Notes = [{'Prénom': 'Michelangelo', 'DS1': '12', 'DS2': '14', 'Projet': 'B'}]
vers_csv(Notes, 'notes', ['Prénom', 'DS1', 'DS2', 'Projet'])
```

16
gloutons/EXERCICES.md
View File

@@ -1,8 +1,10 @@
### Exercices - Algorithmes Gloutons
**Niveaux de difficulté :** ⭐ Facile | ⭐⭐ Moyen | ⭐⭐⭐ Difficile
---
## Exercice 1 : Achat de V-Bucks (Fortnite)
## Exercice 1 ⭐⭐ : Achat de V-Bucks (Fortnite)
Dans Fortnite, on peut acheter des V-Bucks avec les packs suivants : `{500, 1000, 2800, 5000, 13500}` V-Bucks.
@@ -35,7 +37,7 @@ Non, ce système n'est pas canonique. L'algorithme glouton ne fonctionne pas tou
---
## Exercice 2 : Playlist Spotify optimale
## Exercice 2 ⭐ : Playlist Spotify optimale
Tu prépares une playlist pour un trajet de **60 minutes**. Tu veux y mettre le maximum de sons parmi tes favoris :
@@ -88,7 +90,7 @@ Durée totale : **33 minutes**
---
## Exercice 3 : Inventaire Minecraft
## Exercice 3 ⭐⭐ : Inventaire Minecraft
Tu joues à Minecraft et ton inventaire peut contenir **64 objets** maximum. Tu veux maximiser la valeur totale des objets pour le commerce avec les villageois.
@@ -133,7 +135,7 @@ Tri par ratio décroissant, on prend dans l'ordre :
---
## Exercice 4 : Planning de stream Twitch
## Exercice 4 ⭐⭐⭐ : Planning de stream Twitch
Tu es streamer et tu dois planifier tes lives pour demain. Plusieurs marques te proposent des partenariats avec des créneaux imposés :
@@ -207,15 +209,15 @@ planning = planning_stream(sponsors)
total = sum(s[3] for s in planning)
print("Sponsors sélectionnés :")
for nom, debut, fin, remuneration in planning:
print(f" {nom} : {debut}h - {fin}h ({remuneration}€)")
print(f"Rémunération totale : {total}€")
print(" ", nom, ":", debut, "h -", fin, "h (", remuneration, "€)")
print("Rémunération totale :", total, "€")
```
</details>
---
## Exercice 5 : Réflexion
## Exercice 5 ⭐⭐ : Réflexion
1. Dans l'exercice 4, on a maximisé le **nombre** de streams. Si on voulait maximiser la **rémunération totale**, l'algorithme glouton donnerait-il le même résultat ?

8
gloutons/README.md
View File

@@ -147,8 +147,8 @@ objets = [(60, 10), (100, 20), (120, 30)]
capacite = 50
sac, valeur, poids = sac_a_dos_glouton(objets, capacite)
print(f"Objets pris : {sac}")
print(f"Valeur totale : {valeur}, Poids total : {poids}")
print("Objets pris :", sac)
print("Valeur totale :", valeur, ", Poids total :", poids)
# Résultat : [(60, 10), (100, 20)] avec valeur=160 et poids=30
# Note : ce n'est pas optimal ! L'optimal serait [(100, 20), (120, 30)] = 220
```
@@ -223,8 +223,8 @@ distances = [
chemin, distance = voyageur_commerce_glouton(distances, depart=0)
villes = ['A', 'B', 'C', 'D']
chemin_noms = [villes[i] for i in chemin]
print(f"Chemin : {' -> '.join(chemin_noms)}")
print(f"Distance totale : {distance}")
print("Chemin :", ' -> '.join(chemin_noms))
print("Distance totale :", distance)
# Résultat : A -> B -> D -> C -> A avec distance = 80
```

8
knn/EXERCICES.md
View File

@@ -1,5 +1,11 @@
### Exercices
**Niveaux de difficulté :** ⭐ Facile | ⭐⭐ Moyen | ⭐⭐⭐ Difficile
---
## Exercice 1 ⭐⭐
1. **Écrire une fonction `calculer_distance`** qui prend en entrée les caractéristiques de deux Pokémon et retourne la distance euclidienne entre eux.
2. **Tester la fonction** avec des exemples simples pour vérifier son bon fonctionnement
@@ -39,7 +45,7 @@ pokemon1 = [60, 62] # Exemple de stats pour le Pokémon 1
pokemon2 = [85, 80] # Exemple de stats pour le Pokémon 2
distance = calculer_distance(pokemon1, pokemon2)
print(f"La distance entre les deux Pokémon est : {distance}")
print("La distance entre les deux Pokémon est :", distance)
```
**Résultat attendu :** `La distance entre les deux Pokémon est : 31.400636936215164`

2
knn/IMPLEMENTATION.md
View File

@@ -189,7 +189,7 @@ pokemon_mystere = [65, 40]
# Prédiction avec k=3
prediction = knn(pokemons, pokemon_mystere, k=3)
print(f"Le Pokémon mystère est probablement de type : {prediction}")
print("Le Pokémon mystère est probablement de type :", prediction)
```
--------

11
knn/README.md
View File

@@ -1,5 +1,16 @@
> Dans le domaine de l'apprentissage automatique dit "Machine Learning", l'algorithme des k plus proches voisins est l'un des plus utilisés.
## Sommaire
| Chapitre | Description |
|----------|-------------|
| [Distance](DISTANCE.md) | Calcul des distances entre points |
| [Implémentation](IMPLEMENTATION.md) | Code Python de l'algorithme KNN |
| [TP KNN](TP_KNN.md) | Travaux pratiques |
| [Exercices](EXERCICES.md) | Exercices d'application |
---------
### Le programme
![bo](assets/bo.png)

64
programmation/chapitre_1/README.md
View File

@@ -14,6 +14,70 @@ Avoir pris en main l'éditeur en ligne [Basthon](../NOTEBOOK.ipynb)
4. Suivre le déroulé du TD, les réponses sont à mettre directement dans votre fichier,
5. À la fin de la séance, n'oubliez pas de sauvegarder votre fichier sur votre clé USB ou espace personnel.
---------
## Mémo - Les variables en Python
### Qu'est-ce qu'une variable ?
Une **variable** est un espace de stockage en mémoire, caractérisé par :
- Un **nom** (identifiant)
- Un **type** (int, float, str...)
- Une **valeur**
### Affectation
```python
age = 17 # Affecte la valeur 17 à la variable age
nom = "Alice" # Affecte la chaîne "Alice" à la variable nom
```
### Les types de base
| Type | Description | Exemple |
|------|-------------|---------|
| `int` | Entier | `42`, `-7` |
| `float` | Décimal (flottant) | `3.14`, `1.7e2` |
| `str` | Chaîne de caractères | `"Bonjour"`, `'NSI'` |
### Opérateurs arithmétiques
| Opérateur | Description | Exemple |
|-----------|-------------|---------|
| `+` | Addition | `5 + 2` → `7` |
| `-` | Soustraction | `5 - 2` → `3` |
| `*` | Multiplication | `5 * 2` → `10` |
| `/` | Division | `5 / 2` → `2.5` |
| `//` | Division entière | `5 // 2` → `2` |
| `%` | Modulo (reste) | `5 % 2` → `1` |
| `**` | Puissance | `5 ** 2` → `25` |
### Fonctions utiles
```python
print(variable) # Affiche la valeur
type(variable) # Renvoie le type
len(chaine) # Longueur d'une chaîne
input("Message") # Saisie utilisateur (renvoie str)
```
### Conversion de types
```python
int("42") # Convertit en entier → 42
float("3.14") # Convertit en flottant → 3.14
str(42) # Convertit en chaîne → "42"
```
### Règles de nommage
- Lettres minuscules, chiffres, underscore `_`
- Ne pas commencer par un chiffre
- Pas d'accents ni d'espaces
- Choisir des noms explicites
---------
## Pour aller plus loin
Une fois le TD __fini__ et __validé__, vous pouvez effectuer l'[activité suivante](../chapitre_2/)

73
programmation/chapitre_2/README.md
View File

@@ -14,6 +14,79 @@ Avoir effectué l'activité sur les [variables](../chapitre_1/)
4. Suivre le déroulé du TD, les réponses sont à mettre directement dans votre fichier,
5. À la fin de la séance, n'oubliez pas de sauvegarder votre fichier sur votre clé USB ou espace personnel.
---------
## Mémo - Les instructions conditionnelles
### Structure de base : if
```python
if condition:
# Instructions exécutées si la condition est vraie
print("Condition vraie")
```
### Structure complète : if / elif / else
```python
if condition1:
# Si condition1 est vraie
print("Cas 1")
elif condition2:
# Sinon, si condition2 est vraie
print("Cas 2")
else:
# Sinon (aucune condition vraie)
print("Cas par défaut")
```
### Opérateurs de comparaison
| Opérateur | Signification | Exemple |
|-----------|---------------|---------|
| `==` | Égal à | `a == 5` |
| `!=` | Différent de | `a != 5` |
| `<` | Strictement inférieur | `a < 5` |
| `>` | Strictement supérieur | `a > 5` |
| `<=` | Inférieur ou égal | `a <= 5` |
| `>=` | Supérieur ou égal | `a >= 5` |
### Opérateurs logiques
| Opérateur | Signification | Exemple |
|-----------|---------------|---------|
| `and` | ET logique | `a > 0 and a < 10` |
| `or` | OU logique | `a < 0 or a > 10` |
| `not` | NON logique | `not (a == 5)` |
### Exemple complet
```python
age = int(input("Quel est votre âge ? "))
if age < 0:
print("Âge invalide")
elif age < 18:
print("Vous êtes mineur")
elif age < 65:
print("Vous êtes adulte")
else:
print("Vous êtes senior")
```
### Attention à l'indentation !
En Python, l'**indentation** (les espaces en début de ligne) est obligatoire et définit les blocs de code.
```python
if condition:
instruction1 # Dans le if (4 espaces)
instruction2 # Dans le if (4 espaces)
instruction3 # Hors du if (pas d'indentation)
```
---------
## Pour aller plus loin
Une fois le TD __fini__ et __validé__, vous pouvez effectuer l'[activité suivante](../chapitre_3/)

78
programmation/chapitre_3/README.md
View File

@@ -14,6 +14,84 @@ Avoir effectué l'activité sur les [instructions conditionnelles](../chapitre_2
4. Suivre le déroulé du TD, les réponses sont à mettre directement dans votre fichier,
5. À la fin de la séance, n'oubliez pas de sauvegarder votre fichier sur votre clé USB ou espace personnel.
---------
## Mémo - Les boucles
### Boucle for (boucle bornée)
Utilisée quand on **connaît le nombre d'itérations** à l'avance.
```python
# Répéter 5 fois (i vaut 0, 1, 2, 3, 4)
for i in range(5):
print(i)
# Parcourir une liste
for element in liste:
print(element)
# Parcourir une chaîne caractère par caractère
for lettre in "Bonjour":
print(lettre)
```
### La fonction range()
| Syntaxe | Résultat |
|---------|----------|
| `range(5)` | 0, 1, 2, 3, 4 |
| `range(2, 7)` | 2, 3, 4, 5, 6 |
| `range(0, 10, 2)` | 0, 2, 4, 6, 8 |
| `range(5, 0, -1)` | 5, 4, 3, 2, 1 |
### Boucle while (boucle non bornée)
Utilisée quand on **ne connaît pas** le nombre d'itérations à l'avance.
```python
# Répéter tant que la condition est vraie
compteur = 0
while compteur < 5:
print(compteur)
compteur = compteur + 1 # Ne pas oublier !
```
### Comparaison for vs while
| Situation | Boucle à utiliser |
|-----------|-------------------|
| Répéter n fois | `for i in range(n)` |
| Parcourir une liste | `for element in liste` |
| Jusqu'à une condition | `while condition` |
| Saisie utilisateur valide | `while` |
### Exemple : Parcourir avec l'indice
```python
liste = ["a", "b", "c"]
# Méthode 1 : par les éléments
for element in liste:
print(element)
# Méthode 2 : par les indices
for i in range(len(liste)):
print(i, liste[i])
```
### Attention aux boucles infinies !
```python
# DANGER : boucle infinie (n n'est jamais modifié)
n = 0
while n < 5:
print(n)
# n = n + 1 ← Oublié !
```
---------
## Pour aller plus loin
Une fois le TD __fini__ et __validé__, vous pouvez effectuer l'[activité suivante](../chapitre_4/)

110
programmation/chapitre_4/README.md
View File

@@ -13,3 +13,113 @@ Avoir effectué l'activité sur les [boucles](../chapitre_3/)
3. Ouvrir le fichier TD.ipynb téléchargé,
4. Suivre le déroulé du TD, les réponses sont à mettre directement dans votre fichier,
5. À la fin de la séance, n'oubliez pas de sauvegarder votre fichier sur votre clé USB ou espace personnel.
---------
## Mémo - Les fonctions
### Définir une fonction
```python
def nom_fonction(parametre1, parametre2):
"""Documentation de la fonction (docstring)"""
# Instructions
resultat = parametre1 + parametre2
return resultat
```
### Appeler une fonction
```python
# Définition
def carre(x):
return x * x
# Appel
resultat = carre(5) # resultat vaut 25
print(carre(3)) # Affiche 9
```
### Fonction sans retour
```python
def afficher_bonjour(prenom):
print("Bonjour", prenom)
# Pas de return → renvoie None
afficher_bonjour("Alice") # Affiche : Bonjour Alice
```
### Fonction avec plusieurs paramètres
```python
def aire_rectangle(longueur, largeur):
return longueur * largeur
surface = aire_rectangle(5, 3) # surface vaut 15
```
### Fonction avec valeur par défaut
```python
def saluer(prenom, message="Bonjour"):
print(message, prenom)
saluer("Alice") # Affiche : Bonjour Alice
saluer("Bob", "Salut") # Affiche : Salut Bob
```
### Portée des variables
```python
x = 10 # Variable globale
def ma_fonction():
y = 5 # Variable locale (existe uniquement dans la fonction)
return x + y
print(ma_fonction()) # Affiche 15
# print(y) # ERREUR : y n'existe pas ici
```
### Docstring et spécification
```python
def moyenne(a, b):
"""
Calcule la moyenne de deux nombres.
Paramètres:
a (int ou float): premier nombre
b (int ou float): deuxième nombre
Retourne:
float: la moyenne de a et b
"""
return (a + b) / 2
```
### Exemple complet
```python
def est_pair(n):
"""Renvoie True si n est pair, False sinon."""
if n % 2 == 0:
return True
else:
return False
# Version simplifiée
def est_pair(n):
return n % 2 == 0
# Utilisation
print(est_pair(4)) # True
print(est_pair(7)) # False
```
---------
## Pour aller plus loin
Félicitations ! Vous avez terminé les bases de la programmation Python.

21
representation_base/chapitre_1/EXERCICES.md
View File

@@ -1,6 +1,10 @@
# Codage des entiers
## Exercice 1
**Niveaux de difficulté :** ⭐ Facile | ⭐⭐ Moyen | ⭐⭐⭐ Difficile
---
## Exercice 1 ⭐
Donner l'écriture décimale des entiers ci-dessous positifs codés en binaire sur un octet sans complément à 2.
@@ -10,7 +14,7 @@ Donner l'écriture décimale des entiers ci-dessous positifs codés en binaire s
- $`11111110_2`$=
- $`01000010_2`$ =
## Exercice 2
## Exercice 2 ⭐
Donner l'écriture binaire des entiers positifs ci-dessous sur un octet sans complément à 2.
@@ -23,8 +27,7 @@ Donner l'écriture binaire des entiers positifs ci-dessous sur un octet sans com
* 128 =
* 255 =
## Exercice 3
## Exercice 3 ⭐⭐
Certaines œuvres (film, livre, série...) contiennent un nombre dans leur titre. L'objectif est d'écrire les nombres en base 2, ce qui donne une toute autre lecture des titres...
@@ -46,7 +49,7 @@ Exemple : Terminator $`2`$ $`\rightarrow`$ Terminator $`\overline{10}^2`$
- **28** jours plus tard
- Les **Quatre Cents** Coups
## Exercice 4
## Exercice 4 ⭐⭐
Poser les additions de ces nombres binaires, tous positifs et codés sans complément à 2. Donner la valeur en base 10 du résultat.
@@ -55,7 +58,7 @@ Poser les additions de ces nombres binaires, tous positifs et codés sans compl
* $`10001_2+11010_2`$
* $`1101_2+10101_2`$
## Exercice 5
## Exercice 5 ⭐
Convertir en hexadécimal :
@@ -71,7 +74,7 @@ De même avec les entiers positifs ci-dessous codés sans compléments à 2.
* $`10110010_2 = `$
* $`10011001_2 = `$
## Exercice 6
## Exercice 6 ⭐
Convertir en base 10.
@@ -82,7 +85,7 @@ Convertir en base 10.
* $`FAB_{16} = `$
* $`ABCD_{16} = `$
## Exercice 7
## Exercice 7 ⭐⭐
Convertir en base 10.
@@ -93,7 +96,7 @@ Convertir en base 10.
- Le revenu annuel médian en France s'élève à $`6EA_{16}`$ euros.
- La population mondiale dépasse les $`1A0 000 000_{16}`$ habitants
## Exercice 8
## Exercice 8 ⭐⭐⭐
Une recette de cuisine demande de la précision.

24
representation_base/chapitre_2/EXERCICES.md
View File

@@ -1,34 +1,38 @@
# Exercices
# Exercices - Entiers relatifs (complément à 2)
## Exercice 1
**Niveaux de difficulté :** ⭐ Facile | ⭐⭐ Moyen | ⭐⭐⭐ Difficile
Donner la représentation binaire en complément à 2 des nombres relatifs suivants sur 8 bits: 25, -30, -124,100
---
## Exercice 2
## Exercice 1 ⭐
Donner la représentation binaire en complément à 2 des nombres relatifs suivants sur 8 bits: 25, -30, -124, 100
## Exercice 2 ⭐
Soit le nombre écrit en binaire en complément à 2: $`00110110`$. Donner le signe de ce nombre. Écrire en binaire l'opposé de ce nombre.
## Exercice 3
## Exercice 3 ⭐
Peut-on écrire un nombre en binaire en complément à 2 sur 16 bits ? Si oui, donner un exemple de nombre négatif.
## Exercice 4
## Exercice 4 ⭐⭐⭐
1. L'ours polaire peut atteindre 26m de profondeur et l'orque 109m. Donner les représentations en binaire en complément à 2 sur 8 bits de ces profondeurs.
Quelles opérations permet de vérifier l'exactitude de vos calculs ?
2. Le zéro absolu est la température la plus basse qui puisse exister. Selon un accord international, la valeur du zéro absolu est fixée à −273,15 °C. Nous allons l'arrondir à -273°C. Combien de bits sont nécessaires pour le représenter en binaire en complément à 2 ? Donner sa représentation binaire sur le nombre de bits identifiés.
3. Le point le plus profond atteint par un homme en plongée sous-marine est de $`1010110100_2`$. Donner sa représentation en décimale.
3. Le point le plus profond atteint par un homme en plongée sous-marine est de $`1010110100_2`$. Donner sa représentation en décimale.
4. La température minimale $`T_{min}`$ jamais observée en europe est $`1000110`$. Sans calculer la valeur en décimale donner à quelle température minimale puissance de 2 $`T_k`$, $`T_{min} > T_k`$.
## Exercice 5
## Exercice 5 ⭐⭐
Soit les nombres écrits en binaire en complément à 2 sur 8 bits: $`a=10101010`$ et $`b=01101101`$. Calculer $`a+b`$ en binaire. Ecrire $`a`$ et $`b`$ en décimal et vérifier le résultat de votre addition.
## Exercice 6
## Exercice 6 ⭐⭐
Soit les nombres écrits en binaire en complément à 2 sur 8 bits: $`c=10001011`$ et $`d=00010101`$. Calculer $`c+d`$ en binaire. Ecrire $`c`$ et $`d`$ en décimal et vérifier le résultat de votre addition.
## Exercice 7
## Exercice 7 ⭐⭐⭐
Soit $`e=10011100`$ et $`f=00010101`$ en binaire signés sur 8 bits. Calculer $`e-f`$ en binaire et en décimal. Que constatez vous?

12
representation_base/chapitre_4/README.md
View File

@@ -2,6 +2,18 @@
> Ce cours fournit une introduction à la logique booléenne et à la manière dont elle s'applique à l'informatique. Vous apprendrez non seulement les bases des opérations booléennes, mais vous comprendrez également comment ces opérations peuvent être utilisées pour créer des structures plus complexes, telles que des additions binaires, des multiplexeurs, des décodeurs et, finalement, un ordinateur entier.
## Sommaire
| Chapitre | Description |
|----------|-------------|
| [Cours principal](#définition) | Logique booléenne, tables de vérité, portes logiques |
| [Python et booléens](PYTHON.md) | Opérateurs booléens en Python |
| [Tables de Karnaugh](KARNAUGH.md) | Simplification d'expressions logiques |
| [Exercices](exercices/) | Exercices d'application |
| [TP](tp/) | Travaux pratiques |
---------
## Le programme
![bo](assets/bo.png)

2
representation_construits/chapitre_1/README.md
View File

@@ -352,7 +352,7 @@ Coordonnees = namedtuple('Coordonnees', ['latitude', 'longitude'])
paris = Coordonnees(48.8566, 2.3522)
lyon = Coordonnees(latitude=45.7640, longitude=4.8357)
print(f"Paris : {paris.latitude}°N, {paris.longitude}°E")
print("Paris :", paris.latitude, "°N,", paris.longitude, "°E")
```
### Avantages des p-uplets nommés

2
representation_construits/chapitre_1/projet/README.md
View File

@@ -49,7 +49,7 @@ L'algorithme principal est le suivant :
bombe = creer_bombe(creer_combinaison(combinaison))
numero_serie = creer_numero_serie()
print(f"n°{numero_serie}")
print("n°", numero_serie)
afficher_bombe(bombe)

481
representation_construits/chapitre_1/tp/TP_RATTRAPAGE_LISTES.md Normal file
View File

@@ -0,0 +1,481 @@
# TP de rattrapage : Le Vérificateur de Code Secret
**Travail personnel obligatoire**
Ce TP est à réaliser **chez vous**. Il vous prépare au TP Mastermind en vous faisant travailler les mêmes notions, mais **étape par étape**.
Chaque étape vous indique :
- Ce que vous devez faire
- Où trouver l'aide dans votre cours
- Des indices pour vous guider
**Vous devez rendre un fichier Python `verificateur.py` avec tout votre code.**
---
## Contexte
Vous allez créer un petit programme qui vérifie si un code secret à 4 chiffres est correct. C'est comme un digicode d'immeuble !
Le code secret est : `[1, 2, 3, 4]`
L'utilisateur propose un code, et le programme lui dit :
- Combien de chiffres sont **bien placés**
- Combien de chiffres sont **présents mais mal placés**
---
## Partie 1 : Créer des listes (15 min)
### Exercice 1.1 - Créer le code secret
**Objectif** : Créer une variable `code_secret` qui contient la liste `[1, 2, 3, 4]`
**Aide dans le cours** :
> 📖 Cours sur les listes → Section **"Créer une liste"**
> Cherchez "créer par extension"
**Ce que vous devez écrire** : Une seule ligne de code qui crée la variable.
**Vérification** : Ajoutez `print(code_secret)` et exécutez. Vous devez voir `[1, 2, 3, 4]`
---
### Exercice 1.2 - Créer une proposition
**Objectif** : Créer une variable `proposition` qui contient la liste `[1, 5, 3, 2]`
**Aide dans le cours** :
> 📖 Même section que l'exercice précédent
**Vérification** : Ajoutez `print(proposition)` et exécutez.
---
### Exercice 1.3 - Créer une liste vide
**Objectif** : Créer une variable `resultats` qui est une liste **vide**
**Aide dans le cours** :
> 📖 Cours sur les listes → Section **"Créer une liste"**
> Cherchez "Vide"
**Indice** : Une liste vide s'écrit avec des crochets sans rien dedans.
**Vérification** : `print(resultats)` doit afficher `[]`
---
## Partie 2 : Accéder aux éléments (15 min)
### Exercice 2.1 - Afficher le premier élément
**Objectif** : Afficher le **premier** élément de `code_secret`
**Aide dans le cours** :
> 📖 Cours sur les listes → Section **"Accéder aux éléments d'une liste"**
> Cherchez "indice" et "Le premier élément"
**Question** : Quel est l'indice du premier élément ? (Ce n'est PAS 1 !)
**Ce que vous devez écrire** : `print(code_secret[???])` en remplaçant `???`
**Vérification** : Vous devez voir `1`
---
### Exercice 2.2 - Afficher le dernier élément
**Objectif** : Afficher le **dernier** élément de `code_secret`
**Aide dans le cours** :
> 📖 Même section
> Cherchez "indice négatif"
**Deux méthodes possibles** :
- Avec l'indice positif (lequel ?)
- Avec l'indice négatif `-1`
**Vérification** : Vous devez voir `4`
---
### Exercice 2.3 - Connaître la taille d'une liste
**Objectif** : Afficher le nombre d'éléments dans `code_secret`
**Aide dans le cours** :
> 📖 Cours sur les listes → Section **"Accéder aux éléments d'une liste"**
> Cherchez "len"
**Ce que vous devez écrire** : `print(len(???))` en remplaçant `???`
**Vérification** : Vous devez voir `4`
---
## Partie 3 : Comparer des éléments (20 min)
### Exercice 3.1 - Comparer deux valeurs
**Objectif** : Afficher `True` si le premier élément de `code_secret` est égal au premier élément de `proposition`, `False` sinon.
**Aide dans le cours** :
> 📖 Cours sur les conditionnelles (programmation/chapitre_2) → Section **"Comparaisons de variables"**
> Cherchez "est égal à" et le symbole correspondant
**Attention** : Pour tester l'égalité, on n'utilise PAS `=` mais un autre symbole !
**Ce que vous devez écrire** : `print(code_secret[0] ??? proposition[0])` en remplaçant `???`
**Vérification** : Avec `code_secret = [1,2,3,4]` et `proposition = [1,5,3,2]`, vous devez voir `True` (car les deux premiers éléments sont `1`)
---
### Exercice 3.2 - Comparer le deuxième élément
**Objectif** : Même chose pour le **deuxième** élément
**Vérification** : Vous devez voir `False` (car `2 != 5`)
---
### Exercice 3.3 - Utiliser une condition if
**Objectif** : Écrire un code qui affiche `"Bien placé !"` si le premier élément est correct, sinon affiche `"Raté !"`
**Aide dans le cours** :
> 📖 Cours sur les conditionnelles → Section **"Cas : Si...Alors...Sinon"**
> Regardez la structure `if ... else`
**Structure à compléter** :
```python
if code_secret[0] == proposition[0]:
print(???)
else:
print(???)
```
**Vérification** : Avec les listes données, vous devez voir `"Bien placé !"`
---
## Partie 4 : Parcourir une liste avec une boucle (25 min)
### Exercice 4.1 - Afficher tous les éléments
**Objectif** : Afficher **tous** les éléments de `code_secret`, un par ligne
**Aide dans le cours** :
> 📖 Cours sur les listes → Section **"Parcours d'une séquence"**
> Cherchez "for elt in liste"
**Structure à compléter** :
```python
for element in code_secret:
print(???)
```
**Vérification** : Vous devez voir :
```
1
2
3
4
```
---
### Exercice 4.2 - Parcourir avec les indices
**Objectif** : Afficher l'indice ET l'élément correspondant
**Aide dans le cours** :
> 📖 Cours sur les listes → Section **"Parcours d'une séquence"**
> Cherchez "for i in range(len(...))"
> 📖 Cours sur les boucles (programmation/chapitre_3) → Section **"Utilisation de la fonction range()"**
**Structure à compléter** :
```python
for i in range(len(code_secret)):
print("Indice", i, "-> valeur", ???)
```
**Indice** : Pour accéder à l'élément d'indice `i`, on écrit `code_secret[i]`
**Vérification** : Vous devez voir :
```
Indice 0 -> valeur 1
Indice 1 -> valeur 2
Indice 2 -> valeur 3
Indice 3 -> valeur 4
```
---
### Exercice 4.3 - Compter les bien placés
**Objectif** : Compter combien de chiffres de `proposition` sont bien placés (même valeur au même indice)
**Aide dans le cours** :
> 📖 Combinez ce que vous avez vu :
> - Boucle `for i in range(...)`
> - Condition `if ... == ...`
> - Compteur (une variable qu'on incrémente)
**Structure à compléter** :
```python
compteur = 0
for i in range(???):
if code_secret[i] == proposition[i]:
compteur = compteur + 1
print("Nombre de bien placés :", compteur)
```
**Vérification** : Avec `code_secret = [1,2,3,4]` et `proposition = [1,5,3,2]`, vous devez voir `2` (les positions 0 et 2 sont correctes)
---
## Partie 5 : Tester l'appartenance à une liste (15 min)
### Exercice 5.1 - Vérifier si un élément est dans une liste
**Objectif** : Afficher `True` si le chiffre `5` est présent quelque part dans `code_secret`, `False` sinon
**Aide dans le cours** :
> 📖 Cours sur les listes → Section **"À retenir"** (le tableau récapitulatif)
> Cherchez l'opérateur `in`
**Ce que vous devez écrire** : `print(5 ??? code_secret)` en remplaçant `???` par le bon mot-clé
**Vérification** : Vous devez voir `False` (car 5 n'est pas dans [1,2,3,4])
---
### Exercice 5.2 - Vérifier si 2 est dans le code
**Objectif** : Même chose avec le chiffre `2`
**Vérification** : Vous devez voir `True`
---
### Exercice 5.3 - Compter les mal placés
**Objectif** : Compter combien de chiffres de `proposition` sont **présents** dans `code_secret` mais **pas au bon endroit**
**Aide** : Un chiffre est "mal placé" si :
1. Il n'est PAS bien placé (`proposition[i] != code_secret[i]`)
2. ET il existe quelque part dans `code_secret` (`proposition[i] in code_secret`)
**Structure à compléter** :
```python
mal_places = 0
for i in range(4):
if proposition[i] != code_secret[i]: # Pas bien placé
if proposition[i] ??? code_secret: # Mais présent dans le code
mal_places = mal_places + 1
print("Nombre de mal placés :", mal_places)
```
**Vérification** : Avec `proposition = [1,5,3,2]`, vous devez voir `1` (le `2` est présent mais mal placé)
---
## Partie 6 : Ajouter des éléments à une liste (15 min)
### Exercice 6.1 - Ajouter un élément
**Objectif** : Ajouter le nombre `99` à la fin de la liste `resultats` (qui était vide)
**Aide dans le cours** :
> 📖 Cours sur les listes → Section **"Propriétés"**
> Cherchez "append"
**Ce que vous devez écrire** : `resultats.???(99)` en remplaçant `???`
**Vérification** : `print(resultats)` doit afficher `[99]`
---
### Exercice 6.2 - Construire une liste de résultats
**Objectif** : Créer une liste qui contient `"OK"` pour chaque position bien placée et `"X"` pour chaque position mal placée
**Structure à compléter** :
```python
resultats = []
for i in range(4):
if code_secret[i] == proposition[i]:
resultats.???(???) # Ajouter "OK"
else:
resultats.???(???) # Ajouter "X"
print(resultats)
```
**Vérification** : Avec `proposition = [1,5,3,2]`, vous devez voir `['OK', 'X', 'OK', 'X']`
---
## Partie 7 : Créer une fonction (20 min)
### Exercice 7.1 - Votre première fonction
**Objectif** : Créer une fonction `dire_bonjour` qui affiche "Bonjour !"
**Aide dans le cours** :
> 📖 Cours sur les fonctions (programmation/chapitre_4) → Section **"Déclaration d'une fonction"**
**Structure** :
```python
def dire_bonjour():
print("Bonjour !")
```
**Pour appeler la fonction** : `dire_bonjour()`
**Vérification** : Vous devez voir `Bonjour !`
---
### Exercice 7.2 - Fonction avec paramètre
**Objectif** : Créer une fonction `dire_bonjour_a` qui prend un `prenom` en paramètre et affiche "Bonjour [prenom] !"
**Structure à compléter** :
```python
def dire_bonjour_a(prenom):
print("Bonjour", ???, "!")
```
**Appel** : `dire_bonjour_a("Alice")` doit afficher `Bonjour Alice !`
---
### Exercice 7.3 - Fonction qui renvoie une valeur
**Objectif** : Créer une fonction `double` qui prend un nombre en paramètre et **renvoie** son double
**Aide dans le cours** :
> 📖 Cours sur les fonctions → Cherchez `return`
**Structure à compléter** :
```python
def double(nombre):
resultat = nombre * 2
return ???
```
**Appel** : `print(double(5))` doit afficher `10`
---
### Exercice 7.4 - La fonction finale !
**Objectif** : Créer une fonction `verifier_code(secret, proposition)` qui :
- Prend deux listes en paramètres
- Renvoie le nombre de chiffres bien placés
**Structure à compléter** :
```python
def verifier_code(secret, proposition):
compteur = 0
for i in range(???):
if secret[i] == proposition[i]:
compteur = ???
return ???
```
**Test** :
```python
code_secret = [1, 2, 3, 4]
essai = [1, 5, 3, 2]
resultat = verifier_code(code_secret, essai)
print("Bien placés :", resultat) # Doit afficher 2
```
---
## Partie 8 : Le programme complet (30 min)
### Exercice final
**Objectif** : Assembler tout ce que vous avez appris pour créer une fonction `analyser_code(secret, proposition)` qui renvoie **deux valeurs** :
- Le nombre de bien placés
- Le nombre de mal placés
**Aide dans le cours** :
> 📖 Cours sur les fonctions → Cherchez comment renvoyer plusieurs valeurs avec `return`
> (Indice : on sépare les valeurs par une virgule)
**Structure à compléter** :
```python
def analyser_code(secret, proposition):
bien_places = 0
mal_places = 0
for i in range(4):
if secret[i] == proposition[i]:
# C'est bien placé
???
elif proposition[i] in secret:
# C'est présent mais mal placé
???
return ???, ???
```
**Test** :
```python
code = [1, 2, 3, 4]
essai = [1, 5, 3, 2]
bp, mp = analyser_code(code, essai)
print("Bien placés :", bp) # Doit afficher 2
print("Mal placés :", mp) # Doit afficher 1
```
---
## Récapitulatif des notions
| Partie | Notion | Où dans le cours |
|--------|--------|------------------|
| 1 | Créer une liste | Listes → "Créer une liste" |
| 2 | Accéder par indice | Listes → "Accéder aux éléments" |
| 3 | Comparer avec `==` | Conditionnelles → "Comparaisons" |
| 3 | Structure `if/else` | Conditionnelles → "Si...Alors...Sinon" |
| 4 | Boucle `for` | Listes → "Parcours" + Boucles |
| 4 | `range(len(...))` | Boucles → "Fonction range()" |
| 5 | Opérateur `in` | Listes → "À retenir" (tableau) |
| 6 | Méthode `append()` | Listes → "Propriétés" |
| 7 | Fonctions `def/return` | Fonctions → "Déclaration" |
---
## Barème indicatif
| Partie | Points |
|--------|--------|
| Parties 1-2 (listes de base) | 4 pts |
| Partie 3 (comparaisons) | 3 pts |
| Partie 4 (boucles) | 4 pts |
| Partie 5 (opérateur in) | 3 pts |
| Partie 6 (append) | 2 pts |
| Partie 7 (fonctions) | 2 pts |
| Partie 8 (exercice final) | 2 pts |
| **Total** | **20 pts** |
---
## Conseils
1. **Faites les exercices dans l'ordre** : chaque exercice prépare le suivant
2. **Testez chaque exercice** avant de passer au suivant
3. **Relisez votre cours** à chaque fois que vous bloquez
4. **N'hésitez pas à revenir en arrière** si vous ne comprenez plus
5. **Écrivez tout dans un seul fichier** `verificateur.py`
---
*Ce TP est à rendre complété. Il sera noté et permettra de valider votre rattrapage sur les listes.*

4
representation_construits/chapitre_2/exercices/CORRECTION.md
View File

@@ -187,7 +187,7 @@ livre["annee_publication"] = 1950
# On affiche des détails du livre
for cle, valeur in livre.items():
print(f"{cle}: {valeur}")
print(cle, ":", valeur)
```
@@ -204,7 +204,7 @@ liste_courses = {
# Parcours du dictionnaire et affichage des articles
for article, quantite in liste_courses.items():
print(f"{article}: {quantite}")
print(article, ":", quantite)
```

476
representation_construits/evaluation/TP01_Spotify.ipynb Normal file
View File

@@ -0,0 +1,476 @@
{
"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
}

128
representation_construits/evaluation/TP01_Spotify_aide.md Normal file
View File

@@ -0,0 +1,128 @@
# Aide - TP01 Spotify
## Rappels utiles
### Acceder aux elements d'un dictionnaire
```python
chanson = {"titre": "Blinding Lights", "artiste": "The Weeknd", "duree": 203}
print(chanson["titre"]) # Blinding Lights
print(chanson.get("note", 0)) # 0 (valeur par defaut si cle absente)
```
### Convertir des secondes en minutes:secondes
```python
duree = 203 # secondes
minutes = duree // 60 # Division entiere
secondes = duree % 60 # Reste (modulo)
print(minutes, ":", secondes) # 3 : 23
```
### Parcourir une liste de dictionnaires
```python
for chanson in catalogue:
print(chanson["titre"])
```
---
## Exercice 1
### 1.1 - Affichage formate
- Utilisez print() avec des virgules : `print("Titre:", titre)`
- Pour le formatage minutes:secondes, pensez a `//` et `%`
- Concatenation avec `+` si besoin : `str(minutes) + ":" + str(secondes)`
### 1.2 - Statistiques
- Initialisez un dictionnaire vide pour le resultat
- Parcourez la liste avec une boucle for pour calculer la somme
- `round(valeur)` arrondit a l'entier
```python
total = 0
for chanson in catalogue:
total = total + chanson["duree"]
```
### 1.3 - Artistes uniques
- Parcourez et ajoutez dans une liste si pas deja present
- `sorted(liste)` trie par ordre alphabetique
```python
artistes = []
for chanson in catalogue:
if chanson["artiste"] not in artistes:
artistes.append(chanson["artiste"])
artistes.sort()
```
---
## Exercice 2
### 2.1 - Recherche
- Utilisez `if critere == "artiste":` pour differencier les cas
- Pour la recherche insensible a la casse : `"star".lower() in titre.lower()`
- Renvoyez une nouvelle liste (ne modifiez pas l'originale)
### 2.2 - Ajouter/Retirer
- Pour verifier si un titre existe deja :
```python
for chanson in playlist:
if chanson["titre"] == nouveau_titre:
return False # Deja present
```
- Pour retirer, parcourez avec l'indice :
```python
for i in range(len(playlist)):
if playlist[i]["titre"] == titre:
playlist.pop(i)
return True
```
### 2.3 - Top artistes
- Creez d'abord un dictionnaire `{artiste: total_streams}`
- Parcourez le catalogue et cumulez les streams
- Triez avec `sorted(dico.items(), key=lambda x: x[1], reverse=True)`
```python
compteur = {}
for chanson in catalogue:
artiste = chanson["artiste"]
if artiste not in compteur:
compteur[artiste] = 0
compteur[artiste] = compteur[artiste] + chanson["streams"]
```
---
## Exercice 3 (Bonus)
### 3.1 - Filtrage
```python
# Filtrer les chansons courtes
resultat = []
for chanson in catalogue:
if chanson["duree"] < 200:
resultat.append(chanson["titre"])
```
### 3.2 - Recommandations
1. D'abord, recuperez les artistes de la playlist utilisateur
2. Ensuite, filtrez le catalogue pour ces artistes
3. Excluez les chansons deja dans la playlist
4. Triez par streams decroissant
### 3.3 - Playlist automatique
- Triez d'abord le catalogue par streams decroissant
- Parcourez et ajoutez si `duree_actuelle + chanson["duree"] <= duree_cible + tolerance`
- Arretez quand `duree_actuelle >= duree_cible - tolerance`
---
## Pieges a eviter
1. **Ne pas modifier la liste originale** lors des recherches
2. **Attention aux comparaisons de chaines** : utilisez `.lower()` pour ignorer la casse
3. **Division par zero** : verifiez que la liste n'est pas vide avant de calculer une moyenne
4. **Arrondi** : `round(x, 2)` pour 2 decimales, `round(x)` pour un entier

491
representation_construits/evaluation/TP02_Minecraft.ipynb Normal file
View File

@@ -0,0 +1,491 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "cell-0",
"metadata": {},
"source": [
"# TP Évaluation - Système d'inventaire Minecraft\n",
"\n",
"**Durée : 1h30**\n",
"\n",
"**Nom :** \n",
"\n",
"**Prénom :**\n",
"\n",
"---\n",
"\n",
"Dans ce TP, vous allez créer un système de gestion d'inventaire et de craft inspiré de Minecraft.\n",
"\n",
"**Compétences évaluées :**\n",
"- Manipulation de dictionnaires\n",
"- Parcours et modification de structures\n",
"- Algorithmes de vérification"
]
},
{
"cell_type": "markdown",
"id": "cell-1",
"metadata": {},
"source": [
"## Données initiales\n",
"\n",
"**Exécutez cette cellule avant de commencer.**"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-2",
"metadata": {},
"outputs": [],
"source": [
"# Inventaire du joueur : {nom_item: quantite}\n",
"inventaire = {\n",
" \"bois\": 64,\n",
" \"pierre\": 128,\n",
" \"fer\": 32,\n",
" \"or\": 8,\n",
" \"diamant\": 3,\n",
" \"charbon\": 45,\n",
" \"cuir\": 12,\n",
" \"plume\": 24,\n",
" \"ficelle\": 16\n",
"}\n",
"\n",
"# Recettes de craft : {nom_resultat: {ingredient: quantite_necessaire}}\n",
"recettes = {\n",
" \"planche\": {\"bois\": 1},\n",
" \"baton\": {\"planche\": 2},\n",
" \"torche\": {\"baton\": 1, \"charbon\": 1},\n",
" \"pioche_bois\": {\"planche\": 3, \"baton\": 2},\n",
" \"pioche_pierre\": {\"pierre\": 3, \"baton\": 2},\n",
" \"pioche_fer\": {\"fer\": 3, \"baton\": 2},\n",
" \"pioche_diamant\": {\"diamant\": 3, \"baton\": 2},\n",
" \"epee_fer\": {\"fer\": 2, \"baton\": 1},\n",
" \"epee_diamant\": {\"diamant\": 2, \"baton\": 1},\n",
" \"coffre\": {\"planche\": 8},\n",
" \"four\": {\"pierre\": 8}\n",
"}\n",
"\n",
"# Quantites produites par craft (par defaut 1, sauf exceptions)\n",
"quantites_produites = {\n",
" \"planche\": 4,\n",
" \"baton\": 4,\n",
" \"torche\": 4\n",
"}\n",
"\n",
"# Valeurs des items en emeraudes\n",
"valeurs = {\n",
" \"bois\": 1, \"pierre\": 1, \"fer\": 5, \"or\": 10, \"diamant\": 50,\n",
" \"charbon\": 2, \"cuir\": 3, \"plume\": 1, \"ficelle\": 2,\n",
" \"planche\": 1, \"baton\": 1, \"torche\": 3\n",
"}"
]
},
{
"cell_type": "markdown",
"id": "cell-3",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 1 - Gestion de l'inventaire (25 min)\n",
"\n",
"### 1.1 Affichage de l'inventaire (4 pts)\n",
"\n",
"Écrivez une fonction `afficher_inventaire(inv)` qui affiche l'inventaire de manière formatée.\n",
"\n",
"Exemple de sortie :\n",
"```\n",
"=== INVENTAIRE ===\n",
"bois : 64\n",
"pierre : 128\n",
"fer : 32\n",
"...\n",
"==================\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-4",
"metadata": {},
"outputs": [],
"source": [
"def afficher_inventaire(inv):\n",
" print(\"=== INVENTAIRE ===\")\n",
" \n",
" for item, quantite in inv.items():\n",
" # Votre code ici\n",
" pass\n",
" \n",
" print(\"==================\")\n",
"\n",
"# Test\n",
"afficher_inventaire(inventaire)"
]
},
{
"cell_type": "markdown",
"id": "cell-5",
"metadata": {},
"source": [
"### 1.2 Ajouter un item (4 pts)\n",
"\n",
"Écrivez une fonction `ajouter_item(inv, item, quantite)` qui ajoute la quantité à l'item.\n",
"\n",
"Si l'item n'existe pas dans l'inventaire, il doit être créé.\n",
"\n",
"*Aide : utilisez `inv.get(item, 0)` pour obtenir la quantité actuelle (0 si l'item n'existe pas)*"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-6",
"metadata": {},
"outputs": [],
"source": [
"def ajouter_item(inv, item, quantite):\n",
" # Votre code ici\n",
" pass\n",
"\n",
"# Tests\n",
"test_inv = {\"bois\": 10}\n",
"ajouter_item(test_inv, \"bois\", 5)\n",
"print(\"Apres ajout de 5 bois :\", test_inv)\n",
"ajouter_item(test_inv, \"fer\", 3)\n",
"print(\"Apres ajout de 3 fer :\", test_inv)"
]
},
{
"cell_type": "markdown",
"id": "cell-7",
"metadata": {},
"source": [
"### 1.3 Retirer un item (4 pts)\n",
"\n",
"Écrivez une fonction `retirer_item(inv, item, quantite)` qui retire la quantité de l'item.\n",
"\n",
"- Renvoie `True` si le retrait a réussi\n",
"- Renvoie `False` si la quantité est insuffisante (et ne modifie pas l'inventaire)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-8",
"metadata": {},
"outputs": [],
"source": [
"def retirer_item(inv, item, quantite):\n",
" # Verifier si l'item existe et en quantite suffisante\n",
" quantite_actuelle = inv.get(item, 0)\n",
" \n",
" if quantite_actuelle < quantite:\n",
" return False\n",
" \n",
" # Retirer la quantite\n",
" # Votre code ici\n",
" pass\n",
"\n",
"# Tests\n",
"test_inv = {\"bois\": 10, \"pierre\": 5}\n",
"print(\"Retirer 5 bois :\", retirer_item(test_inv, \"bois\", 5))\n",
"print(\"Inventaire :\", test_inv)\n",
"print(\"Retirer 100 bois :\", retirer_item(test_inv, \"bois\", 100))\n",
"print(\"Inventaire :\", test_inv)"
]
},
{
"cell_type": "markdown",
"id": "cell-9",
"metadata": {},
"source": [
"### 1.4 Valeur de l'inventaire (4 pts)\n",
"\n",
"Écrivez une fonction `calculer_valeur(inv, valeurs)` qui renvoie la valeur totale de l'inventaire.\n",
"\n",
"*Note : si un item n'a pas de valeur définie, il vaut 0*"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-10",
"metadata": {},
"outputs": [],
"source": [
"def calculer_valeur(inv, valeurs):\n",
" total = 0\n",
" \n",
" for item, quantite in inv.items():\n",
" # Recuperer la valeur de l'item (0 si pas definie)\n",
" valeur_unitaire = valeurs.get(item, 0)\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return total\n",
"\n",
"# Test\n",
"print(\"Valeur totale :\", calculer_valeur(inventaire, valeurs), \"emeraudes\")"
]
},
{
"cell_type": "markdown",
"id": "cell-11",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 2 - Système de craft (35 min)\n",
"\n",
"### 2.1 Vérifier si un craft est possible (5 pts)\n",
"\n",
"Écrivez une fonction `peut_crafter(inv, recette)` qui renvoie `True` si l'inventaire contient tous les ingrédients nécessaires pour la recette, `False` sinon.\n",
"\n",
"*Note : `recette` est un dictionnaire `{ingredient: quantite_necessaire}`*"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-12",
"metadata": {},
"outputs": [],
"source": [
"def peut_crafter(inv, recette):\n",
" for ingredient, quantite_necessaire in recette.items():\n",
" quantite_disponible = inv.get(ingredient, 0)\n",
" \n",
" # Verifier si on a assez\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return True\n",
"\n",
"# Tests\n",
"print(\"Peut crafter planche ?\", peut_crafter(inventaire, recettes[\"planche\"]))\n",
"print(\"Peut crafter pioche_diamant ?\", peut_crafter(inventaire, recettes[\"pioche_diamant\"]))"
]
},
{
"cell_type": "markdown",
"id": "cell-13",
"metadata": {},
"source": [
"### 2.2 Effectuer un craft (6 pts)\n",
"\n",
"Écrivez une fonction `crafter(inv, nom_item, recettes, quantites_produites)` qui :\n",
"1. Vérifie si le craft est possible\n",
"2. Si oui, retire les ingrédients et ajoute le résultat\n",
"3. Renvoie `True` si le craft a réussi, `False` sinon\n",
"\n",
"*Note : utilisez `quantites_produites.get(nom_item, 1)` pour obtenir la quantité produite (1 par défaut)*"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-14",
"metadata": {},
"outputs": [],
"source": [
"def crafter(inv, nom_item, recettes, quantites_produites):\n",
" # Verifier que la recette existe\n",
" if nom_item not in recettes:\n",
" print(\"Recette inconnue :\", nom_item)\n",
" return False\n",
" \n",
" recette = recettes[nom_item]\n",
" \n",
" # Verifier si le craft est possible\n",
" if not peut_crafter(inv, recette):\n",
" print(\"Ingredients insuffisants pour\", nom_item)\n",
" return False\n",
" \n",
" # Retirer les ingredients\n",
" for ingredient, quantite in recette.items():\n",
" retirer_item(inv, ingredient, quantite)\n",
" \n",
" # Ajouter le resultat\n",
" quantite_produite = quantites_produites.get(nom_item, 1)\n",
" # Votre code ici\n",
" pass\n",
"\n",
"# Test\n",
"test_inv = {\"bois\": 10, \"charbon\": 5}\n",
"print(\"Inventaire avant :\", test_inv)\n",
"\n",
"crafter(test_inv, \"planche\", recettes, quantites_produites)\n",
"print(\"Apres craft de planches :\", test_inv)\n",
"\n",
"crafter(test_inv, \"baton\", recettes, quantites_produites)\n",
"print(\"Apres craft de batons :\", test_inv)\n",
"\n",
"crafter(test_inv, \"torche\", recettes, quantites_produites)\n",
"print(\"Apres craft de torches :\", test_inv)"
]
},
{
"cell_type": "markdown",
"id": "cell-15",
"metadata": {},
"source": [
"### 2.3 Lister les crafts possibles (6 pts)\n",
"\n",
"Écrivez une fonction `lister_crafts_possibles(inv, recettes)` qui renvoie la **liste des noms** de tous les items qu'il est possible de crafter avec l'inventaire actuel."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-16",
"metadata": {},
"outputs": [],
"source": [
"def lister_crafts_possibles(inv, recettes):\n",
" possibles = []\n",
" \n",
" for nom_item, recette in recettes.items():\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return possibles\n",
"\n",
"# Test\n",
"print(\"Crafts possibles :\")\n",
"print(lister_crafts_possibles(inventaire, recettes))"
]
},
{
"cell_type": "markdown",
"id": "cell-17",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 3 - Bonus (20 min)\n",
"\n",
"### 3.1 Nombre maximum de crafts (5 pts)\n",
"\n",
"Écrivez une fonction `nb_max_craft(inv, recette)` qui renvoie le nombre maximum de fois qu'on peut effectuer un craft avec l'inventaire actuel.\n",
"\n",
"*Aide : pour chaque ingrédient, calculez `quantite_disponible // quantite_necessaire`, puis prenez le minimum*"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-18",
"metadata": {},
"outputs": [],
"source": [
"def nb_max_craft(inv, recette):\n",
" if not peut_crafter(inv, recette):\n",
" return 0\n",
" \n",
" ratios = []\n",
" \n",
" for ingredient, quantite_necessaire in recette.items():\n",
" quantite_disponible = inv.get(ingredient, 0)\n",
" # Calculer combien de crafts possibles avec cet ingredient\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return min(ratios)\n",
"\n",
"# Tests\n",
"print(\"Nb max de planches :\", nb_max_craft(inventaire, recettes[\"planche\"]))\n",
"print(\"Nb max de torches :\", nb_max_craft(inventaire, recettes[\"torche\"]))\n",
"print(\"Nb max de pioche_diamant :\", nb_max_craft(inventaire, recettes[\"pioche_diamant\"]))"
]
},
{
"cell_type": "markdown",
"id": "cell-19",
"metadata": {},
"source": [
"### 3.2 Crafts avec compteur (5 pts)\n",
"\n",
"Écrivez une fonction `crafts_avec_compteur(inv, recettes)` qui renvoie un **dictionnaire** `{nom_item: nombre_max}` pour tous les items qu'on peut crafter au moins une fois."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-20",
"metadata": {},
"outputs": [],
"source": [
"def crafts_avec_compteur(inv, recettes):\n",
" resultat = {}\n",
" \n",
" for nom_item, recette in recettes.items():\n",
" nb = nb_max_craft(inv, recette)\n",
" # Ajouter au resultat si nb > 0\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return resultat\n",
"\n",
"# Test\n",
"print(\"Crafts disponibles :\")\n",
"for item, nb in crafts_avec_compteur(inventaire, recettes).items():\n",
" print(\" \", item, \":\", nb, \"x\")"
]
},
{
"cell_type": "markdown",
"id": "cell-21",
"metadata": {},
"source": [
"### 3.3 Item le plus rentable (4 pts)\n",
"\n",
"Écrivez une fonction `item_plus_rentable(inv, recettes, valeurs)` qui renvoie le nom de l'item craftable qui a la meilleure valeur de revente parmi ceux qu'on peut crafter."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-22",
"metadata": {},
"outputs": [],
"source": [
"def item_plus_rentable(inv, recettes, valeurs):\n",
" possibles = lister_crafts_possibles(inv, recettes)\n",
" \n",
" if len(possibles) == 0:\n",
" return None\n",
" \n",
" meilleur = possibles[0]\n",
" meilleure_valeur = valeurs.get(meilleur, 0)\n",
" \n",
" for item in possibles:\n",
" valeur = valeurs.get(item, 0)\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return meilleur\n",
"\n",
"# Test\n",
"print(\"Item le plus rentable a crafter :\", item_plus_rentable(inventaire, recettes, valeurs))"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"name": "python",
"version": "3.9.0"
}
},
"nbformat": 4,
"nbformat_minor": 5
}

133
representation_construits/evaluation/TP02_Minecraft_aide.md Normal file
View File

@@ -0,0 +1,133 @@
# Aide - TP02 Minecraft
## Rappels utiles
### Verifier si une cle existe dans un dictionnaire
```python
inventaire = {"bois": 64, "pierre": 32}
if "fer" in inventaire:
print("Vous avez du fer")
else:
print("Pas de fer")
# Ou avec get (renvoie 0 si absent)
quantite = inventaire.get("fer", 0)
```
### Modifier un dictionnaire
```python
# Ajouter ou modifier
inventaire["fer"] = 10
# Supprimer
del inventaire["fer"]
# Ajouter a une valeur existante
inventaire["bois"] = inventaire.get("bois", 0) + 5
```
### Trier un dictionnaire par valeur
```python
# Trier par valeur decroissante
items_tries = sorted(inventaire.items(), key=lambda x: x[1], reverse=True)
# Resultat : [("bois", 64), ("pierre", 32)]
```
---
## Exercice 1
### 1.1 - Affichage inventaire
- `sorted(inv.items(), key=lambda x: x[1], reverse=True)` pour trier par quantite
- Utilisez print() avec des virgules pour afficher
```python
for item, quantite in inventaire.items():
print(item, ":", quantite)
```
### 1.2 - Operations
- Pour ajouter : `inv[item] = inv.get(item, 0) + quantite`
- Pour retirer, **verifiez d'abord** que la quantite est suffisante
- Ne modifiez l'inventaire que si l'operation est possible
### 1.3 - Valeur
```python
total = 0
for item, qte in inv.items():
if item in valeurs:
total = total + qte * valeurs[item]
```
---
## Exercice 2
### 2.1 - Verifier craft possible
```python
def peut_crafter(inv, recette):
for ingredient, qte_necessaire in recette.items():
if inv.get(ingredient, 0) < qte_necessaire:
return False
return True
```
### 2.2 - Effectuer un craft
1. Verifiez d'abord avec `peut_crafter`
2. Si possible, retirez les ingredients
3. Ajoutez le resultat (attention a `quantites_produites`)
```python
qte_produite = quantites.get(nom_item, 1) # Par defaut 1
```
### 2.3 - Crafts disponibles
- Pour chaque recette, calculez combien de fois on peut la faire
- Le nombre max = minimum des ratios `inv[ingredient] // qte_necessaire`
```python
def nb_max_craft(inv, recette):
ratios = []
for ing, qte in recette.items():
if inv.get(ing, 0) < qte:
return 0
ratios.append(inv[ing] // qte)
return min(ratios)
```
---
## Exercice 3 (Bonus)
### 3.1 - Chaine de craft (recursivite)
```python
def ingredients_totaux(nom_item, recettes, quantite):
if nom_item not in recettes:
# C'est une matiere premiere
return {nom_item: quantite}
resultat = {}
for ingredient, qte in recettes[nom_item].items():
sous_ingredients = ingredients_totaux(ingredient, recettes, qte * quantite)
for ing, q in sous_ingredients.items():
resultat[ing] = resultat.get(ing, 0) + q
return resultat
```
### 3.2 - Meilleur equipement
- Definissez les tiers : `tiers = {"diamant": 4, "fer": 3, "pierre": 2, "bois": 1}`
- Pour chaque type (pioche, epee, armure), testez du meilleur au moins bon
- Utilisez `peut_crafter` pour verifier
### 3.3 - Liste de courses
1. Calculez les ingredients totaux pour chaque objectif
2. Soustrayez ce qui est deja dans l'inventaire
3. Ne gardez que les quantites positives (ce qui manque)
---
## Pieges a eviter
1. **Quantites produites** : un craft de planches donne 4 planches, pas 1 !
2. **Modification de dictionnaire** : creez une copie si necessaire avec `inv.copy()`
3. **Division entiere** : utilisez `//` pour obtenir un entier
4. **Recette inexistante** : verifiez que `nom_item in recettes`

509
representation_construits/evaluation/TP03_Instagram.ipynb Normal file
View File

@@ -0,0 +1,509 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "cell-0",
"metadata": {},
"source": [
"# TP Évaluation - Analyse de réseau social Instagram\n",
"\n",
"**Durée : 1h30**\n",
"\n",
"**Nom :** \n",
"\n",
"**Prénom :**\n",
"\n",
"---\n",
"\n",
"Dans ce TP, vous allez analyser un mini réseau social inspiré d'Instagram.\n",
"\n",
"**Compétences évaluées :**\n",
"- Manipulation de dictionnaires imbriqués\n",
"- Parcours de structures complexes\n",
"- Algorithmes de recherche et filtrage"
]
},
{
"cell_type": "markdown",
"id": "cell-1",
"metadata": {},
"source": [
"## Données initiales\n",
"\n",
"**Exécutez cette cellule avant de commencer.**"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-2",
"metadata": {},
"outputs": [],
"source": [
"# Base de données des utilisateurs\n",
"# Structure : {username: {infos du profil}}\n",
"utilisateurs = {\n",
" \"@music_lover\": {\n",
" \"nom\": \"Emma Martin\",\n",
" \"bio\": \"Fan de musique\",\n",
" \"verifie\": False,\n",
" \"followers\": [\"@tech_geek\", \"@foodie_paris\", \"@travel_adventures\"],\n",
" \"following\": [\"@tech_geek\", \"@fashion_style\"],\n",
" \"posts\": [\n",
" {\"id\": 1, \"type\": \"photo\", \"likes\": 234, \"commentaires\": 12},\n",
" {\"id\": 2, \"type\": \"reel\", \"likes\": 1520, \"commentaires\": 89}\n",
" ]\n",
" },\n",
" \"@tech_geek\": {\n",
" \"nom\": \"Lucas Bernard\",\n",
" \"bio\": \"Developpeur Python\",\n",
" \"verifie\": True,\n",
" \"followers\": [\"@music_lover\", \"@foodie_paris\", \"@fashion_style\", \"@travel_adventures\"],\n",
" \"following\": [\"@music_lover\", \"@foodie_paris\"],\n",
" \"posts\": [\n",
" {\"id\": 3, \"type\": \"photo\", \"likes\": 567, \"commentaires\": 34},\n",
" {\"id\": 4, \"type\": \"photo\", \"likes\": 892, \"commentaires\": 67},\n",
" {\"id\": 5, \"type\": \"reel\", \"likes\": 3420, \"commentaires\": 156}\n",
" ]\n",
" },\n",
" \"@foodie_paris\": {\n",
" \"nom\": \"Sophie Dubois\",\n",
" \"bio\": \"Food blogger Paris\",\n",
" \"verifie\": True,\n",
" \"followers\": [\"@tech_geek\", \"@fashion_style\"],\n",
" \"following\": [\"@music_lover\", \"@tech_geek\", \"@fashion_style\", \"@travel_adventures\"],\n",
" \"posts\": [\n",
" {\"id\": 6, \"type\": \"photo\", \"likes\": 1205, \"commentaires\": 78},\n",
" {\"id\": 7, \"type\": \"reel\", \"likes\": 4532, \"commentaires\": 234}\n",
" ]\n",
" },\n",
" \"@fashion_style\": {\n",
" \"nom\": \"Marie Laurent\",\n",
" \"bio\": \"Mode et tendances\",\n",
" \"verifie\": False,\n",
" \"followers\": [\"@music_lover\", \"@foodie_paris\"],\n",
" \"following\": [\"@tech_geek\", \"@foodie_paris\", \"@travel_adventures\"],\n",
" \"posts\": [\n",
" {\"id\": 8, \"type\": \"photo\", \"likes\": 2341, \"commentaires\": 123},\n",
" {\"id\": 9, \"type\": \"photo\", \"likes\": 1876, \"commentaires\": 98},\n",
" {\"id\": 10, \"type\": \"reel\", \"likes\": 5678, \"commentaires\": 321}\n",
" ]\n",
" },\n",
" \"@travel_adventures\": {\n",
" \"nom\": \"Pierre Moreau\",\n",
" \"bio\": \"Tour du monde\",\n",
" \"verifie\": True,\n",
" \"followers\": [\"@foodie_paris\", \"@fashion_style\"],\n",
" \"following\": [\"@music_lover\"],\n",
" \"posts\": [\n",
" {\"id\": 11, \"type\": \"photo\", \"likes\": 3456, \"commentaires\": 187},\n",
" {\"id\": 12, \"type\": \"reel\", \"likes\": 8901, \"commentaires\": 456}\n",
" ]\n",
" }\n",
"}"
]
},
{
"cell_type": "markdown",
"id": "cell-3",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 1 - Exploration des profils (25 min)\n",
"\n",
"### 1.1 Afficher un profil (4 pts)\n",
"\n",
"Écrivez une fonction `afficher_profil(username, utilisateurs)` qui affiche les informations d'un utilisateur.\n",
"\n",
"Exemple de sortie :\n",
"```\n",
"@tech_geek (verifie)\n",
"Nom : Lucas Bernard\n",
"Bio : Developpeur Python\n",
"Followers : 4 | Following : 2\n",
"Posts : 3\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-4",
"metadata": {},
"outputs": [],
"source": [
"def afficher_profil(username, utilisateurs):\n",
" # Verifier que l'utilisateur existe\n",
" if username not in utilisateurs:\n",
" print(\"Utilisateur non trouve\")\n",
" return\n",
" \n",
" profil = utilisateurs[username]\n",
" \n",
" # Afficher le badge verifie si necessaire\n",
" badge = \"\"\n",
" if profil[\"verifie\"]:\n",
" badge = \" (verifie)\"\n",
" \n",
" print(username + badge)\n",
" print(\"Nom :\", profil[\"nom\"])\n",
" # Completer l'affichage\n",
" # Votre code ici\n",
" pass\n",
"\n",
"# Test\n",
"afficher_profil(\"@tech_geek\", utilisateurs)"
]
},
{
"cell_type": "markdown",
"id": "cell-5",
"metadata": {},
"source": [
"### 1.2 Compter les likes et commentaires (4 pts)\n",
"\n",
"Écrivez une fonction `stats_engagement(username, utilisateurs)` qui renvoie un dictionnaire contenant :\n",
"- `\"total_likes\"` : somme des likes de tous les posts\n",
"- `\"total_commentaires\"` : somme des commentaires\n",
"- `\"nb_posts\"` : nombre de posts"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-6",
"metadata": {},
"outputs": [],
"source": [
"def stats_engagement(username, utilisateurs):\n",
" profil = utilisateurs[username]\n",
" posts = profil[\"posts\"]\n",
" \n",
" total_likes = 0\n",
" total_commentaires = 0\n",
" \n",
" for post in posts:\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return {\n",
" \"total_likes\": total_likes,\n",
" \"total_commentaires\": total_commentaires,\n",
" \"nb_posts\": len(posts)\n",
" }\n",
"\n",
"# Test\n",
"stats = stats_engagement(\"@tech_geek\", utilisateurs)\n",
"print(\"Stats de @tech_geek :\")\n",
"print(\" Likes :\", stats[\"total_likes\"])\n",
"print(\" Commentaires :\", stats[\"total_commentaires\"])\n",
"print(\" Posts :\", stats[\"nb_posts\"])"
]
},
{
"cell_type": "markdown",
"id": "cell-7",
"metadata": {},
"source": [
"### 1.3 Liste des comptes vérifiés (4 pts)\n",
"\n",
"Écrivez une fonction `comptes_verifies(utilisateurs)` qui renvoie la liste des usernames des comptes vérifiés."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-8",
"metadata": {},
"outputs": [],
"source": [
"def comptes_verifies(utilisateurs):\n",
" verifies = []\n",
" \n",
" for username, profil in utilisateurs.items():\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return verifies\n",
"\n",
"# Test\n",
"print(\"Comptes verifies :\", comptes_verifies(utilisateurs))"
]
},
{
"cell_type": "markdown",
"id": "cell-9",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 2 - Relations entre utilisateurs (35 min)\n",
"\n",
"### 2.1 Vérifier si deux utilisateurs sont amis mutuels (5 pts)\n",
"\n",
"Deux utilisateurs sont \"amis mutuels\" s'ils se suivent mutuellement (A suit B ET B suit A).\n",
"\n",
"Écrivez une fonction `sont_amis_mutuels(user1, user2, utilisateurs)` qui renvoie `True` ou `False`."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-10",
"metadata": {},
"outputs": [],
"source": [
"def sont_amis_mutuels(user1, user2, utilisateurs):\n",
" # Recuperer les listes de following\n",
" following_user1 = utilisateurs[user1][\"following\"]\n",
" following_user2 = utilisateurs[user2][\"following\"]\n",
" \n",
" # Verifier si user1 suit user2 ET user2 suit user1\n",
" # Votre code ici\n",
" pass\n",
"\n",
"# Tests\n",
"print(\"@music_lover et @tech_geek sont amis mutuels ?\", sont_amis_mutuels(\"@music_lover\", \"@tech_geek\", utilisateurs))\n",
"print(\"@foodie_paris et @travel_adventures sont amis mutuels ?\", sont_amis_mutuels(\"@foodie_paris\", \"@travel_adventures\", utilisateurs))"
]
},
{
"cell_type": "markdown",
"id": "cell-11",
"metadata": {},
"source": [
"### 2.2 Trouver tous les amis mutuels d'un utilisateur (6 pts)\n",
"\n",
"Écrivez une fonction `liste_amis_mutuels(username, utilisateurs)` qui renvoie la liste des usernames avec lesquels cet utilisateur est ami mutuel."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-12",
"metadata": {},
"outputs": [],
"source": [
"def liste_amis_mutuels(username, utilisateurs):\n",
" amis = []\n",
" \n",
" # Pour chaque utilisateur qu'on suit\n",
" for user_suivi in utilisateurs[username][\"following\"]:\n",
" # Verifier s'il nous suit aussi\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return amis\n",
"\n",
"# Test\n",
"print(\"Amis mutuels de @tech_geek :\", liste_amis_mutuels(\"@tech_geek\", utilisateurs))"
]
},
{
"cell_type": "markdown",
"id": "cell-13",
"metadata": {},
"source": [
"### 2.3 Classement par nombre de followers (6 pts)\n",
"\n",
"Écrivez une fonction `classement_followers(utilisateurs)` qui renvoie une liste de tuples `(username, nb_followers)` triée par nombre de followers décroissant.\n",
"\n",
"*Aide : utilisez `sorted(liste, key=lambda x: x[1], reverse=True)`*"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-14",
"metadata": {},
"outputs": [],
"source": [
"def classement_followers(utilisateurs):\n",
" classement = []\n",
" \n",
" for username, profil in utilisateurs.items():\n",
" nb_followers = len(profil[\"followers\"])\n",
" # Ajouter le tuple (username, nb_followers)\n",
" # Votre code ici\n",
" pass\n",
" \n",
" # Trier par nb_followers decroissant\n",
" classement = sorted(classement, key=lambda x: x[1], reverse=True)\n",
" return classement\n",
"\n",
"# Test\n",
"print(\"Classement par followers :\")\n",
"for username, nb in classement_followers(utilisateurs):\n",
" print(\" \", username, \":\", nb, \"followers\")"
]
},
{
"cell_type": "markdown",
"id": "cell-15",
"metadata": {},
"source": [
"### 2.4 Suggestions d'amis (6 pts)\n",
"\n",
"Écrivez une fonction `suggestions_amis(username, utilisateurs)` qui suggère des comptes à suivre.\n",
"\n",
"Une suggestion est un compte que nos amis suivent mais que nous ne suivons pas encore (et qui n'est pas nous-même)."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-16",
"metadata": {},
"outputs": [],
"source": [
"def suggestions_amis(username, utilisateurs):\n",
" suggestions = []\n",
" mes_suivis = utilisateurs[username][\"following\"]\n",
" \n",
" # Pour chaque personne que je suis\n",
" for ami in mes_suivis:\n",
" # Regarder qui cet ami suit\n",
" for suggestion in utilisateurs[ami][\"following\"]:\n",
" # Verifier que ce n'est pas moi et que je ne le suis pas deja\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return suggestions\n",
"\n",
"# Test\n",
"print(\"Suggestions pour @music_lover :\", suggestions_amis(\"@music_lover\", utilisateurs))"
]
},
{
"cell_type": "markdown",
"id": "cell-17",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 3 - Bonus (20 min)\n",
"\n",
"### 3.1 Posts populaires (5 pts)\n",
"\n",
"Écrivez une fonction `posts_populaires(utilisateurs, seuil_likes)` qui renvoie la liste de tous les posts ayant plus de `seuil_likes` likes.\n",
"\n",
"Chaque élément de la liste est un dictionnaire avec `\"auteur\"`, `\"post_id\"` et `\"likes\"`."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-18",
"metadata": {},
"outputs": [],
"source": [
"def posts_populaires(utilisateurs, seuil_likes):\n",
" populaires = []\n",
" \n",
" for username, profil in utilisateurs.items():\n",
" for post in profil[\"posts\"]:\n",
" if post[\"likes\"] > seuil_likes:\n",
" # Ajouter le post a la liste\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return populaires\n",
"\n",
"# Test\n",
"print(\"Posts avec plus de 3000 likes :\")\n",
"for p in posts_populaires(utilisateurs, 3000):\n",
" print(\" \", p[\"auteur\"], \"- post\", p[\"post_id\"], \":\", p[\"likes\"], \"likes\")"
]
},
{
"cell_type": "markdown",
"id": "cell-19",
"metadata": {},
"source": [
"### 3.2 Meilleur taux d'engagement (5 pts)\n",
"\n",
"Le taux d'engagement = (total_likes + total_commentaires) / nb_followers\n",
"\n",
"Écrivez une fonction `meilleur_engagement(utilisateurs)` qui renvoie le username ayant le meilleur taux d'engagement."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-20",
"metadata": {},
"outputs": [],
"source": [
"def meilleur_engagement(utilisateurs):\n",
" meilleur_user = None\n",
" meilleur_taux = 0\n",
" \n",
" for username, profil in utilisateurs.items():\n",
" # Calculer les stats\n",
" stats = stats_engagement(username, utilisateurs)\n",
" nb_followers = len(profil[\"followers\"])\n",
" \n",
" # Eviter division par zero\n",
" if nb_followers == 0:\n",
" continue\n",
" \n",
" taux = (stats[\"total_likes\"] + stats[\"total_commentaires\"]) / nb_followers\n",
" \n",
" # Comparer avec le meilleur\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return meilleur_user\n",
"\n",
"# Test\n",
"print(\"Meilleur taux d'engagement :\", meilleur_engagement(utilisateurs))"
]
},
{
"cell_type": "markdown",
"id": "cell-21",
"metadata": {},
"source": [
"### 3.3 Compter les reels (4 pts)\n",
"\n",
"Écrivez une fonction `compter_par_type(utilisateurs)` qui renvoie un dictionnaire avec le nombre total de posts de chaque type (\"photo\" et \"reel\")."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-22",
"metadata": {},
"outputs": [],
"source": [
"def compter_par_type(utilisateurs):\n",
" compteur = {\"photo\": 0, \"reel\": 0}\n",
" \n",
" for username, profil in utilisateurs.items():\n",
" for post in profil[\"posts\"]:\n",
" type_post = post[\"type\"]\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return compteur\n",
"\n",
"# Test\n",
"print(\"Nombre de posts par type :\", compter_par_type(utilisateurs))"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"name": "python",
"version": "3.9.0"
}
},
"nbformat": 4,
"nbformat_minor": 5
}

181
representation_construits/evaluation/TP03_Instagram_aide.md Normal file
View File

@@ -0,0 +1,181 @@
# Aide - TP03 Instagram
## Rappels utiles
### Acceder a des structures imbriquees
```python
utilisateurs = {
"@music_lover": {
"nom": "Emma Martin",
"followers": ["@tech_geek", "@foodie_paris"],
"posts": [
{"id": 1, "likes": 234}
]
}
}
# Acceder au nom
nom = utilisateurs["@music_lover"]["nom"]
# Acceder au premier post
premier_post = utilisateurs["@music_lover"]["posts"][0]
# Nombre de followers
nb_followers = len(utilisateurs["@music_lover"]["followers"])
```
### Parcourir un dictionnaire de dictionnaires
```python
for username, profil in utilisateurs.items():
print(username, ":", profil["nom"])
```
---
## Exercice 1
### 1.1 - Affichage profil
- Verifiez `profil["verifie"]` pour le badge
- `len(profil["posts"])` pour le nombre de posts
- `len(profil["followers"])` et `len(profil["following"])`
```python
def afficher_profil(username, users):
profil = users[username]
print(username, "-", profil["nom"])
print("Followers:", len(profil["followers"]))
print("Posts:", len(profil["posts"]))
```
### 1.2 - Statistiques d'engagement
```python
total_likes = 0
for post in profil["posts"]:
total_likes = total_likes + post["likes"]
total_commentaires = 0
for post in profil["posts"]:
total_commentaires = total_commentaires + post["commentaires"]
nb_followers = len(profil["followers"])
# Attention a la division par zero !
if nb_followers > 0:
taux = (total_likes + total_commentaires) / nb_followers
else:
taux = 0
```
### 1.3 - Relations mutuelles
```python
def sont_amis_mutuels(user1, user2, users):
# user1 suit user2 ET user2 suit user1
suit_user2 = user2 in users[user1]["following"]
suit_user1 = user1 in users[user2]["following"]
return suit_user2 and suit_user1
```
---
## Exercice 2
### 2.1 - Top influenceurs
```python
# Creer liste de tuples (username, nb_followers)
classement = []
for user, profil in users.items():
classement.append((user, len(profil["followers"])))
# Trier par nb_followers decroissant
classement = sorted(classement, key=lambda x: x[1], reverse=True)
# Renvoyer les n premiers
return classement[:n]
```
### 2.2 - Posts viraux
1. Parcourez tous les utilisateurs et leurs posts
2. Filtrez les posts avec likes > 2000
3. Creez un dictionnaire avec les infos demandees
4. Triez par likes decroissant
```python
viraux = []
for username, profil in users.items():
for post in profil["posts"]:
if post["likes"] > 2000:
viraux.append({
"auteur": username,
"post_id": post["id"],
"likes": post["likes"]
})
```
### 2.3 - Suggestions
1. Recuperez qui l'utilisateur suit
2. Pour chacun, recuperez qui ILS suivent
3. Comptez les occurrences (dictionnaire)
4. Excluez l'utilisateur et ceux deja suivis
```python
suggestions = {}
for ami in users[username]["following"]:
for suggestion in users[ami]["following"]:
if suggestion != username and suggestion not in users[username]["following"]:
if suggestion not in suggestions:
suggestions[suggestion] = 0
suggestions[suggestion] = suggestions[suggestion] + 1
```
---
## Exercice 3 (Bonus)
### 3.1 - Comptes verifies
```python
verifies = []
for user, profil in users.items():
if profil["verifie"]:
verifies.append(user)
```
### 3.2 - Total likes par user
```python
likes_par_user = {}
for user, profil in users.items():
total = 0
for post in profil["posts"]:
total = total + post["likes"]
likes_par_user[user] = total
```
### 3.3 - Feed personnalise
```python
def generer_feed(username, users, n):
posts_feed = []
suivis = users[username]["following"]
for auteur in suivis:
est_ami_mutuel = username in users[auteur]["following"]
for post in users[auteur]["posts"]:
score = post["likes"] + post["commentaires"] * 3
if post["type"] == "reel":
score = score * 1.5
if est_ami_mutuel:
score = score * 1.2
posts_feed.append({"auteur": auteur, "post": post, "score": score})
posts_feed = sorted(posts_feed, key=lambda x: x["score"], reverse=True)
return posts_feed[:n]
```
---
## Pieges a eviter
1. **KeyError** : utilisez `users.get(username)` ou verifiez `if username in users`
2. **Doublons** : verifiez avec `if element not in liste` avant d'ajouter
3. **Ami mutuel vs follower** : un follower vous suit, un ami mutuel = vous vous suivez mutuellement
4. **Division par zero** : verifiez `nb_followers > 0` avant de diviser

500
representation_construits/evaluation/TP04_Netflix.ipynb Normal file
View File

@@ -0,0 +1,500 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "cell-0",
"metadata": {},
"source": [
"# TP Évaluation - Catalogue Netflix\n",
"\n",
"**Durée : 1h30**\n",
"\n",
"**Nom :** \n",
"\n",
"**Prénom :**\n",
"\n",
"---\n",
"\n",
"Dans ce TP, vous allez manipuler un catalogue de films et séries inspiré de Netflix.\n",
"\n",
"**Compétences évaluées :**\n",
"- Manipulation de listes de dictionnaires\n",
"- Filtrage et tri de données\n",
"- Algorithmes de recherche"
]
},
{
"cell_type": "markdown",
"id": "cell-1",
"metadata": {},
"source": [
"## Données initiales\n",
"\n",
"**Exécutez cette cellule avant de commencer.**"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-2",
"metadata": {},
"outputs": [],
"source": [
"# Catalogue de contenus\n",
"# type: \"film\" ou \"serie\"\n",
"# duree: en minutes (pour les films)\n",
"# saisons et duree_moy: pour les series (duree moyenne par episode)\n",
"catalogue = [\n",
" {\"titre\": \"Stranger Things\", \"type\": \"serie\", \"genre\": [\"SF\", \"Horreur\"], \"annee\": 2016, \"note\": 8.7, \"saisons\": 4, \"duree_moy\": 50},\n",
" {\"titre\": \"Breaking Bad\", \"type\": \"serie\", \"genre\": [\"Drame\", \"Thriller\"], \"annee\": 2008, \"note\": 9.5, \"saisons\": 5, \"duree_moy\": 47},\n",
" {\"titre\": \"The Crown\", \"type\": \"serie\", \"genre\": [\"Drame\", \"Historique\"], \"annee\": 2016, \"note\": 8.6, \"saisons\": 6, \"duree_moy\": 58},\n",
" {\"titre\": \"Squid Game\", \"type\": \"serie\", \"genre\": [\"Thriller\", \"Drame\"], \"annee\": 2021, \"note\": 8.0, \"saisons\": 1, \"duree_moy\": 55},\n",
" {\"titre\": \"Wednesday\", \"type\": \"serie\", \"genre\": [\"Comedie\", \"Fantastique\"], \"annee\": 2022, \"note\": 8.1, \"saisons\": 1, \"duree_moy\": 45},\n",
" {\"titre\": \"Inception\", \"type\": \"film\", \"genre\": [\"SF\", \"Action\"], \"annee\": 2010, \"note\": 8.8, \"duree\": 148},\n",
" {\"titre\": \"The Dark Knight\", \"type\": \"film\", \"genre\": [\"Action\", \"Drame\"], \"annee\": 2008, \"note\": 9.0, \"duree\": 152},\n",
" {\"titre\": \"Pulp Fiction\", \"type\": \"film\", \"genre\": [\"Drame\", \"Thriller\"], \"annee\": 1994, \"note\": 8.9, \"duree\": 154},\n",
" {\"titre\": \"Interstellar\", \"type\": \"film\", \"genre\": [\"SF\", \"Drame\"], \"annee\": 2014, \"note\": 8.6, \"duree\": 169},\n",
" {\"titre\": \"The Matrix\", \"type\": \"film\", \"genre\": [\"SF\", \"Action\"], \"annee\": 1999, \"note\": 8.7, \"duree\": 136},\n",
" {\"titre\": \"Parasite\", \"type\": \"film\", \"genre\": [\"Thriller\", \"Comedie\"], \"annee\": 2019, \"note\": 8.5, \"duree\": 132},\n",
" {\"titre\": \"Don't Look Up\", \"type\": \"film\", \"genre\": [\"Comedie\", \"SF\"], \"annee\": 2021, \"note\": 7.2, \"duree\": 138}\n",
"]\n",
"\n",
"# Historique de visionnage\n",
"historique = [\n",
" {\"titre\": \"Stranger Things\", \"episodes_vus\": 34, \"note_perso\": 9},\n",
" {\"titre\": \"Inception\", \"note_perso\": 10},\n",
" {\"titre\": \"The Matrix\", \"note_perso\": 8},\n",
" {\"titre\": \"Wednesday\", \"episodes_vus\": 8, \"note_perso\": 7}\n",
"]\n",
"\n",
"# Ma liste (watchlist)\n",
"ma_liste = [\"Breaking Bad\", \"Interstellar\", \"Parasite\"]"
]
},
{
"cell_type": "markdown",
"id": "cell-3",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 1 - Exploration du catalogue (25 min)\n",
"\n",
"### 1.1 Afficher un contenu (4 pts)\n",
"\n",
"Écrivez une fonction `afficher_contenu(contenu)` qui affiche les informations d'un film ou d'une série.\n",
"\n",
"Pour un film : `Inception (2010) - Film | 2h28 | Note: 8.8`\n",
"\n",
"Pour une série : `Stranger Things (2016) - Serie | 4 saisons | Note: 8.7`\n",
"\n",
"*Aide : pour convertir les minutes en heures, utilisez `duree // 60` et `duree % 60`*"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-4",
"metadata": {},
"outputs": [],
"source": [
"def afficher_contenu(contenu):\n",
" titre = contenu[\"titre\"]\n",
" annee = contenu[\"annee\"]\n",
" note = contenu[\"note\"]\n",
" \n",
" if contenu[\"type\"] == \"film\":\n",
" duree = contenu[\"duree\"]\n",
" heures = duree // 60\n",
" minutes = duree % 60\n",
" # Afficher les infos du film\n",
" # Votre code ici\n",
" pass\n",
" else:\n",
" saisons = contenu[\"saisons\"]\n",
" # Afficher les infos de la serie\n",
" # Votre code ici\n",
" pass\n",
"\n",
"# Tests\n",
"afficher_contenu(catalogue[0]) # Serie\n",
"afficher_contenu(catalogue[5]) # Film"
]
},
{
"cell_type": "markdown",
"id": "cell-5",
"metadata": {},
"source": [
"### 1.2 Compter films et séries (4 pts)\n",
"\n",
"Écrivez une fonction `compter_par_type(catalogue)` qui renvoie un dictionnaire avec le nombre de films et de séries."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-6",
"metadata": {},
"outputs": [],
"source": [
"def compter_par_type(catalogue):\n",
" compteur = {\"film\": 0, \"serie\": 0}\n",
" \n",
" for contenu in catalogue:\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return compteur\n",
"\n",
"# Test\n",
"print(\"Contenu du catalogue :\", compter_par_type(catalogue))"
]
},
{
"cell_type": "markdown",
"id": "cell-7",
"metadata": {},
"source": [
"### 1.3 Liste des genres (4 pts)\n",
"\n",
"Écrivez une fonction `tous_les_genres(catalogue)` qui renvoie la liste de tous les genres présents dans le catalogue, sans doublons, triée par ordre alphabétique."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-8",
"metadata": {},
"outputs": [],
"source": [
"def tous_les_genres(catalogue):\n",
" genres = []\n",
" \n",
" for contenu in catalogue:\n",
" for genre in contenu[\"genre\"]:\n",
" if genre not in genres:\n",
" # Votre code ici\n",
" pass\n",
" \n",
" genres.sort()\n",
" return genres\n",
"\n",
"# Test\n",
"print(\"Genres disponibles :\", tous_les_genres(catalogue))"
]
},
{
"cell_type": "markdown",
"id": "cell-9",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 2 - Recherche et filtrage (35 min)\n",
"\n",
"### 2.1 Rechercher par genre (5 pts)\n",
"\n",
"Écrivez une fonction `rechercher_par_genre(catalogue, genre)` qui renvoie la liste des contenus ayant ce genre."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-10",
"metadata": {},
"outputs": [],
"source": [
"def rechercher_par_genre(catalogue, genre):\n",
" resultats = []\n",
" \n",
" for contenu in catalogue:\n",
" if genre in contenu[\"genre\"]:\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return resultats\n",
"\n",
"# Test\n",
"print(\"Contenus SF :\")\n",
"for c in rechercher_par_genre(catalogue, \"SF\"):\n",
" afficher_contenu(c)"
]
},
{
"cell_type": "markdown",
"id": "cell-11",
"metadata": {},
"source": [
"### 2.2 Filtrer par note minimum (5 pts)\n",
"\n",
"Écrivez une fonction `filtrer_par_note(catalogue, note_min)` qui renvoie la liste des contenus ayant une note supérieure ou égale à `note_min`."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-12",
"metadata": {},
"outputs": [],
"source": [
"def filtrer_par_note(catalogue, note_min):\n",
" resultats = []\n",
" \n",
" for contenu in catalogue:\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return resultats\n",
"\n",
"# Test\n",
"print(\"Contenus avec note >= 8.5 :\")\n",
"for c in filtrer_par_note(catalogue, 8.5):\n",
" afficher_contenu(c)"
]
},
{
"cell_type": "markdown",
"id": "cell-13",
"metadata": {},
"source": [
"### 2.3 Trier par note (6 pts)\n",
"\n",
"Écrivez une fonction `trier_par_note(catalogue)` qui renvoie une nouvelle liste triée par note décroissante.\n",
"\n",
"*Aide : utilisez `sorted(liste, key=lambda x: x[\"note\"], reverse=True)`*"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-14",
"metadata": {},
"outputs": [],
"source": [
"def trier_par_note(catalogue):\n",
" # Votre code ici\n",
" pass\n",
"\n",
"# Test\n",
"print(\"Top 5 par note :\")\n",
"for c in trier_par_note(catalogue)[:5]:\n",
" afficher_contenu(c)"
]
},
{
"cell_type": "markdown",
"id": "cell-15",
"metadata": {},
"source": [
"### 2.4 Recherche combinée (6 pts)\n",
"\n",
"Écrivez une fonction `recherche_avancee(catalogue, type_contenu, genre, note_min)` qui filtre selon plusieurs critères.\n",
"\n",
"- `type_contenu` : \"film\", \"serie\" ou None (tous)\n",
"- `genre` : un genre ou None (tous)\n",
"- `note_min` : note minimum ou None (pas de filtre)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-16",
"metadata": {},
"outputs": [],
"source": [
"def recherche_avancee(catalogue, type_contenu, genre, note_min):\n",
" resultats = []\n",
" \n",
" for contenu in catalogue:\n",
" # Verifier le type (si specifie)\n",
" if type_contenu != None and contenu[\"type\"] != type_contenu:\n",
" continue\n",
" \n",
" # Verifier le genre (si specifie)\n",
" if genre != None and genre not in contenu[\"genre\"]:\n",
" continue\n",
" \n",
" # Verifier la note (si specifiee)\n",
" # Votre code ici\n",
" \n",
" resultats.append(contenu)\n",
" \n",
" return resultats\n",
"\n",
"# Test\n",
"print(\"Films SF avec note >= 8.5 :\")\n",
"for c in recherche_avancee(catalogue, \"film\", \"SF\", 8.5):\n",
" afficher_contenu(c)"
]
},
{
"cell_type": "markdown",
"id": "cell-17",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 3 - Bonus (20 min)\n",
"\n",
"### 3.1 Temps de visionnage (5 pts)\n",
"\n",
"Écrivez une fonction `temps_visionne(historique, catalogue)` qui calcule le temps total de visionnage en minutes.\n",
"\n",
"Pour un film : la durée complète.\n",
"Pour une série : `episodes_vus * duree_moy`"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-18",
"metadata": {},
"outputs": [],
"source": [
"def temps_visionne(historique, catalogue):\n",
" total_minutes = 0\n",
" \n",
" for h in historique:\n",
" # Trouver le contenu dans le catalogue\n",
" contenu = None\n",
" for c in catalogue:\n",
" if c[\"titre\"] == h[\"titre\"]:\n",
" contenu = c\n",
" break\n",
" \n",
" if contenu == None:\n",
" continue\n",
" \n",
" if contenu[\"type\"] == \"film\":\n",
" # Ajouter la duree du film\n",
" # Votre code ici\n",
" pass\n",
" else:\n",
" # Ajouter duree des episodes vus\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return total_minutes\n",
"\n",
"# Test\n",
"minutes = temps_visionne(historique, catalogue)\n",
"heures = minutes // 60\n",
"print(\"Temps total visionne :\", heures, \"h\", minutes % 60, \"min\")"
]
},
{
"cell_type": "markdown",
"id": "cell-19",
"metadata": {},
"source": [
"### 3.2 Recommandation simple (5 pts)\n",
"\n",
"Écrivez une fonction `recommander(historique, catalogue)` qui recommande un contenu basé sur les genres préférés de l'utilisateur.\n",
"\n",
"1. Trouvez les genres des contenus dans l'historique\n",
"2. Trouvez un contenu non vu qui a au moins un genre en commun\n",
"3. Renvoyez le contenu avec la meilleure note"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-20",
"metadata": {},
"outputs": [],
"source": [
"def recommander(historique, catalogue):\n",
" # Collecter les genres des contenus vus\n",
" genres_aimes = []\n",
" titres_vus = []\n",
" \n",
" for h in historique:\n",
" titres_vus.append(h[\"titre\"])\n",
" # Trouver le contenu pour recuperer ses genres\n",
" for c in catalogue:\n",
" if c[\"titre\"] == h[\"titre\"]:\n",
" for g in c[\"genre\"]:\n",
" if g not in genres_aimes:\n",
" genres_aimes.append(g)\n",
" \n",
" # Trouver le meilleur contenu non vu avec un genre en commun\n",
" meilleur = None\n",
" meilleure_note = 0\n",
" \n",
" for c in catalogue:\n",
" # Verifier que non vu\n",
" if c[\"titre\"] in titres_vus:\n",
" continue\n",
" \n",
" # Verifier qu'il a un genre en commun\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return meilleur\n",
"\n",
"# Test\n",
"reco = recommander(historique, catalogue)\n",
"if reco:\n",
" print(\"Recommandation :\")\n",
" afficher_contenu(reco)"
]
},
{
"cell_type": "markdown",
"id": "cell-21",
"metadata": {},
"source": [
"### 3.3 Note moyenne par genre (4 pts)\n",
"\n",
"Écrivez une fonction `note_moyenne_par_genre(catalogue)` qui renvoie un dictionnaire `{genre: note_moyenne}`."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-22",
"metadata": {},
"outputs": [],
"source": [
"def note_moyenne_par_genre(catalogue):\n",
" # Dictionnaire pour stocker somme et compteur par genre\n",
" sommes = {}\n",
" compteurs = {}\n",
" \n",
" for contenu in catalogue:\n",
" for genre in contenu[\"genre\"]:\n",
" if genre not in sommes:\n",
" sommes[genre] = 0\n",
" compteurs[genre] = 0\n",
" sommes[genre] = sommes[genre] + contenu[\"note\"]\n",
" compteurs[genre] = compteurs[genre] + 1\n",
" \n",
" # Calculer les moyennes\n",
" moyennes = {}\n",
" for genre in sommes:\n",
" moyennes[genre] = round(sommes[genre] / compteurs[genre], 1)\n",
" \n",
" return moyennes\n",
"\n",
"# Test\n",
"print(\"Note moyenne par genre :\")\n",
"for genre, note in note_moyenne_par_genre(catalogue).items():\n",
" print(\" \", genre, \":\", note)"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"name": "python",
"version": "3.9.0"
}
},
"nbformat": 4,
"nbformat_minor": 5
}

232
representation_construits/evaluation/TP04_Netflix_aide.md Normal file
View File

@@ -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

527
representation_construits/evaluation/TP05_Football.ipynb Normal file
View File

@@ -0,0 +1,527 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "cell-0",
"metadata": {},
"source": [
"# TP Évaluation - Gestion d'équipe de Football\n",
"\n",
"**Durée : 1h30**\n",
"\n",
"**Nom :** \n",
"\n",
"**Prénom :**\n",
"\n",
"---\n",
"\n",
"Dans ce TP, vous allez créer un système de gestion d'équipe de football.\n",
"\n",
"**Compétences évaluées :**\n",
"- Manipulation de tuples et listes\n",
"- Dictionnaires et structures imbriquées\n",
"- Algorithmes de sélection"
]
},
{
"cell_type": "markdown",
"id": "cell-1",
"metadata": {},
"source": [
"## Données initiales\n",
"\n",
"**Exécutez cette cellule avant de commencer.**"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-2",
"metadata": {},
"outputs": [],
"source": [
"# Effectif de l'equipe\n",
"# Chaque joueur est un tuple : (nom, poste, note_globale, stats)\n",
"# stats est un dictionnaire avec les caracteristiques\n",
"\n",
"effectif = [\n",
" (\"Mbappe\", \"ATT\", 91, {\"vitesse\": 97, \"tir\": 89, \"passe\": 80, \"dribble\": 92, \"defense\": 36, \"physique\": 78}),\n",
" (\"Griezmann\", \"ATT\", 87, {\"vitesse\": 80, \"tir\": 86, \"passe\": 84, \"dribble\": 88, \"defense\": 56, \"physique\": 72}),\n",
" (\"Dembele\", \"ATT\", 86, {\"vitesse\": 93, \"tir\": 78, \"passe\": 82, \"dribble\": 90, \"defense\": 32, \"physique\": 63}),\n",
" (\"Thuram\", \"ATT\", 84, {\"vitesse\": 86, \"tir\": 80, \"passe\": 72, \"dribble\": 82, \"defense\": 42, \"physique\": 84}),\n",
" (\"Tchouameni\", \"MIL\", 86, {\"vitesse\": 74, \"tir\": 72, \"passe\": 80, \"dribble\": 76, \"defense\": 82, \"physique\": 86}),\n",
" (\"Kante\", \"MIL\", 88, {\"vitesse\": 78, \"tir\": 66, \"passe\": 75, \"dribble\": 81, \"defense\": 87, \"physique\": 82}),\n",
" (\"Rabiot\", \"MIL\", 82, {\"vitesse\": 72, \"tir\": 75, \"passe\": 79, \"dribble\": 80, \"defense\": 76, \"physique\": 80}),\n",
" (\"Camavinga\", \"MIL\", 83, {\"vitesse\": 82, \"tir\": 64, \"passe\": 78, \"dribble\": 82, \"defense\": 76, \"physique\": 78}),\n",
" (\"Hernandez\", \"DEF\", 85, {\"vitesse\": 84, \"tir\": 65, \"passe\": 76, \"dribble\": 78, \"defense\": 82, \"physique\": 82}),\n",
" (\"Upamecano\", \"DEF\", 84, {\"vitesse\": 80, \"tir\": 48, \"passe\": 62, \"dribble\": 58, \"defense\": 86, \"physique\": 88}),\n",
" (\"Konate\", \"DEF\", 84, {\"vitesse\": 78, \"tir\": 42, \"passe\": 56, \"dribble\": 52, \"defense\": 87, \"physique\": 86}),\n",
" (\"Saliba\", \"DEF\", 86, {\"vitesse\": 76, \"tir\": 38, \"passe\": 65, \"dribble\": 60, \"defense\": 88, \"physique\": 84}),\n",
" (\"Maignan\", \"GK\", 87, {\"plongeon\": 88, \"reflexes\": 89, \"placement\": 84, \"jeu_pied\": 78}),\n",
" (\"Lloris\", \"GK\", 85, {\"plongeon\": 86, \"reflexes\": 87, \"placement\": 86, \"jeu_pied\": 72})\n",
"]\n",
"\n",
"# Formation 4-3-3 : nombre de joueurs par poste\n",
"formation = {\n",
" \"GK\": 1, # Gardien\n",
" \"DEF\": 4, # Defenseurs\n",
" \"MIL\": 3, # Milieux\n",
" \"ATT\": 3 # Attaquants\n",
"}\n",
"\n",
"# Historique des matchs : (adversaire, buts_pour, buts_contre, buteurs)\n",
"matchs = [\n",
" (\"Allemagne\", 2, 1, [\"Mbappe\", \"Griezmann\"]),\n",
" (\"Belgique\", 3, 0, [\"Mbappe\", \"Mbappe\", \"Dembele\"]),\n",
" (\"Espagne\", 1, 2, [\"Thuram\"]),\n",
" (\"Italie\", 2, 2, [\"Griezmann\", \"Mbappe\"]),\n",
" (\"Portugal\", 0, 1, []),\n",
" (\"Angleterre\", 3, 1, [\"Mbappe\", \"Griezmann\", \"Dembele\"])\n",
"]"
]
},
{
"cell_type": "markdown",
"id": "cell-3",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 1 - Gestion de l'effectif (25 min)\n",
"\n",
"### 1.1 Affichage des joueurs (4 pts)\n",
"\n",
"Écrivez une fonction `afficher_joueur(joueur)` qui affiche un joueur de manière formatée.\n",
"\n",
"Exemple pour un joueur de champ :\n",
"```\n",
"Mbappe (ATT) - Note: 91\n",
" VIT:97 | TIR:89 | PAS:80 | DRI:92\n",
"```\n",
"\n",
"Pour les gardiens (poste \"GK\"), afficher leurs stats spécifiques (plongeon, reflexes, etc.)."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-4",
"metadata": {},
"outputs": [],
"source": [
"def afficher_joueur(joueur):\n",
" # Extraire les infos du tuple\n",
" nom = joueur[0]\n",
" poste = joueur[1]\n",
" note = joueur[2]\n",
" stats = joueur[3]\n",
" \n",
" print(nom, \"(\" + poste + \") - Note:\", note)\n",
" \n",
" if poste == \"GK\":\n",
" # Afficher stats gardien\n",
" # Votre code ici\n",
" pass\n",
" else:\n",
" # Afficher stats joueur de champ\n",
" # Votre code ici\n",
" pass\n",
"\n",
"# Tests\n",
"afficher_joueur(effectif[0]) # Joueur de champ\n",
"print()\n",
"afficher_joueur(effectif[12]) # Gardien"
]
},
{
"cell_type": "markdown",
"id": "cell-5",
"metadata": {},
"source": [
"### 1.2 Filtrage par poste (4 pts)\n",
"\n",
"Écrivez une fonction `joueurs_par_poste(effectif, poste)` qui renvoie la liste des joueurs d'un poste donné, triés par note décroissante."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-6",
"metadata": {},
"outputs": [],
"source": [
"def joueurs_par_poste(effectif, poste):\n",
" joueurs = []\n",
" \n",
" for joueur in effectif:\n",
" if joueur[1] == poste:\n",
" joueurs.append(joueur)\n",
" \n",
" # Trier par note (indice 2) decroissante\n",
" joueurs = sorted(joueurs, key=lambda j: j[2], reverse=True)\n",
" return joueurs\n",
"\n",
"# Test\n",
"print(\"Attaquants :\")\n",
"for j in joueurs_par_poste(effectif, \"ATT\"):\n",
" print(\" \", j[0], \"-\", j[2])"
]
},
{
"cell_type": "markdown",
"id": "cell-7",
"metadata": {},
"source": [
"### 1.3 Meilleur dans une stat (4 pts)\n",
"\n",
"Écrivez une fonction `meilleur_stat(effectif, stat)` qui renvoie le tuple `(nom_joueur, valeur)` du joueur ayant la meilleure valeur pour cette statistique.\n",
"\n",
"*Attention : les gardiens n'ont pas les mêmes stats que les joueurs de champ.*"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-8",
"metadata": {},
"outputs": [],
"source": [
"def meilleur_stat(effectif, stat):\n",
" meilleur_nom = None\n",
" meilleure_valeur = -1\n",
" \n",
" for joueur in effectif:\n",
" nom = joueur[0]\n",
" stats = joueur[3]\n",
" \n",
" # Verifier si le joueur a cette stat\n",
" if stat in stats:\n",
" valeur = stats[stat]\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return (meilleur_nom, meilleure_valeur)\n",
"\n",
"# Tests\n",
"print(\"Plus rapide :\", meilleur_stat(effectif, \"vitesse\"))\n",
"print(\"Meilleur tireur :\", meilleur_stat(effectif, \"tir\"))\n",
"print(\"Meilleurs reflexes :\", meilleur_stat(effectif, \"reflexes\"))"
]
},
{
"cell_type": "markdown",
"id": "cell-9",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 2 - Composition d'équipe (35 min)\n",
"\n",
"### 2.1 Générer le XI de départ (6 pts)\n",
"\n",
"Écrivez une fonction `generer_xi(effectif, formation)` qui génère automatiquement le meilleur XI possible.\n",
"\n",
"Pour chaque poste, sélectionner les meilleurs joueurs (par note globale) en respectant le nombre requis.\n",
"\n",
"Renvoie un dictionnaire `{poste: [liste des joueurs sélectionnés]}`"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-10",
"metadata": {},
"outputs": [],
"source": [
"def generer_xi(effectif, formation):\n",
" xi = {}\n",
" \n",
" for poste, nb_joueurs in formation.items():\n",
" # Recuperer les joueurs de ce poste, tries par note\n",
" candidats = joueurs_par_poste(effectif, poste)\n",
" \n",
" # Prendre les n meilleurs\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return xi\n",
"\n",
"# Test\n",
"xi = generer_xi(effectif, formation)\n",
"print(\"=== XI de depart ===\")\n",
"for poste, joueurs in xi.items():\n",
" print(poste + \":\")\n",
" for j in joueurs:\n",
" print(\" -\", j[0], \"(\", j[2], \")\")"
]
},
{
"cell_type": "markdown",
"id": "cell-11",
"metadata": {},
"source": [
"### 2.2 Note moyenne du XI (5 pts)\n",
"\n",
"Écrivez une fonction `note_equipe(xi)` qui calcule la note moyenne de l'équipe sélectionnée."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-12",
"metadata": {},
"outputs": [],
"source": [
"def note_equipe(xi):\n",
" total_notes = 0\n",
" nb_joueurs = 0\n",
" \n",
" for poste, joueurs in xi.items():\n",
" for joueur in joueurs:\n",
" # Votre code ici\n",
" pass\n",
" \n",
" if nb_joueurs == 0:\n",
" return 0\n",
" \n",
" return round(total_notes / nb_joueurs, 1)\n",
"\n",
"# Test\n",
"print(\"Note de l'equipe :\", note_equipe(xi))"
]
},
{
"cell_type": "markdown",
"id": "cell-13",
"metadata": {},
"source": [
"### 2.3 Statistiques des matchs (6 pts)\n",
"\n",
"Écrivez une fonction `stats_matchs(matchs)` qui renvoie un dictionnaire avec :\n",
"- `\"victoires\"` : nombre de victoires\n",
"- `\"nuls\"` : nombre de matchs nuls\n",
"- `\"defaites\"` : nombre de défaites\n",
"- `\"buts_pour\"` : total des buts marqués\n",
"- `\"buts_contre\"` : total des buts encaissés"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-14",
"metadata": {},
"outputs": [],
"source": [
"def stats_matchs(matchs):\n",
" victoires = 0\n",
" nuls = 0\n",
" defaites = 0\n",
" buts_pour = 0\n",
" buts_contre = 0\n",
" \n",
" for match in matchs:\n",
" adversaire = match[0]\n",
" bp = match[1] # buts pour\n",
" bc = match[2] # buts contre\n",
" \n",
" buts_pour = buts_pour + bp\n",
" buts_contre = buts_contre + bc\n",
" \n",
" if bp > bc:\n",
" victoires = victoires + 1\n",
" elif bp == bc:\n",
" nuls = nuls + 1\n",
" else:\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return {\n",
" \"victoires\": victoires,\n",
" \"nuls\": nuls,\n",
" \"defaites\": defaites,\n",
" \"buts_pour\": buts_pour,\n",
" \"buts_contre\": buts_contre\n",
" }\n",
"\n",
"# Test\n",
"stats = stats_matchs(matchs)\n",
"print(\"Bilan :\", stats[\"victoires\"], \"V\", stats[\"nuls\"], \"N\", stats[\"defaites\"], \"D\")\n",
"print(\"Buts :\", stats[\"buts_pour\"], \"-\", stats[\"buts_contre\"])"
]
},
{
"cell_type": "markdown",
"id": "cell-15",
"metadata": {},
"source": [
"### 2.4 Classement des buteurs (6 pts)\n",
"\n",
"Écrivez une fonction `classement_buteurs(matchs)` qui renvoie une liste de tuples `(joueur, nb_buts)` triée par nombre de buts décroissant."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-16",
"metadata": {},
"outputs": [],
"source": [
"def classement_buteurs(matchs):\n",
" # Dictionnaire pour compter les buts par joueur\n",
" buts_par_joueur = {}\n",
" \n",
" for match in matchs:\n",
" buteurs = match[3] # liste des buteurs\n",
" for buteur in buteurs:\n",
" if buteur not in buts_par_joueur:\n",
" buts_par_joueur[buteur] = 0\n",
" buts_par_joueur[buteur] = buts_par_joueur[buteur] + 1\n",
" \n",
" # Convertir en liste de tuples et trier\n",
" classement = []\n",
" for joueur, buts in buts_par_joueur.items():\n",
" classement.append((joueur, buts))\n",
" \n",
" classement = sorted(classement, key=lambda x: x[1], reverse=True)\n",
" return classement\n",
"\n",
"# Test\n",
"print(\"Classement des buteurs :\")\n",
"for i, (joueur, buts) in enumerate(classement_buteurs(matchs), 1):\n",
" print(\" \", i, \".\", joueur, \":\", buts, \"but(s)\")"
]
},
{
"cell_type": "markdown",
"id": "cell-17",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 3 - Bonus (20 min)\n",
"\n",
"### 3.1 Points forts et faibles (5 pts)\n",
"\n",
"Écrivez une fonction `analyser_joueur(joueur)` qui renvoie un dictionnaire avec :\n",
"- `\"points_forts\"` : liste des stats >= 85\n",
"- `\"points_faibles\"` : liste des stats <= 60"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-18",
"metadata": {},
"outputs": [],
"source": [
"def analyser_joueur(joueur):\n",
" stats = joueur[3]\n",
" points_forts = []\n",
" points_faibles = []\n",
" \n",
" for stat, valeur in stats.items():\n",
" if valeur >= 85:\n",
" points_forts.append(stat)\n",
" # Votre code ici pour les points faibles\n",
" pass\n",
" \n",
" return {\n",
" \"points_forts\": points_forts,\n",
" \"points_faibles\": points_faibles\n",
" }\n",
"\n",
"# Test\n",
"analyse = analyser_joueur(effectif[0]) # Mbappe\n",
"print(\"Analyse de Mbappe :\")\n",
"print(\" Points forts :\", analyse[\"points_forts\"])\n",
"print(\" Points faibles :\", analyse[\"points_faibles\"])"
]
},
{
"cell_type": "markdown",
"id": "cell-19",
"metadata": {},
"source": [
"### 3.2 Rechercher un joueur (4 pts)\n",
"\n",
"Écrivez une fonction `rechercher_joueur(effectif, nom)` qui renvoie le joueur correspondant au nom (ou None si non trouvé)."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-20",
"metadata": {},
"outputs": [],
"source": [
"def rechercher_joueur(effectif, nom):\n",
" for joueur in effectif:\n",
" if joueur[0] == nom:\n",
" return joueur\n",
" return None\n",
"\n",
"# Test\n",
"joueur = rechercher_joueur(effectif, \"Kante\")\n",
"if joueur:\n",
" afficher_joueur(joueur)"
]
},
{
"cell_type": "markdown",
"id": "cell-21",
"metadata": {},
"source": [
"### 3.3 Performance d'un joueur (5 pts)\n",
"\n",
"Écrivez une fonction `performance_buteur(nom, matchs)` qui renvoie le nombre de buts et la moyenne de buts par match pour un joueur donné."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cell-22",
"metadata": {},
"outputs": [],
"source": [
"def performance_buteur(nom, matchs):\n",
" nb_buts = 0\n",
" nb_matchs = len(matchs)\n",
" \n",
" for match in matchs:\n",
" buteurs = match[3]\n",
" for buteur in buteurs:\n",
" if buteur == nom:\n",
" nb_buts = nb_buts + 1\n",
" \n",
" moyenne = 0\n",
" if nb_matchs > 0:\n",
" moyenne = round(nb_buts / nb_matchs, 2)\n",
" \n",
" return {\n",
" \"buts\": nb_buts,\n",
" \"matchs\": nb_matchs,\n",
" \"moyenne\": moyenne\n",
" }\n",
"\n",
"# Test\n",
"perf = performance_buteur(\"Mbappe\", matchs)\n",
"print(\"Performance de Mbappe :\")\n",
"print(\" Buts :\", perf[\"buts\"])\n",
"print(\" Moyenne par match :\", perf[\"moyenne\"])"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"name": "python",
"version": "3.9.0"
}
},
"nbformat": 4,
"nbformat_minor": 5
}

201
representation_construits/evaluation/TP05_Football_aide.md Normal file
View File

@@ -0,0 +1,201 @@
# Aide - TP05 Football
## Rappels utiles
### Structure des tuples
```python
# Joueur = (nom, poste, note_globale, stats)
joueur = effectif[0]
nom = joueur[0] # "Mbappe"
poste = joueur[1] # "ATT"
note = joueur[2] # 91
stats = joueur[3] # {"vitesse": 97, "tir": 89, ...}
# Acces direct
vitesse = joueur[3]["vitesse"]
```
### Parcourir une liste de tuples
```python
for joueur in effectif:
nom = joueur[0]
poste = joueur[1]
note = joueur[2]
stats = joueur[3]
print(nom, "-", poste, "- Note:", note)
```
### Filtrer une liste de tuples
```python
attaquants = []
for j in effectif:
if j[1] == "ATT":
attaquants.append(j)
```
---
## Exercice 1
### 1.1 - Affichage joueur
- Verifiez si c'est un gardien (`poste == "GK"`) car les stats sont differentes
```python
def afficher_joueur(joueur):
nom = joueur[0]
poste = joueur[1]
note = joueur[2]
stats = joueur[3]
print(nom, "(", poste, ") - Note:", note)
if poste == "GK":
print(" Plongeon:", stats["plongeon"])
print(" Reflexes:", stats["reflexes"])
else:
print(" Vitesse:", stats["vitesse"])
print(" Tir:", stats["tir"])
```
### 1.2 - Filtrage par poste
```python
def joueurs_par_poste(eff, poste):
filtre = []
for j in eff:
if j[1] == poste:
filtre.append(j)
# Trier par note (indice 2) decroissante
filtre = sorted(filtre, key=lambda j: j[2], reverse=True)
return filtre
```
### 1.3 - Meilleur dans une stat
```python
def meilleur_stat(eff, stat):
meilleur = None
max_val = -1
for joueur in eff:
nom = joueur[0]
stats = joueur[3]
if stat in stats and stats[stat] > max_val:
max_val = stats[stat]
meilleur = nom
return (meilleur, max_val)
```
---
## Exercice 2
### 2.1 - Generer le XI
```python
def generer_xi(eff, formation):
xi = {}
for poste, nb_joueurs in formation.items():
# Recuperer les joueurs de ce poste, tries par note
candidats = joueurs_par_poste(eff, poste)
# Prendre les n meilleurs
xi[poste] = candidats[:nb_joueurs]
return xi
```
### 2.2 - Note moyenne ponderee
```python
def note_equipe(xi):
poids = {"ATT": 1.2, "MIL": 1.1, "DEF": 1.0, "GK": 0.9}
total_pondere = 0
total_poids = 0
for poste, joueurs in xi.items():
for j in joueurs:
note = j[2]
p = poids[poste]
total_pondere = total_pondere + note * p
total_poids = total_poids + p
return total_pondere / total_poids
```
### 2.3 - Equipe specialisee
```python
def score_priorite(joueur, priorite):
stats = joueur[3]
if priorite == "offensive":
return stats.get("tir", 0) + stats.get("dribble", 0)
elif priorite == "defensive":
return stats.get("defense", 0) + stats.get("physique", 0)
elif priorite == "technique":
return stats.get("passe", 0) + stats.get("dribble", 0)
return 0
```
---
## Exercice 3 (Bonus)
### 3.1 - Statistiques des matchs
```python
def stats_matchs(matchs):
victoires = 0
nuls = 0
defaites = 0
buts_pour = 0
buts_contre = 0
for match in matchs:
adversaire = match[0]
score_eq = match[1]
score_adv = match[2]
buteurs = match[3]
buts_pour = buts_pour + score_eq
buts_contre = buts_contre + score_adv
if score_eq > score_adv:
victoires = victoires + 1
elif score_eq == score_adv:
nuls = nuls + 1
else:
defaites = defaites + 1
return {
"victoires": victoires,
"nuls": nuls,
"defaites": defaites,
"buts_pour": buts_pour,
"buts_contre": buts_contre,
"difference": buts_pour - buts_contre,
"points": victoires * 3 + nuls
}
```
### 3.2 - Classement buteurs
```python
def classement_buteurs(matchs):
compteur = {}
for match in matchs:
buteurs = match[3]
for buteur in buteurs:
if buteur not in compteur:
compteur[buteur] = 0
compteur[buteur] = compteur[buteur] + 1
# sorted renvoie une liste de tuples triee
return sorted(compteur.items(), key=lambda x: x[1], reverse=True)
```
### 3.3 - Performance joueur
- Trouvez le joueur dans l'effectif pour ses stats
- Comptez ses buts dans les matchs
- Identifiez ses points forts (>= 85) et faibles (<= 60)
---
## Pieges a eviter
1. **Gardiens differents** : les GK n'ont pas les memes stats (pas de "vitesse", mais "plongeon", "reflexes"...)
2. **Tuples immutables** : vous ne pouvez pas modifier un tuple, creez-en un nouveau si besoin
3. **Division par zero** : verifiez que le diviseur est > 0
4. **Acces par indice** : joueur[0] = nom, joueur[1] = poste, joueur[2] = note, joueur[3] = stats

471
representation_construits/evaluation/TP06_Pokemon.ipynb Normal file
View File

@@ -0,0 +1,471 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# TP Évaluation - Pokédex\n",
"\n",
"**Durée : 1h30**\n",
"\n",
"**Nom :** \n",
"\n",
"**Prénom :**\n",
"\n",
"---\n",
"\n",
"Dans ce TP, vous allez créer un système de gestion de Pokédex.\n",
"\n",
"**Compétences évaluées :**\n",
"- Manipulation de tuples et listes\n",
"- Dictionnaires et structures imbriquées\n",
"- Algorithmes de filtrage et tri"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Données initiales\n",
"\n",
"**Exécutez cette cellule avant de commencer.**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Pokedex (liste de tuples)\n",
"# Chaque Pokemon : (nom, types, pv, attaque, defense, vitesse, evolution)\n",
"# types est un tuple de 1 ou 2 types\n",
"# evolution est None si pas d'evolution\n",
"\n",
"pokedex = [\n",
" (\"Bulbizarre\", (\"Plante\", \"Poison\"), 45, 49, 49, 45, \"Herbizarre\"),\n",
" (\"Herbizarre\", (\"Plante\", \"Poison\"), 60, 62, 63, 60, \"Florizarre\"),\n",
" (\"Florizarre\", (\"Plante\", \"Poison\"), 80, 82, 83, 80, None),\n",
" (\"Salameche\", (\"Feu\",), 39, 52, 43, 65, \"Reptincel\"),\n",
" (\"Reptincel\", (\"Feu\",), 58, 64, 58, 80, \"Dracaufeu\"),\n",
" (\"Dracaufeu\", (\"Feu\", \"Vol\"), 78, 84, 78, 100, None),\n",
" (\"Carapuce\", (\"Eau\",), 44, 48, 65, 43, \"Carabaffe\"),\n",
" (\"Carabaffe\", (\"Eau\",), 59, 63, 80, 58, \"Tortank\"),\n",
" (\"Tortank\", (\"Eau\",), 79, 83, 100, 78, None),\n",
" (\"Pikachu\", (\"Electrique\",), 35, 55, 40, 90, \"Raichu\"),\n",
" (\"Raichu\", (\"Electrique\",), 60, 90, 55, 110, None),\n",
" (\"Evoli\", (\"Normal\",), 55, 55, 50, 55, \"Multiple\"),\n",
" (\"Aquali\", (\"Eau\",), 130, 65, 60, 65, None),\n",
" (\"Voltali\", (\"Electrique\",), 65, 65, 60, 130, None),\n",
" (\"Pyroli\", (\"Feu\",), 65, 130, 60, 65, None),\n",
" (\"Mewtwo\", (\"Psy\",), 106, 110, 90, 130, None),\n",
" (\"Mew\", (\"Psy\",), 100, 100, 100, 100, None),\n",
" (\"Dracolosse\", (\"Dragon\", \"Vol\"), 91, 134, 95, 80, None),\n",
" (\"Leviator\", (\"Eau\", \"Vol\"), 95, 125, 79, 81, None),\n",
" (\"Lokhlass\", (\"Eau\", \"Glace\"), 130, 85, 80, 60, None)\n",
"]\n",
"\n",
"# Table des faiblesses (type_attaquant -> liste des types faibles)\n",
"faiblesses = {\n",
" \"Feu\": [\"Plante\", \"Glace\"],\n",
" \"Eau\": [\"Feu\", \"Sol\"],\n",
" \"Plante\": [\"Eau\", \"Sol\"],\n",
" \"Electrique\": [\"Eau\", \"Vol\"],\n",
" \"Glace\": [\"Dragon\", \"Vol\", \"Plante\"],\n",
" \"Psy\": [\"Poison\"],\n",
" \"Dragon\": [\"Dragon\"],\n",
" \"Vol\": [\"Plante\"]\n",
"}\n",
"\n",
"# Equipe du joueur (liste de noms)\n",
"mon_equipe = [\"Pikachu\", \"Dracaufeu\", \"Tortank\", \"Dracolosse\", \"Mewtwo\", \"Evoli\"]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 1 - Exploration du Pokédex (25 min)\n",
"\n",
"### 1.1 Affichage d'un Pokémon (4 pts)\n",
"\n",
"Écrivez une fonction `afficher_pokemon(pokemon)` qui affiche les infos d'un Pokémon.\n",
"\n",
"Exemple :\n",
"```\n",
"DRACAUFEU (Feu/Vol)\n",
"PV: 78 | ATK: 84 | DEF: 78 | VIT: 100\n",
"Evolution: Forme finale\n",
"```\n",
"\n",
"*Rappel : pokemon[0] = nom, pokemon[1] = types, pokemon[2] = pv, pokemon[3] = attaque, pokemon[4] = defense, pokemon[5] = vitesse, pokemon[6] = evolution*"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def afficher_pokemon(pokemon):\n",
" nom = pokemon[0]\n",
" types = pokemon[1]\n",
" pv = pokemon[2]\n",
" attaque = pokemon[3]\n",
" defense = pokemon[4]\n",
" vitesse = pokemon[5]\n",
" evolution = pokemon[6]\n",
" \n",
" # Afficher le nom et les types\n",
" # Votre code ici\n",
" pass\n",
" \n",
" # Afficher les stats\n",
" # Votre code ici\n",
" pass\n",
" \n",
" # Afficher l'evolution (\"Forme finale\" si None)\n",
" # Votre code ici\n",
" pass\n",
"\n",
"# Test\n",
"afficher_pokemon(pokedex[5]) # Dracaufeu"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1.2 Recherche par type (4 pts)\n",
"\n",
"Écrivez une fonction `pokemon_par_type(dex, type_recherche)` qui renvoie tous les Pokémon ayant ce type (principal ou secondaire), triés par PV décroissants.\n",
"\n",
"*Aide : utilisez `sorted(liste, key=lambda p: p[2], reverse=True)` pour trier par PV*"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def pokemon_par_type(dex, type_recherche):\n",
" resultats = []\n",
" \n",
" for pokemon in dex:\n",
" types = pokemon[1]\n",
" # Verifier si le type recherche est dans les types du pokemon\n",
" # Votre code ici\n",
" pass\n",
" \n",
" # Trier par PV (indice 2) decroissants\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return resultats\n",
"\n",
"# Test\n",
"print(\"Pokemon de type Eau :\")\n",
"for p in pokemon_par_type(pokedex, \"Eau\"):\n",
" print(\" \", p[0], \"-\", p[2], \"PV\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1.3 Compter les types (4 pts)\n",
"\n",
"Écrivez une fonction `compter_types(dex)` qui renvoie un dictionnaire `{type: nombre}` comptant combien de Pokémon ont chaque type."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def compter_types(dex):\n",
" compteur = {}\n",
" \n",
" for pokemon in dex:\n",
" types = pokemon[1]\n",
" for t in types:\n",
" # Ajouter le type au compteur\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return compteur\n",
"\n",
"# Test\n",
"print(\"Nombre de Pokemon par type :\")\n",
"types_compteur = compter_types(pokedex)\n",
"for t, nb in types_compteur.items():\n",
" print(\" \", t, \":\", nb)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 2 - Gestion d'équipe (35 min)\n",
"\n",
"### 2.1 Charger une équipe (5 pts)\n",
"\n",
"Écrivez une fonction `charger_equipe(noms, dex)` qui renvoie la liste des tuples Pokemon correspondant aux noms donnés.\n",
"\n",
"Si un nom n'existe pas dans le Pokédex, l'ignorer."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def charger_equipe(noms, dex):\n",
" equipe = []\n",
" \n",
" for nom_recherche in noms:\n",
" # Chercher le pokemon dans le pokedex\n",
" for pokemon in dex:\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return equipe\n",
"\n",
"# Test\n",
"equipe = charger_equipe(mon_equipe, pokedex)\n",
"print(\"Equipe chargee :\")\n",
"for p in equipe:\n",
" print(\" \", p[0])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2.2 Force totale de l'équipe (5 pts)\n",
"\n",
"Écrivez une fonction `force_equipe(equipe)` qui calcule la force totale de l'équipe.\n",
"\n",
"Force d'un Pokémon = PV + Attaque + Défense + Vitesse"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def force_equipe(equipe):\n",
" force_totale = 0\n",
" \n",
" for pokemon in equipe:\n",
" # Calculer la force du pokemon et l'ajouter au total\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return force_totale\n",
"\n",
"# Test\n",
"print(\"Force totale de l'equipe :\", force_equipe(equipe))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2.3 Pokémon le plus fort (5 pts)\n",
"\n",
"Écrivez une fonction `plus_fort(equipe)` qui renvoie le Pokémon ayant la meilleure attaque."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def plus_fort(equipe):\n",
" if len(equipe) == 0:\n",
" return None\n",
" \n",
" meilleur = equipe[0]\n",
" meilleure_attaque = equipe[0][3]\n",
" \n",
" for pokemon in equipe:\n",
" # Comparer l'attaque avec la meilleure\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return meilleur\n",
"\n",
"# Test\n",
"fort = plus_fort(equipe)\n",
"if fort:\n",
" print(\"Pokemon le plus fort :\", fort[0], \"avec\", fort[3], \"d'attaque\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2.4 Types couverts par l'équipe (6 pts)\n",
"\n",
"Écrivez une fonction `types_couverts(equipe)` qui renvoie la liste (sans doublons) de tous les types présents dans l'équipe."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def types_couverts(equipe):\n",
" types_liste = []\n",
" \n",
" for pokemon in equipe:\n",
" types = pokemon[1]\n",
" for t in types:\n",
" # Ajouter le type s'il n'est pas deja dans la liste\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return types_liste\n",
"\n",
"# Test\n",
"print(\"Types couverts par l'equipe :\", types_couverts(equipe))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 3 - Bonus (20 min)\n",
"\n",
"### 3.1 Chaîne d'évolution (5 pts)\n",
"\n",
"Écrivez une fonction `chaine_evolution(nom, dex)` qui renvoie la chaîne d'évolution complète d'un Pokémon.\n",
"\n",
"Exemple : `chaine_evolution(\"Bulbizarre\", pokedex)` → `[\"Bulbizarre\", \"Herbizarre\", \"Florizarre\"]`"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def chaine_evolution(nom, dex):\n",
" chaine = [nom]\n",
" \n",
" # Chercher le pokemon actuel\n",
" pokemon_actuel = None\n",
" for p in dex:\n",
" if p[0] == nom:\n",
" pokemon_actuel = p\n",
" break\n",
" \n",
" if pokemon_actuel == None:\n",
" return chaine\n",
" \n",
" # Suivre les evolutions\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return chaine\n",
"\n",
"# Tests\n",
"print(chaine_evolution(\"Bulbizarre\", pokedex))\n",
"print(chaine_evolution(\"Pikachu\", pokedex))\n",
"print(chaine_evolution(\"Mewtwo\", pokedex))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 3.2 Vérifier efficacité (5 pts)\n",
"\n",
"Écrivez une fonction `est_efficace(attaquant, defenseur, faiblesses)` qui renvoie `True` si l'attaquant a un type efficace contre le défenseur."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def est_efficace(attaquant, defenseur, faiblesses):\n",
" types_attaquant = attaquant[1]\n",
" types_defenseur = defenseur[1]\n",
" \n",
" # Pour chaque type de l'attaquant, verifier s'il est efficace\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return False\n",
"\n",
"# Tests\n",
"pikachu = pokedex[9]\n",
"tortank = pokedex[8]\n",
"dracaufeu = pokedex[5]\n",
"\n",
"print(\"Pikachu efficace contre Tortank ?\", est_efficace(pikachu, tortank, faiblesses))\n",
"print(\"Dracaufeu efficace contre Tortank ?\", est_efficace(dracaufeu, tortank, faiblesses))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 3.3 Meilleur contre un adversaire (4 pts)\n",
"\n",
"Écrivez une fonction `meilleur_contre(adversaire, equipe, faiblesses)` qui renvoie le Pokémon de l'équipe le plus efficace contre l'adversaire.\n",
"\n",
"S'il n'y a pas de Pokémon efficace, renvoyer le plus fort en attaque."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def meilleur_contre(adversaire, equipe, faiblesses):\n",
" # D'abord chercher un pokemon efficace\n",
" # Votre code ici\n",
" pass\n",
" \n",
" # Sinon renvoyer le plus fort en attaque\n",
" return plus_fort(equipe)\n",
"\n",
"# Test\n",
"leviator = pokedex[18]\n",
"choix = meilleur_contre(leviator, equipe, faiblesses)\n",
"if choix:\n",
" print(\"Meilleur choix contre Leviator :\", choix[0])"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"name": "python",
"version": "3.9.0"
}
},
"nbformat": 4,
"nbformat_minor": 4
}

214
representation_construits/evaluation/TP06_Pokemon_aide.md Normal file
View File

@@ -0,0 +1,214 @@
# Aide - TP06 Pokemon
## Rappels utiles
### Structure des tuples Pokemon
```python
# Pokemon = (nom, types, pv, attaque, defense, vitesse, evolution)
pokemon = pokedex[0]
nom = pokemon[0] # "Bulbizarre"
types = pokemon[1] # ("Plante", "Poison")
pv = pokemon[2] # 45
attaque = pokemon[3] # 49
defense = pokemon[4] # 49
vitesse = pokemon[5] # 45
evolution = pokemon[6] # "Herbizarre"
```
### Types multiples
```python
pokemon = pokedex[5] # Dracaufeu
# types est un tuple : ("Feu", "Vol")
print(pokemon[1][0]) # "Feu" (type principal)
if "Feu" in pokemon[1]:
print("C'est un type Feu")
```
---
## Exercice 1
### 1.1 - Affichage Pokemon
```python
def afficher_pokemon(pokemon):
nom = pokemon[0]
types = pokemon[1]
pv = pokemon[2]
attaque = pokemon[3]
defense = pokemon[4]
vitesse = pokemon[5]
evolution = pokemon[6]
# Afficher les types
if len(types) == 2:
types_str = types[0] + "/" + types[1]
else:
types_str = types[0]
print(nom, "(", types_str, ")")
print("PV:", pv, "| ATK:", attaque, "| DEF:", defense, "| VIT:", vitesse)
if evolution == None:
print("Evolution: Forme finale")
else:
print("Evolution:", evolution)
```
### 1.2 - Recherche par type
```python
def pokemon_par_type(dex, type_recherche):
resultat = []
for p in dex:
if type_recherche in p[1]: # p[1] = types
resultat.append(p)
# Trier par PV (indice 2) decroissants
resultat = sorted(resultat, key=lambda p: p[2], reverse=True)
return resultat
```
### 1.3 - Compter les types
```python
def compter_types(dex):
compteur = {}
for pokemon in dex:
types = pokemon[1]
for t in types:
if t not in compteur:
compteur[t] = 0
compteur[t] = compteur[t] + 1
return compteur
```
---
## Exercice 2
### 2.1 - Charger equipe
```python
def charger_equipe(noms, dex):
equipe = []
for nom_recherche in noms:
# Chercher le pokemon dans le pokedex
for pokemon in dex:
if pokemon[0] == nom_recherche:
equipe.append(pokemon)
break
return equipe
```
### 2.2 - Force de l'equipe
```python
def force_equipe(equipe):
force_totale = 0
for pokemon in equipe:
pv = pokemon[2]
attaque = pokemon[3]
defense = pokemon[4]
vitesse = pokemon[5]
force_pokemon = pv + attaque + defense + vitesse
force_totale = force_totale + force_pokemon
return force_totale
```
### 2.3 - Pokemon le plus fort
```python
def plus_fort(equipe):
if len(equipe) == 0:
return None
meilleur = equipe[0]
meilleure_attaque = equipe[0][3] # indice 3 = attaque
for pokemon in equipe:
if pokemon[3] > meilleure_attaque:
meilleur = pokemon
meilleure_attaque = pokemon[3]
return meilleur
```
### 2.4 - Types couverts
```python
def types_couverts(equipe):
types_liste = []
for pokemon in equipe:
types = pokemon[1]
for t in types:
if t not in types_liste:
types_liste.append(t)
return types_liste
```
---
## Exercice 3 (Bonus)
### 3.1 - Chaine d'evolution
```python
def chaine_evolution(nom, dex):
chaine = [nom]
# Chercher le pokemon actuel
pokemon_actuel = None
for p in dex:
if p[0] == nom:
pokemon_actuel = p
break
if pokemon_actuel == None:
return chaine
# Suivre les evolutions
evolution = pokemon_actuel[6]
while evolution != None and evolution != "Multiple":
chaine.append(evolution)
# Chercher le pokemon suivant
for p in dex:
if p[0] == evolution:
evolution = p[6]
break
return chaine
```
### 3.2 - Verifier efficacite
```python
def est_efficace(attaquant, defenseur, faiblesses):
types_attaquant = attaquant[1]
types_defenseur = defenseur[1]
# Pour chaque type de l'attaquant
for type_att in types_attaquant:
# Verifier si ce type est efficace
if type_att in faiblesses:
types_faibles = faiblesses[type_att]
# Verifier si le defenseur a un type faible
for type_def in types_defenseur:
if type_def in types_faibles:
return True
return False
```
### 3.3 - Meilleur contre un adversaire
```python
def meilleur_contre(adversaire, equipe, faiblesses):
# D'abord chercher un pokemon efficace
for pokemon in equipe:
if est_efficace(pokemon, adversaire, faiblesses):
return pokemon
# Sinon renvoyer le plus fort en attaque
return plus_fort(equipe)
```
---
## Pieges a eviter
1. **Types en tuple** : meme un seul type est un tuple `("Feu",)` - notez la virgule !
2. **Tuples immutables** : vous ne pouvez pas modifier `pokemon[2] = 50`
3. **Faiblesses unidirectionnelles** : Feu bat Plante, mais Plante ne bat pas Feu
4. **PV negatifs** : verifiez `pv > 0` et non `pv >= 0`
5. **Acces par indice** : pokemon[0]=nom, pokemon[1]=types, pokemon[2]=pv, pokemon[3]=attaque, pokemon[4]=defense, pokemon[5]=vitesse, pokemon[6]=evolution

268
representation_construits/evaluation/TP07_Manga.ipynb Normal file
View File

@@ -0,0 +1,268 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# TP Évaluation - Collection Manga\n",
"\n",
"**Durée : 1h30**\n",
"\n",
"**Nom :** \n",
"\n",
"**Prénom :**\n",
"\n",
"---\n",
"\n",
"Dans ce TP, vous allez gérer une collection de mangas.\n",
"\n",
"**Compétences évaluées :**\n",
"- Listes de dictionnaires\n",
"- Algorithmes de filtrage et tri\n",
"- Manipulation de données"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Données initiales\n",
"\n",
"**Exécutez cette cellule avant de commencer.**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Collection de mangas\n",
"# Chaque manga est un dictionnaire\n",
"mangas = [\n",
" {\"titre\": \"One Piece\", \"auteur\": \"Eiichiro Oda\", \"genres\": [\"Aventure\", \"Action\"], \"tomes\": 107, \"termine\": False, \"note\": 9.2},\n",
" {\"titre\": \"Naruto\", \"auteur\": \"Masashi Kishimoto\", \"genres\": [\"Action\", \"Aventure\"], \"tomes\": 72, \"termine\": True, \"note\": 8.5},\n",
" {\"titre\": \"Death Note\", \"auteur\": \"Tsugumi Ohba\", \"genres\": [\"Thriller\", \"Psychologique\"], \"tomes\": 12, \"termine\": True, \"note\": 9.0},\n",
" {\"titre\": \"Attack on Titan\", \"auteur\": \"Hajime Isayama\", \"genres\": [\"Action\", \"Drame\"], \"tomes\": 34, \"termine\": True, \"note\": 9.1},\n",
" {\"titre\": \"My Hero Academia\", \"auteur\": \"Kohei Horikoshi\", \"genres\": [\"Action\", \"Super-heros\"], \"tomes\": 40, \"termine\": False, \"note\": 8.3},\n",
" {\"titre\": \"Demon Slayer\", \"auteur\": \"Koyoharu Gotouge\", \"genres\": [\"Action\", \"Surnaturel\"], \"tomes\": 23, \"termine\": True, \"note\": 8.7},\n",
" {\"titre\": \"Jujutsu Kaisen\", \"auteur\": \"Gege Akutami\", \"genres\": [\"Action\", \"Surnaturel\"], \"tomes\": 25, \"termine\": False, \"note\": 8.8},\n",
" {\"titre\": \"Chainsaw Man\", \"auteur\": \"Tatsuki Fujimoto\", \"genres\": [\"Action\", \"Horreur\"], \"tomes\": 16, \"termine\": False, \"note\": 8.9},\n",
" {\"titre\": \"Spy x Family\", \"auteur\": \"Tatsuya Endo\", \"genres\": [\"Action\", \"Comedie\"], \"tomes\": 12, \"termine\": False, \"note\": 8.6},\n",
" {\"titre\": \"Dragon Ball\", \"auteur\": \"Akira Toriyama\", \"genres\": [\"Action\", \"Aventure\"], \"tomes\": 42, \"termine\": True, \"note\": 8.8},\n",
" {\"titre\": \"Fullmetal Alchemist\", \"auteur\": \"Hiromu Arakawa\", \"genres\": [\"Action\", \"Aventure\", \"Fantasy\"], \"tomes\": 27, \"termine\": True, \"note\": 9.3},\n",
" {\"titre\": \"Tokyo Ghoul\", \"auteur\": \"Sui Ishida\", \"genres\": [\"Action\", \"Horreur\"], \"tomes\": 14, \"termine\": True, \"note\": 8.4}\n",
"]\n",
"\n",
"# Ma collection personnelle (tomes possedes par manga)\n",
"ma_collection = {\n",
" \"Death Note\": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],\n",
" \"One Piece\": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],\n",
" \"Demon Slayer\": [1, 2, 3, 4, 5],\n",
" \"Spy x Family\": [1, 2, 3, 4]\n",
"}\n",
"\n",
"# Liste de souhaits\n",
"liste_souhaits = [\"Chainsaw Man\", \"Jujutsu Kaisen\", \"Fullmetal Alchemist\"]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 1 - Exploration du catalogue (25 min)\n",
"\n",
"### 1.1 Affichage d'un manga (4 pts)\n",
"\n",
"Écrivez une fonction `afficher_manga(manga)` qui affiche les informations d'un manga.\n",
"\n",
"Exemple :\n",
"```\n",
"Death Note - Tsugumi Ohba\n",
"Genres : Thriller, Psychologique\n",
"12 tomes (Termine) | Note : 9.0\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": "def afficher_manga(manga):\n titre = manga[\"titre\"]\n auteur = manga[\"auteur\"]\n genres = manga[\"genres\"]\n tomes = manga[\"tomes\"]\n termine = manga[\"termine\"]\n note = manga[\"note\"]\n \n # Afficher : titre - auteur\n # Votre code ici\n pass\n \n # Afficher les genres séparés par des virgules\n # Votre code ici\n pass\n \n # Afficher le statut : \"Termine\" ou \"En cours\"\n # Votre code ici\n pass\n\n# Tests\nafficher_manga(mangas[2]) # Death Note\nprint()\nafficher_manga(mangas[0]) # One Piece"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1.2 Recherche par genre (4 pts)\n",
"\n",
"Écrivez une fonction `rechercher_par_genre(mangas, genre)` qui renvoie la liste des mangas contenant ce genre."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": "def rechercher_par_genre(mangas, genre):\n resultats = []\n \n for manga in mangas:\n # Votre code ici\n pass\n \n return resultats\n\n# Test\nprint(\"Mangas d'Horreur :\")\nfor m in rechercher_par_genre(mangas, \"Horreur\"):\n print(\" \", m[\"titre\"])"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1.3 Mangas terminés (4 pts)\n",
"\n",
"Écrivez une fonction `mangas_termines(mangas)` qui renvoie la liste des mangas terminés, triés par note décroissante."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": "def mangas_termines(mangas):\n termines = []\n \n for manga in mangas:\n # Votre code ici\n pass\n \n # Trier par note decroissante\n # Votre code ici\n pass\n \n return termines\n\n# Test\nprint(\"Mangas termines (par note) :\")\nfor m in mangas_termines(mangas):\n print(\" \", m[\"titre\"], \"-\", m[\"note\"])"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 2 - Gestion de collection (35 min)\n",
"\n",
"### 2.1 Avancement de lecture (6 pts)\n",
"\n",
"Écrivez une fonction `avancement_collection(ma_coll, mangas)` qui calcule l'avancement pour chaque manga possédé.\n",
"\n",
"Renvoie une liste de dictionnaires avec `titre`, `possede`, `total`, `pourcentage`, `complet` (booléen)."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": "def avancement_collection(ma_coll, mangas):\n avancement = []\n \n for titre, tomes_possedes in ma_coll.items():\n # Trouver le manga dans le catalogue\n total_tomes = 0\n for manga in mangas:\n # Votre code ici\n pass\n \n nb_possedes = len(tomes_possedes)\n \n # Calculer le pourcentage (arrondi)\n # Votre code ici\n pourcentage = 0\n \n # Determiner si la collection est complete\n # Votre code ici\n complet = False\n \n avancement.append({\n \"titre\": titre,\n \"possede\": nb_possedes,\n \"total\": total_tomes,\n \"pourcentage\": pourcentage,\n \"complet\": complet\n })\n \n return avancement\n\n# Test\nprint(\"Avancement de ma collection :\")\nfor item in avancement_collection(ma_collection, mangas):\n statut = \"Complet\" if item[\"complet\"] else str(item[\"pourcentage\"]) + \"%\"\n print(\" \", item[\"titre\"], \":\", item[\"possede\"], \"/\", item[\"total\"], \"(\", statut, \")\")"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2.2 Tomes manquants (5 pts)\n",
"\n",
"Écrivez une fonction `tomes_manquants(titre, ma_coll, mangas)` qui renvoie la liste des numéros de tomes manquants pour un manga donné."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": "def tomes_manquants(titre, ma_coll, mangas):\n # Trouver le nombre total de tomes\n total_tomes = 0\n for manga in mangas:\n # Votre code ici\n pass\n \n # Recuperer les tomes possedes\n if titre in ma_coll:\n possedes = ma_coll[titre]\n else:\n possedes = []\n \n # Trouver les manquants\n manquants = []\n for i in range(1, total_tomes + 1):\n # Votre code ici\n pass\n \n return manquants\n\n# Test\nmanq = tomes_manquants(\"One Piece\", ma_collection, mangas)\nprint(\"Tomes manquants de One Piece :\", len(manq), \"tomes\")\nprint(\"Premiers manquants :\", manq[:10])"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2.3 Valeur de la collection (5 pts)\n",
"\n",
"Écrivez une fonction `valeur_collection(ma_coll, prix_par_tome)` qui calcule la valeur totale de la collection.\n",
"\n",
"Renvoie un dictionnaire avec `nb_tomes` et `valeur_totale`."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": "def valeur_collection(ma_coll, prix_par_tome):\n nb_tomes = 0\n \n for titre, tomes in ma_coll.items():\n # Votre code ici\n pass\n \n # Calculer la valeur totale\n # Votre code ici\n valeur = 0\n \n return {\n \"nb_tomes\": nb_tomes,\n \"valeur_totale\": valeur\n }\n\n# Test (7 euros par tome)\nval = valeur_collection(ma_collection, 7)\nprint(\"Ma collection :\", val[\"nb_tomes\"], \"tomes\")\nprint(\"Valeur estimee :\", val[\"valeur_totale\"], \"euros\")"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2.4 Note moyenne des mangas possédés (5 pts)\n",
"\n",
"Écrivez une fonction `note_moyenne_collection(ma_coll, mangas)` qui calcule la note moyenne des mangas de la collection."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": "def note_moyenne_collection(ma_coll, mangas):\n total_notes = 0\n nb_mangas = 0\n \n for titre in ma_coll.keys():\n # Trouver le manga dans le catalogue\n for manga in mangas:\n # Votre code ici\n pass\n \n if nb_mangas == 0:\n return 0\n \n return round(total_notes / nb_mangas, 2)\n\n# Test\nprint(\"Note moyenne de ma collection :\", note_moyenne_collection(ma_collection, mangas))"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 3 - Bonus (20 min)\n",
"\n",
"### 3.1 Recommandation (5 pts)\n",
"\n",
"Écrivez une fonction `recommander(ma_coll, mangas)` qui recommande un manga non possédé basé sur les genres de la collection.\n",
"\n",
"Score = nombre de genres en commun + note du manga"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": "def recommander(ma_coll, mangas):\n # Collecter les genres de ma collection\n mes_genres = []\n for titre in ma_coll.keys():\n for manga in mangas:\n if manga[\"titre\"] == titre:\n for g in manga[\"genres\"]:\n if g not in mes_genres:\n mes_genres.append(g)\n \n # Chercher le meilleur manga non possede\n meilleur = None\n meilleur_score = 0\n \n for manga in mangas:\n if manga[\"titre\"] not in ma_coll:\n # Compter les genres en commun\n genres_communs = 0\n for g in manga[\"genres\"]:\n # Votre code ici\n pass\n \n score = genres_communs + manga[\"note\"]\n \n # Votre code ici : mettre a jour meilleur si score est superieur\n pass\n \n return meilleur\n\n# Test\nreco = recommander(ma_collection, mangas)\nif reco:\n print(\"Recommandation :\")\n afficher_manga(reco)"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 3.2 Liste des auteurs (4 pts)\n",
"\n",
"Écrivez une fonction `auteurs_uniques(mangas)` qui renvoie la liste des auteurs (sans doublons), triée par ordre alphabétique."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": "def auteurs_uniques(mangas):\n auteurs = []\n \n for manga in mangas:\n # Votre code ici : ajouter l'auteur s'il n'est pas deja dans la liste\n pass\n \n auteurs.sort()\n return auteurs\n\n# Test\nprint(\"Auteurs :\", auteurs_uniques(mangas))"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 3.3 Statistiques par genre (5 pts)\n",
"\n",
"Écrivez une fonction `stats_par_genre(mangas)` qui renvoie un dictionnaire avec pour chaque genre : le nombre de mangas et la note moyenne."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": "def stats_par_genre(mangas):\n # Collecter les donnees par genre\n donnees = {}\n \n for manga in mangas:\n for genre in manga[\"genres\"]:\n if genre not in donnees:\n donnees[genre] = {\"nb\": 0, \"total_notes\": 0}\n # Votre code ici : incrementer nb et ajouter la note\n pass\n \n # Calculer les moyennes\n stats = {}\n for genre, data in donnees.items():\n # Votre code ici : calculer la moyenne et remplir stats\n pass\n \n return stats\n\n# Test\nprint(\"Statistiques par genre :\")\nfor genre, data in stats_par_genre(mangas).items():\n print(\" \", genre, \":\", data[\"nombre\"], \"mangas, note moyenne\", data[\"note_moyenne\"])"
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"name": "python",
"version": "3.9.0"
}
},
"nbformat": 4,
"nbformat_minor": 4
}

264
representation_construits/evaluation/TP07_Manga_aide.md Normal file
View File

@@ -0,0 +1,264 @@
# Aide - TP07 Manga
## Rappels utiles
### Structure des mangas (dictionnaires)
```python
# Chaque manga est un dictionnaire
manga = mangas[0]
print(manga["titre"]) # "One Piece"
print(manga["auteur"]) # "Eiichiro Oda"
print(manga["genres"]) # ["Aventure", "Action"]
print(manga["tomes"]) # 107
print(manga["termine"]) # False
print(manga["note"]) # 9.2
```
### Collection personnelle (dictionnaire)
```python
# ma_collection = {titre: [liste des tomes possedes]}
ma_collection = {
"Death Note": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
"One Piece": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
}
# Acceder aux tomes d'un manga
tomes_possedes = ma_collection["Death Note"]
print(len(tomes_possedes)) # 12
```
### Parcourir la collection
```python
for titre, tomes_possedes in ma_collection.items():
print(titre, ":", len(tomes_possedes), "tomes")
```
---
## Exercice 1
### 1.1 - Affichage d'un manga
```python
def afficher_manga(manga):
titre = manga["titre"]
auteur = manga["auteur"]
genres = manga["genres"]
tomes = manga["tomes"]
termine = manga["termine"]
note = manga["note"]
print(titre, "-", auteur)
# Afficher les genres
genres_str = ", ".join(genres)
print("Genres:", genres_str)
# Afficher le statut
if termine:
statut = "Termine"
else:
statut = "En cours"
print(tomes, "tomes (", statut, ") | Note:", note)
```
### 1.2 - Recherche par genre
```python
def rechercher_par_genre(mangas, genre):
resultats = []
for manga in mangas:
if genre in manga["genres"]:
resultats.append(manga)
return resultats
```
### 1.3 - Mangas termines
```python
def mangas_termines(mangas):
termines = []
for manga in mangas:
if manga["termine"] == True:
termines.append(manga)
# Trier par note decroissante
termines = sorted(termines, key=lambda m: m["note"], reverse=True)
return termines
```
---
## Exercice 2
### 2.1 - Avancement de lecture
```python
def avancement_collection(ma_coll, mangas):
avancement = []
for titre, tomes_possedes in ma_coll.items():
# Trouver le manga dans le catalogue
total_tomes = 0
for manga in mangas:
if manga["titre"] == titre:
total_tomes = manga["tomes"]
break
nb_possedes = len(tomes_possedes)
if total_tomes > 0:
pourcentage = round(nb_possedes / total_tomes * 100)
else:
pourcentage = 0
complet = (nb_possedes == total_tomes)
avancement.append({
"titre": titre,
"possede": nb_possedes,
"total": total_tomes,
"pourcentage": pourcentage,
"complet": complet
})
return avancement
```
### 2.2 - Tomes manquants
```python
def tomes_manquants(titre, ma_coll, mangas):
# Trouver le nombre total de tomes
total_tomes = 0
for manga in mangas:
if manga["titre"] == titre:
total_tomes = manga["tomes"]
break
# Recuperer les tomes possedes
if titre in ma_coll:
possedes = ma_coll[titre]
else:
possedes = []
# Trouver les manquants
manquants = []
for i in range(1, total_tomes + 1):
if i not in possedes:
manquants.append(i)
return manquants
```
### 2.3 - Valeur de la collection
```python
def valeur_collection(ma_coll, prix_par_tome):
nb_tomes = 0
for titre, tomes in ma_coll.items():
nb_tomes = nb_tomes + len(tomes)
valeur = nb_tomes * prix_par_tome
return {
"nb_tomes": nb_tomes,
"valeur_totale": valeur
}
```
### 2.4 - Note moyenne des mangas possedes
```python
def note_moyenne_collection(ma_coll, mangas):
total_notes = 0
nb_mangas = 0
for titre in ma_coll.keys():
# Trouver le manga dans le catalogue
for manga in mangas:
if manga["titre"] == titre:
total_notes = total_notes + manga["note"]
nb_mangas = nb_mangas + 1
break
if nb_mangas == 0:
return 0
return round(total_notes / nb_mangas, 2)
```
---
## Exercice 3 (Bonus)
### 3.1 - Recommandation
```python
def recommander(ma_coll, mangas):
# Collecter les genres de ma collection
mes_genres = []
for titre in ma_coll.keys():
for manga in mangas:
if manga["titre"] == titre:
for g in manga["genres"]:
if g not in mes_genres:
mes_genres.append(g)
# Chercher le meilleur manga non possede
meilleur = None
meilleur_score = 0
for manga in mangas:
if manga["titre"] not in ma_coll:
# Compter les genres en commun
genres_communs = 0
for g in manga["genres"]:
if g in mes_genres:
genres_communs = genres_communs + 1
score = genres_communs + manga["note"]
if score > meilleur_score:
meilleur = manga
meilleur_score = score
return meilleur
```
### 3.2 - Auteurs uniques
```python
def auteurs_uniques(mangas):
auteurs = []
for manga in mangas:
auteur = manga["auteur"]
if auteur not in auteurs:
auteurs.append(auteur)
auteurs.sort()
return auteurs
```
### 3.3 - Statistiques par genre
```python
def stats_par_genre(mangas):
# Collecter les donnees par genre
donnees = {}
for manga in mangas:
for genre in manga["genres"]:
if genre not in donnees:
donnees[genre] = {"nb": 0, "total_notes": 0}
donnees[genre]["nb"] = donnees[genre]["nb"] + 1
donnees[genre]["total_notes"] = donnees[genre]["total_notes"] + manga["note"]
# Calculer les moyennes
stats = {}
for genre, data in donnees.items():
moyenne = round(data["total_notes"] / data["nb"], 2)
stats[genre] = {"nombre": data["nb"], "note_moyenne": moyenne}
return stats
```
---
## Pieges a eviter
1. **Genres en liste** : les genres sont une liste `["Action", "Aventure"]`, utilisez `in` pour verifier
2. **Collection vs catalogue** : `ma_collection` contient les titres possedes, `mangas` contient les infos completes
3. **Division par zero** : verifiez que le diviseur est > 0 avant de calculer une moyenne
4. **Tomes manquants** : n'oubliez pas que les tomes sont numerotes de 1 a total_tomes

518
representation_construits/evaluation/TP08_McDonalds.ipynb Normal file
View File

@@ -0,0 +1,518 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# TP Évaluation - Système de commande McDonald's\n",
"\n",
"**Durée : 1h30**\n",
"\n",
"**Nom :** \n",
"\n",
"**Prénom :**\n",
"\n",
"---\n",
"\n",
"Dans ce TP, vous allez créer un système de gestion de commandes pour un fast-food.\n",
"\n",
"**Compétences évaluées :**\n",
"- Manipulation de dictionnaires imbriqués\n",
"- Calculs sur des structures de données\n",
"- Algorithmes de traitement de commandes"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Données initiales\n",
"\n",
"**Exécutez cette cellule avant de commencer.**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Menu du restaurant\n",
"menu = {\n",
" \"burgers\": {\n",
" \"Big Mac\": {\"prix\": 5.50, \"calories\": 540},\n",
" \"McChicken\": {\"prix\": 4.90, \"calories\": 400},\n",
" \"Royal Deluxe\": {\"prix\": 6.20, \"calories\": 580},\n",
" \"Double Cheese\": {\"prix\": 4.50, \"calories\": 450},\n",
" \"Filet-O-Fish\": {\"prix\": 4.80, \"calories\": 380},\n",
" \"McFirst\": {\"prix\": 2.50, \"calories\": 260}\n",
" },\n",
" \"accompagnements\": {\n",
" \"Frites (P)\": {\"prix\": 2.00, \"calories\": 230},\n",
" \"Frites (M)\": {\"prix\": 2.50, \"calories\": 340},\n",
" \"Frites (G)\": {\"prix\": 3.00, \"calories\": 450},\n",
" \"Potatoes\": {\"prix\": 3.20, \"calories\": 290},\n",
" \"Salade\": {\"prix\": 3.50, \"calories\": 80},\n",
" \"Nuggets x6\": {\"prix\": 4.50, \"calories\": 260},\n",
" \"Nuggets x9\": {\"prix\": 5.90, \"calories\": 390}\n",
" },\n",
" \"boissons\": {\n",
" \"Coca-Cola (M)\": {\"prix\": 2.50, \"calories\": 140},\n",
" \"Coca-Cola (G)\": {\"prix\": 3.00, \"calories\": 200},\n",
" \"Sprite (M)\": {\"prix\": 2.50, \"calories\": 130},\n",
" \"Eau\": {\"prix\": 1.50, \"calories\": 0},\n",
" \"Cafe\": {\"prix\": 1.80, \"calories\": 5}\n",
" },\n",
" \"desserts\": {\n",
" \"Sundae Caramel\": {\"prix\": 2.80, \"calories\": 340},\n",
" \"Sundae Chocolat\": {\"prix\": 2.80, \"calories\": 350},\n",
" \"McFlurry Oreo\": {\"prix\": 3.50, \"calories\": 380},\n",
" \"Cookie\": {\"prix\": 1.50, \"calories\": 180}\n",
" }\n",
"}\n",
"\n",
"# Menus Best-Of (formules)\n",
"menus_bestof = {\n",
" \"Best-Of Big Mac\": {\"burger\": \"Big Mac\", \"frites\": \"Frites (M)\", \"boisson\": \"Coca-Cola (M)\", \"prix\": 8.90},\n",
" \"Best-Of McChicken\": {\"burger\": \"McChicken\", \"frites\": \"Frites (M)\", \"boisson\": \"Coca-Cola (M)\", \"prix\": 8.50},\n",
" \"Best-Of Royal\": {\"burger\": \"Royal Deluxe\", \"frites\": \"Frites (M)\", \"boisson\": \"Coca-Cola (M)\", \"prix\": 9.50}\n",
"}\n",
"\n",
"# File de commandes en cours\n",
"# Chaque commande : {\"id\": numero, \"items\": [(article, quantite), ...], \"heure\": \"HH:MM\"}\n",
"commandes_en_cours = [\n",
" {\"id\": 101, \"items\": [(\"Big Mac\", 2), (\"Frites (G)\", 2), (\"Coca-Cola (G)\", 2)], \"heure\": \"12:05\"},\n",
" {\"id\": 102, \"items\": [(\"Best-Of McChicken\", 1), (\"McFlurry Oreo\", 1)], \"heure\": \"12:07\"},\n",
" {\"id\": 103, \"items\": [(\"Nuggets x9\", 2), (\"Frites (M)\", 2), (\"Sprite (M)\", 2)], \"heure\": \"12:08\"},\n",
" {\"id\": 104, \"items\": [(\"Best-Of Royal\", 1), (\"Salade\", 1), (\"Eau\", 1)], \"heure\": \"12:10\"},\n",
" {\"id\": 105, \"items\": [(\"Double Cheese\", 3), (\"Frites (G)\", 3), (\"Sundae Chocolat\", 3)], \"heure\": \"12:12\"}\n",
"]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 1 - Exploration du menu (25 min)\n",
"\n",
"### 1.1 Affichage d'une catégorie (4 pts)\n",
"\n",
"Écrivez une fonction `afficher_categorie(menu, categorie)` qui affiche les articles d'une catégorie.\n",
"\n",
"Exemple :\n",
"```\n",
"=== BURGERS ===\n",
"Big Mac : 5.50 euros (540 cal)\n",
"McChicken : 4.90 euros (400 cal)\n",
"...\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def afficher_categorie(menu, categorie):\n",
" if categorie not in menu:\n",
" print(\"Categorie inconnue\")\n",
" return\n",
" \n",
" print(\"===\", categorie.upper(), \"===\")\n",
" \n",
" articles = menu[categorie]\n",
" for nom, infos in articles.items():\n",
" # Votre code ici : afficher le nom, prix et calories\n",
" pass\n",
"\n",
"# Test\n",
"afficher_categorie(menu, \"burgers\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1.2 Rechercher un article (4 pts)\n",
"\n",
"Écrivez une fonction `rechercher_article(menu, nom)` qui cherche un article par son nom.\n",
"\n",
"Renvoie un dictionnaire `{\"nom\": ..., \"categorie\": ..., \"prix\": ..., \"calories\": ...}` ou `None` si non trouvé."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def rechercher_article(menu, nom):\n",
" for categorie, articles in menu.items():\n",
" if nom in articles:\n",
" infos = articles[nom]\n",
" # Votre code ici : renvoyer le dictionnaire avec nom, categorie, prix, calories\n",
" pass\n",
" return None\n",
"\n",
"# Tests\n",
"article = rechercher_article(menu, \"Big Mac\")\n",
"if article:\n",
" print(article[\"nom\"], \"trouve dans\", article[\"categorie\"])\n",
" print(\"Prix :\", article[\"prix\"], \"euros\")\n",
"\n",
"print()\n",
"print(\"Pizza :\", rechercher_article(menu, \"Pizza\"))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1.3 Article le moins calorique (4 pts)\n",
"\n",
"Écrivez une fonction `moins_calorique(menu, categorie)` qui renvoie l'article le moins calorique d'une catégorie.\n",
"\n",
"Si `categorie` est `None`, chercher dans tout le menu.\n",
"\n",
"Renvoie un tuple `(nom, calories)`."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def moins_calorique(menu, categorie):\n",
" meilleur_nom = None\n",
" meilleur_cal = 99999\n",
" \n",
" if categorie != None:\n",
" # Chercher dans une seule categorie\n",
" articles = menu[categorie]\n",
" for nom, infos in articles.items():\n",
" # Votre code ici\n",
" pass\n",
" else:\n",
" # Chercher dans tout le menu\n",
" for cat, articles in menu.items():\n",
" for nom, infos in articles.items():\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return (meilleur_nom, meilleur_cal)\n",
"\n",
"# Tests\n",
"print(\"Moins calorique (burgers) :\", moins_calorique(menu, \"burgers\"))\n",
"print(\"Moins calorique (tout) :\", moins_calorique(menu, None))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 2 - Gestion des commandes (35 min)\n",
"\n",
"### 2.1 Calculer le prix d'une commande (6 pts)\n",
"\n",
"Écrivez une fonction `calculer_prix(commande, menu, menus_bestof)` qui calcule le prix total d'une commande.\n",
"\n",
"Attention : les articles peuvent être des Best-Of ou des articles individuels.\n",
"\n",
"*Aide : utilisez `rechercher_article()` pour trouver le prix d'un article dans le menu.*"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def calculer_prix(commande, menu, menus_bestof):\n",
" total = 0\n",
" \n",
" for item in commande[\"items\"]:\n",
" nom_article = item[0]\n",
" quantite = item[1]\n",
" \n",
" # Verifier si c'est un Best-Of\n",
" if nom_article in menus_bestof:\n",
" # Votre code ici : ajouter le prix du Best-Of * quantite\n",
" pass\n",
" else:\n",
" # Chercher dans le menu normal avec rechercher_article\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return round(total, 2)\n",
"\n",
"# Test\n",
"for cmd in commandes_en_cours:\n",
" prix = calculer_prix(cmd, menu, menus_bestof)\n",
" print(\"Commande\", cmd[\"id\"], \":\", prix, \"euros\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2.2 Calculer les calories d'une commande (5 pts)\n",
"\n",
"Écrivez une fonction `calculer_calories(commande, menu, menus_bestof)` qui calcule le total des calories.\n",
"\n",
"Pour un Best-Of, additionner les calories du burger, des frites et de la boisson."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def calculer_calories(commande, menu, menus_bestof):\n",
" total_cal = 0\n",
" \n",
" for item in commande[\"items\"]:\n",
" nom_article = item[0]\n",
" quantite = item[1]\n",
" \n",
" # Verifier si c'est un Best-Of\n",
" if nom_article in menus_bestof:\n",
" bestof = menus_bestof[nom_article]\n",
" # Votre code ici : additionner les calories du burger, frites et boisson\n",
" pass\n",
" else:\n",
" # Chercher dans le menu normal\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return total_cal\n",
"\n",
"# Test\n",
"for cmd in commandes_en_cours:\n",
" cal = calculer_calories(cmd, menu, menus_bestof)\n",
" print(\"Commande\", cmd[\"id\"], \":\", cal, \"calories\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2.3 Ticket de caisse (6 pts)\n",
"\n",
"Écrivez une fonction `generer_ticket(commande, menu, menus_bestof)` qui génère un ticket de caisse sous forme de chaîne de caractères."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def generer_ticket(commande, menu, menus_bestof):\n",
" lignes = []\n",
" lignes.append(\"=\" * 30)\n",
" lignes.append(\"COMMANDE #\" + str(commande[\"id\"]))\n",
" lignes.append(\"Heure : \" + commande[\"heure\"])\n",
" lignes.append(\"-\" * 30)\n",
" \n",
" for item in commande[\"items\"]:\n",
" nom_article = item[0]\n",
" quantite = item[1]\n",
" \n",
" # Trouver le prix de l'article\n",
" # Votre code ici\n",
" prix = 0\n",
" \n",
" sous_total = prix * quantite\n",
" ligne = str(quantite) + \"x \" + nom_article + \" - \" + str(sous_total) + \" euros\"\n",
" lignes.append(ligne)\n",
" \n",
" lignes.append(\"-\" * 30)\n",
" total = calculer_prix(commande, menu, menus_bestof)\n",
" lignes.append(\"TOTAL : \" + str(total) + \" euros\")\n",
" lignes.append(\"=\" * 30)\n",
" \n",
" return \"\\n\".join(lignes)\n",
"\n",
"# Test\n",
"print(generer_ticket(commandes_en_cours[0], menu, menus_bestof))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2.4 Chiffre d'affaires (5 pts)\n",
"\n",
"Écrivez une fonction `chiffre_affaires(commandes, menu, menus_bestof)` qui calcule le chiffre d'affaires total de toutes les commandes."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def chiffre_affaires(commandes, menu, menus_bestof):\n",
" total = 0\n",
" \n",
" for commande in commandes:\n",
" # Votre code ici : utiliser calculer_prix\n",
" pass\n",
" \n",
" return round(total, 2)\n",
"\n",
"# Test\n",
"ca = chiffre_affaires(commandes_en_cours, menu, menus_bestof)\n",
"print(\"Chiffre d'affaires :\", ca, \"euros\")\n",
"print(\"Nombre de commandes :\", len(commandes_en_cours))\n",
"print(\"Panier moyen :\", round(ca / len(commandes_en_cours), 2), \"euros\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 3 - Bonus (20 min)\n",
"\n",
"### 3.1 Article le plus commandé (5 pts)\n",
"\n",
"Écrivez une fonction `article_plus_commande(commandes)` qui renvoie l'article le plus commandé (en nombre total).\n",
"\n",
"Renvoie un tuple `(nom_article, nombre_total)`."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def article_plus_commande(commandes):\n",
" compteur = {}\n",
" \n",
" for commande in commandes:\n",
" for item in commande[\"items\"]:\n",
" nom = item[0]\n",
" quantite = item[1]\n",
" # Votre code ici : incrementer le compteur\n",
" pass\n",
" \n",
" # Trouver le maximum\n",
" meilleur = None\n",
" meilleur_nb = 0\n",
" \n",
" for article, nb in compteur.items():\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return (meilleur, meilleur_nb)\n",
"\n",
"# Test\n",
"art, nb = article_plus_commande(commandes_en_cours)\n",
"print(\"Article le plus commande :\", art, \"(\", nb, \"fois)\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 3.2 Économie Best-Of (5 pts)\n",
"\n",
"Écrivez une fonction `economie_bestof(nom_bestof, menu, menus_bestof)` qui calcule l'économie réalisée en prenant un Best-Of par rapport aux articles séparés."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def economie_bestof(nom_bestof, menu, menus_bestof):\n",
" if nom_bestof not in menus_bestof:\n",
" return 0\n",
" \n",
" bestof = menus_bestof[nom_bestof]\n",
" prix_bestof = bestof[\"prix\"]\n",
" \n",
" # Calculer le prix des articles separes (burger + frites + boisson)\n",
" # Votre code ici\n",
" prix_separe = 0\n",
" \n",
" economie = prix_separe - prix_bestof\n",
" \n",
" return round(economie, 2)\n",
"\n",
"# Test\n",
"for nom in menus_bestof.keys():\n",
" eco = economie_bestof(nom, menu, menus_bestof)\n",
" print(nom, \": economie de\", eco, \"euros\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 3.3 Statistiques par catégorie (4 pts)\n",
"\n",
"Écrivez une fonction `stats_menu(menu)` qui renvoie des statistiques pour chaque catégorie : nombre d'articles, prix moyen, calories moyennes."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def stats_menu(menu):\n",
" stats = {}\n",
" \n",
" for categorie, articles in menu.items():\n",
" nb = len(articles)\n",
" total_prix = 0\n",
" total_cal = 0\n",
" \n",
" for nom, infos in articles.items():\n",
" # Votre code ici : cumuler prix et calories\n",
" pass\n",
" \n",
" stats[categorie] = {\n",
" \"nb_articles\": nb,\n",
" \"prix_moyen\": round(total_prix / nb, 2),\n",
" \"calories_moyennes\": round(total_cal / nb)\n",
" }\n",
" \n",
" return stats\n",
"\n",
"# Test\n",
"print(\"Statistiques du menu :\")\n",
"for cat, data in stats_menu(menu).items():\n",
" print(\" \", cat, \":\")\n",
" print(\" Articles :\", data[\"nb_articles\"])\n",
" print(\" Prix moyen :\", data[\"prix_moyen\"], \"euros\")\n",
" print(\" Calories moyennes :\", data[\"calories_moyennes\"])"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"name": "python",
"version": "3.9.0"
}
},
"nbformat": 4,
"nbformat_minor": 4
}

282
representation_construits/evaluation/TP08_McDonalds_aide.md Normal file
View File

@@ -0,0 +1,282 @@
# Aide - TP08 McDonald's
## Rappels utiles
### Structure du menu (dictionnaire imbrique)
```python
# menu = {categorie: {article: {infos}}}
menu = {
"burgers": {
"Big Mac": {"prix": 5.50, "calories": 540, "temps_prep": 3},
"McChicken": {"prix": 4.90, "calories": 420, "temps_prep": 3}
},
"accompagnements": {...},
"boissons": {...}
}
# Acceder au prix du Big Mac
prix = menu["burgers"]["Big Mac"]["prix"]
# Parcourir toutes les categories
for categorie, articles in menu.items():
for nom_article, infos in articles.items():
print(nom_article, ":", infos["prix"], "euros")
```
### Structure des commandes
```python
commande = {
"id": 101,
"items": [("Big Mac", 2), ("Frites (G)", 2)], # (article, quantite)
"heure": "12:05"
}
# Parcourir les items
for article, quantite in commande["items"]:
print(quantite, "x", article)
```
### Trouver un article dans le menu
```python
def trouver_article(menu, nom):
for categorie, articles in menu.items():
if nom in articles:
return articles[nom]
return None
```
---
## Exercice 1
### 1.1 - Affichage du menu
```python
def afficher_menu(menu, categorie):
if categorie in menu:
print("===", categorie.upper(), "===")
for nom, infos in menu[categorie].items():
print(" ", nom, ":", infos["prix"], "euros (", infos["calories"], "cal)")
```
### 1.2 - Recherche d'articles
```python
def rechercher_article(menu, nom_recherche):
resultats = []
nom_lower = nom_recherche.lower()
for categorie, articles in menu.items():
for nom_article, infos in articles.items():
if nom_lower in nom_article.lower():
resultats.append({
"nom": nom_article,
"categorie": categorie,
"prix": infos["prix"],
"calories": infos["calories"]
})
return resultats
```
### 1.3 - Statistiques du menu
```python
def stats_menu(menu):
tous_articles = []
for categorie, articles in menu.items():
for nom, infos in articles.items():
tous_articles.append({"nom": nom, "infos": infos})
# Prix moyen
total_prix = 0
for article in tous_articles:
total_prix = total_prix + article["infos"]["prix"]
prix_moyen = total_prix / len(tous_articles)
# Article le moins calorique
min_cal = tous_articles[0]
for article in tous_articles:
if article["infos"]["calories"] < min_cal["infos"]["calories"]:
min_cal = article
return {
"prix_moyen": round(prix_moyen, 2),
"article_moins_calorique": min_cal["nom"]
}
```
---
## Exercice 2
### 2.1 - Calculer le prix
```python
def calculer_prix(commande, menu, menus_bestof):
total = 0
for article, qte in commande["items"]:
# Verifier si c'est un Best-Of
if article in menus_bestof:
total = total + menus_bestof[article]["prix"] * qte
else:
# Chercher dans le menu normal
for categorie, articles in menu.items():
if article in articles:
total = total + articles[article]["prix"] * qte
break
return total
```
### 2.2 - Temps de preparation
```python
def temps_preparation(commande, menu, menus_bestof):
temps_par_categorie = {}
for article, qte in commande["items"]:
if article in menus_bestof:
# Best-Of = burger + frites + boisson
# Ajouter le temps du burger (le plus long)
temps_par_categorie["burgers"] = max(
temps_par_categorie.get("burgers", 0), 3
)
else:
# Trouver la categorie et le temps
for categorie, articles in menu.items():
if article in articles:
temps = articles[article]["temps_prep"]
# Garder le max par categorie (preparation parallele)
temps_par_categorie[categorie] = max(
temps_par_categorie.get(categorie, 0), temps
)
break
# Additionner les temps des differentes categories
total = 0
for temps in temps_par_categorie.values():
total = total + temps
return total
```
### 2.3 - Calories totales
```python
def calories_commande(commande, menu, menus_bestof):
total_calories = 0
for article, qte in commande["items"]:
if article in menus_bestof:
total_calories = total_calories + menus_bestof[article]["calories"] * qte
else:
for categorie, articles in menu.items():
if article in articles:
total_calories = total_calories + articles[article]["calories"] * qte
break
return total_calories
```
---
## Exercice 3 (Bonus)
### 3.1 - Ticket de caisse
```python
def generer_ticket(commande, menu, menus_bestof):
lignes = []
lignes.append("=" * 30)
lignes.append("COMMANDE #" + str(commande["id"]))
lignes.append("Heure: " + commande["heure"])
lignes.append("-" * 30)
total = 0
for article, qte in commande["items"]:
# Trouver le prix
prix = 0
if article in menus_bestof:
prix = menus_bestof[article]["prix"]
else:
for cat, articles in menu.items():
if article in articles:
prix = articles[article]["prix"]
break
sous_total = prix * qte
total = total + sous_total
lignes.append(str(qte) + "x " + article + " : " + str(sous_total) + " euros")
lignes.append("-" * 30)
lignes.append("TOTAL: " + str(total) + " euros")
lignes.append("=" * 30)
return "\n".join(lignes)
```
### 3.2 - Repas optimal
```python
def repas_optimal(menu, budget, calories_max):
meilleur_repas = None
meilleur_score = -1
for burger_nom, burger in menu["burgers"].items():
for accomp_nom, accomp in menu["accompagnements"].items():
for boisson_nom, boisson in menu["boissons"].items():
prix = burger["prix"] + accomp["prix"] + boisson["prix"]
calories = burger["calories"] + accomp["calories"] + boisson["calories"]
if prix <= budget and calories <= calories_max:
# Score = satisfaction / prix
satisfaction = 100 - calories / 10
score = satisfaction / prix
if score > meilleur_score:
meilleur_score = score
meilleur_repas = {
"burger": burger_nom,
"accompagnement": accomp_nom,
"boisson": boisson_nom,
"prix_total": prix,
"calories_total": calories
}
return meilleur_repas
```
### 3.3 - Analyse de la file
```python
def analyser_file(commandes, menu, menus_bestof):
chiffre_affaires = 0
# Compter les articles
compteur_articles = {}
for cmd in commandes:
chiffre_affaires = chiffre_affaires + calculer_prix(cmd, menu, menus_bestof)
for article, qte in cmd["items"]:
if article not in compteur_articles:
compteur_articles[article] = 0
compteur_articles[article] = compteur_articles[article] + qte
# Trouver l'article le plus commande
article_star = None
max_qte = 0
for article, qte in compteur_articles.items():
if qte > max_qte:
article_star = article
max_qte = qte
return {
"nb_commandes": len(commandes),
"chiffre_affaires": chiffre_affaires,
"article_plus_commande": article_star
}
```
---
## Pieges a eviter
1. **Best-Of vs articles individuels** : verifiez d'abord si l'article est un Best-Of avant de chercher dans le menu
2. **Temps de preparation** : meme categorie = parallele (max), categories differentes = sequentiel (somme)
3. **Prix avec decimales** : utilisez round() pour arrondir
4. **Quantites** : n'oubliez pas de multiplier par la quantite !
5. **Articles avec tailles** : "Frites (M)" et "Frites (G)" sont des articles differents

559
representation_construits/evaluation/TP09_Fortnite.ipynb Normal file
View File

@@ -0,0 +1,559 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# TP Évaluation - Statistiques Fortnite\n",
"\n",
"**Durée : 1h30**\n",
"\n",
"**Nom :** \n",
"\n",
"**Prénom :**\n",
"\n",
"---\n",
"\n",
"Dans ce TP, vous allez analyser des statistiques de joueurs Fortnite.\n",
"\n",
"**Compétences évaluées :**\n",
"- Dictionnaires imbriqués\n",
"- Algorithmes de calcul statistique\n",
"- Filtrage et tri de données"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Données initiales\n",
"\n",
"**Exécutez cette cellule avant de commencer.**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Statistiques des joueurs\n",
"joueurs = {\n",
" \"NinjaMaster\": {\n",
" \"niveau\": 250,\n",
" \"vbucks\": 3500,\n",
" \"stats\": {\n",
" \"solo\": {\"parties\": 450, \"victoires\": 89, \"kills\": 2340},\n",
" \"duo\": {\"parties\": 320, \"victoires\": 65, \"kills\": 1890},\n",
" \"squad\": {\"parties\": 280, \"victoires\": 72, \"kills\": 1650}\n",
" },\n",
" \"inventaire\": [\"Pioche Spectrale\", \"Planeur Dragon\", \"Skin Raven\"]\n",
" },\n",
" \"BuilderPro\": {\n",
" \"niveau\": 180,\n",
" \"vbucks\": 1200,\n",
" \"stats\": {\n",
" \"solo\": {\"parties\": 280, \"victoires\": 42, \"kills\": 1120},\n",
" \"duo\": {\"parties\": 450, \"victoires\": 98, \"kills\": 2450},\n",
" \"squad\": {\"parties\": 380, \"victoires\": 110, \"kills\": 2100}\n",
" },\n",
" \"inventaire\": [\"Pioche Arc-en-ciel\", \"Skin Drift\"]\n",
" },\n",
" \"SniperElite\": {\n",
" \"niveau\": 320,\n",
" \"vbucks\": 8900,\n",
" \"stats\": {\n",
" \"solo\": {\"parties\": 680, \"victoires\": 156, \"kills\": 4200},\n",
" \"duo\": {\"parties\": 220, \"victoires\": 45, \"kills\": 980},\n",
" \"squad\": {\"parties\": 150, \"victoires\": 28, \"kills\": 620}\n",
" },\n",
" \"inventaire\": [\"Pioche Galaxy\", \"Planeur Meteore\", \"Skin Black Knight\", \"Skin Omega\"]\n",
" },\n",
" \"CasualGamer\": {\n",
" \"niveau\": 85,\n",
" \"vbucks\": 500,\n",
" \"stats\": {\n",
" \"solo\": {\"parties\": 120, \"victoires\": 8, \"kills\": 180},\n",
" \"duo\": {\"parties\": 200, \"victoires\": 22, \"kills\": 420},\n",
" \"squad\": {\"parties\": 350, \"victoires\": 45, \"kills\": 680}\n",
" },\n",
" \"inventaire\": [\"Skin Default\", \"Pioche Standard\"]\n",
" },\n",
" \"StreamerKing\": {\n",
" \"niveau\": 450,\n",
" \"vbucks\": 25000,\n",
" \"stats\": {\n",
" \"solo\": {\"parties\": 1200, \"victoires\": 312, \"kills\": 8900},\n",
" \"duo\": {\"parties\": 800, \"victoires\": 245, \"kills\": 5600},\n",
" \"squad\": {\"parties\": 600, \"victoires\": 198, \"kills\": 4200}\n",
" },\n",
" \"inventaire\": [\"Pioche Galaxy\", \"Skin Skull Trooper\", \"Skin Ghoul Trooper\", \"Planeur Dragon\", \"Skin Renegade Raider\"]\n",
" }\n",
"}\n",
"\n",
"# Boutique du jour\n",
"boutique = [\n",
" {\"nom\": \"Skin Crystal\", \"type\": \"skin\", \"rarete\": \"rare\", \"prix\": 1200},\n",
" {\"nom\": \"Skin Aura\", \"type\": \"skin\", \"rarete\": \"uncommon\", \"prix\": 800},\n",
" {\"nom\": \"Skin Raptor\", \"type\": \"skin\", \"rarete\": \"legendary\", \"prix\": 2000},\n",
" {\"nom\": \"Pioche Laser\", \"type\": \"pioche\", \"rarete\": \"rare\", \"prix\": 800},\n",
" {\"nom\": \"Pioche Feu\", \"type\": \"pioche\", \"rarete\": \"uncommon\", \"prix\": 500},\n",
" {\"nom\": \"Planeur Etoile\", \"type\": \"planeur\", \"rarete\": \"epic\", \"prix\": 1200},\n",
" {\"nom\": \"Emote Dance\", \"type\": \"emote\", \"rarete\": \"rare\", \"prix\": 500}\n",
"]\n",
"\n",
"# Historique des parties recentes\n",
"parties_recentes = [\n",
" {\"joueur\": \"NinjaMaster\", \"mode\": \"solo\", \"placement\": 1, \"kills\": 8},\n",
" {\"joueur\": \"NinjaMaster\", \"mode\": \"solo\", \"placement\": 15, \"kills\": 3},\n",
" {\"joueur\": \"BuilderPro\", \"mode\": \"duo\", \"placement\": 1, \"kills\": 6},\n",
" {\"joueur\": \"SniperElite\", \"mode\": \"solo\", \"placement\": 1, \"kills\": 12},\n",
" {\"joueur\": \"SniperElite\", \"mode\": \"solo\", \"placement\": 3, \"kills\": 7},\n",
" {\"joueur\": \"CasualGamer\", \"mode\": \"squad\", \"placement\": 8, \"kills\": 2},\n",
" {\"joueur\": \"StreamerKing\", \"mode\": \"solo\", \"placement\": 1, \"kills\": 15},\n",
" {\"joueur\": \"StreamerKing\", \"mode\": \"duo\", \"placement\": 1, \"kills\": 9},\n",
" {\"joueur\": \"BuilderPro\", \"mode\": \"squad\", \"placement\": 2, \"kills\": 5}\n",
"]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 1 - Analyse des profils (25 min)\n",
"\n",
"### 1.1 Affichage de profil (4 pts)\n",
"\n",
"Écrivez une fonction `afficher_profil(pseudo, joueurs)` qui affiche le profil d'un joueur.\n",
"\n",
"Exemple :\n",
"```\n",
"=== NinjaMaster ===\n",
"Niveau : 250 | V-Bucks : 3500\n",
"Inventaire : 3 items\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def afficher_profil(pseudo, joueurs):\n",
" if pseudo not in joueurs:\n",
" print(\"Joueur non trouve\")\n",
" return\n",
" \n",
" profil = joueurs[pseudo]\n",
" \n",
" # Votre code ici : afficher le pseudo, niveau, vbucks et nb d'items\n",
" pass\n",
"\n",
"# Test\n",
"afficher_profil(\"NinjaMaster\", joueurs)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1.2 Statistiques globales (4 pts)\n",
"\n",
"Écrivez une fonction `stats_globales(pseudo, joueurs)` qui calcule pour un joueur :\n",
"- `parties_totales` : somme de toutes les parties\n",
"- `victoires_totales` : somme de toutes les victoires\n",
"- `kills_totaux` : somme de tous les kills\n",
"- `winrate` : pourcentage de victoires (arrondi à 2 décimales)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def stats_globales(pseudo, joueurs):\n",
" profil = joueurs[pseudo]\n",
" stats = profil[\"stats\"]\n",
" \n",
" parties_totales = 0\n",
" victoires_totales = 0\n",
" kills_totaux = 0\n",
" \n",
" for mode, data in stats.items():\n",
" # Votre code ici : cumuler parties, victoires et kills\n",
" pass\n",
" \n",
" # Calculer le winrate\n",
" # Votre code ici\n",
" winrate = 0\n",
" \n",
" return {\n",
" \"parties_totales\": parties_totales,\n",
" \"victoires_totales\": victoires_totales,\n",
" \"kills_totaux\": kills_totaux,\n",
" \"winrate\": winrate\n",
" }\n",
"\n",
"# Test\n",
"stats = stats_globales(\"SniperElite\", joueurs)\n",
"print(\"Stats de SniperElite :\")\n",
"print(\" Parties :\", stats[\"parties_totales\"])\n",
"print(\" Victoires :\", stats[\"victoires_totales\"])\n",
"print(\" Kills :\", stats[\"kills_totaux\"])\n",
"print(\" Winrate :\", stats[\"winrate\"], \"%\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1.3 Mode préféré (4 pts)\n",
"\n",
"Écrivez une fonction `mode_prefere(pseudo, joueurs)` qui renvoie le mode de jeu (solo, duo, squad) où le joueur a joué le plus de parties."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def mode_prefere(pseudo, joueurs):\n",
" profil = joueurs[pseudo]\n",
" stats = profil[\"stats\"]\n",
" \n",
" meilleur_mode = None\n",
" max_parties = 0\n",
" \n",
" for mode, data in stats.items():\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return meilleur_mode\n",
"\n",
"# Test\n",
"for pseudo in joueurs:\n",
" print(pseudo, \"prefere le mode\", mode_prefere(pseudo, joueurs))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 2 - Classements et boutique (35 min)\n",
"\n",
"### 2.1 Classement par critère (6 pts)\n",
"\n",
"Écrivez une fonction `classement(joueurs, critere)` qui renvoie la liste des pseudos triés selon le critère.\n",
"\n",
"Critères possibles : `\"niveau\"`, `\"victoires\"`, `\"kills\"`, `\"winrate\"`\n",
"\n",
"*Aide : créez d'abord une liste de tuples (pseudo, valeur), triez-la, puis extrayez les pseudos.*"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def classement(joueurs, critere):\n",
" # Creer une liste de tuples (pseudo, valeur)\n",
" liste = []\n",
" \n",
" for pseudo in joueurs:\n",
" if critere == \"niveau\":\n",
" valeur = joueurs[pseudo][\"niveau\"]\n",
" elif critere == \"victoires\":\n",
" stats = stats_globales(pseudo, joueurs)\n",
" valeur = stats[\"victoires_totales\"]\n",
" elif critere == \"kills\":\n",
" stats = stats_globales(pseudo, joueurs)\n",
" valeur = stats[\"kills_totaux\"]\n",
" elif critere == \"winrate\":\n",
" stats = stats_globales(pseudo, joueurs)\n",
" valeur = stats[\"winrate\"]\n",
" else:\n",
" valeur = 0\n",
" \n",
" liste.append((pseudo, valeur))\n",
" \n",
" # Trier par valeur decroissante\n",
" # Votre code ici\n",
" pass\n",
" \n",
" # Extraire les pseudos\n",
" resultat = []\n",
" for item in liste:\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return resultat\n",
"\n",
"# Tests\n",
"print(\"Par niveau :\", classement(joueurs, \"niveau\"))\n",
"print(\"Par victoires :\", classement(joueurs, \"victoires\"))\n",
"print(\"Par winrate :\", classement(joueurs, \"winrate\"))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2.2 Articles achetables (5 pts)\n",
"\n",
"Écrivez une fonction `articles_achetables(pseudo, joueurs, boutique)` qui renvoie la liste des articles que le joueur peut acheter avec ses V-Bucks.\n",
"\n",
"Exclure les articles déjà possédés dans l'inventaire."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def articles_achetables(pseudo, joueurs, boutique):\n",
" profil = joueurs[pseudo]\n",
" vbucks = profil[\"vbucks\"]\n",
" inventaire = profil[\"inventaire\"]\n",
" \n",
" achetables = []\n",
" \n",
" for article in boutique:\n",
" # Verifier le prix et si pas deja possede\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return achetables\n",
"\n",
"# Test\n",
"print(\"Articles achetables pour BuilderPro :\")\n",
"for art in articles_achetables(\"BuilderPro\", joueurs, boutique):\n",
" print(\" \", art[\"nom\"], \"-\", art[\"prix\"], \"V-Bucks\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2.3 Comparaison de joueurs (6 pts)\n",
"\n",
"Écrivez une fonction `comparer_joueurs(pseudo1, pseudo2, joueurs)` qui compare deux joueurs.\n",
"\n",
"Renvoie un dictionnaire indiquant pour chaque critère (niveau, victoires, kills, winrate) quel joueur est meilleur."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def comparer_joueurs(pseudo1, pseudo2, joueurs):\n",
" stats1 = stats_globales(pseudo1, joueurs)\n",
" stats2 = stats_globales(pseudo2, joueurs)\n",
" \n",
" comparaison = {}\n",
" \n",
" # Comparer le niveau\n",
" # Votre code ici\n",
" pass\n",
" \n",
" # Comparer les victoires\n",
" # Votre code ici\n",
" pass\n",
" \n",
" # Comparer les kills\n",
" # Votre code ici\n",
" pass\n",
" \n",
" # Comparer le winrate\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return comparaison\n",
"\n",
"# Test\n",
"comp = comparer_joueurs(\"NinjaMaster\", \"SniperElite\", joueurs)\n",
"print(\"Comparaison NinjaMaster vs SniperElite :\")\n",
"for critere, gagnant in comp.items():\n",
" print(\" \", critere, \":\", gagnant)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2.4 Joueur le plus riche (5 pts)\n",
"\n",
"Écrivez une fonction `plus_riche(joueurs)` qui renvoie le pseudo du joueur ayant le plus de V-Bucks."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def plus_riche(joueurs):\n",
" meilleur = None\n",
" max_vbucks = 0\n",
" \n",
" for pseudo, profil in joueurs.items():\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return meilleur\n",
"\n",
"# Test\n",
"riche = plus_riche(joueurs)\n",
"print(\"Joueur le plus riche :\", riche)\n",
"if riche:\n",
" print(\"V-Bucks :\", joueurs[riche][\"vbucks\"])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 3 - Bonus (20 min)\n",
"\n",
"### 3.1 Performances récentes (5 pts)\n",
"\n",
"Écrivez une fonction `performances_recentes(pseudo, parties)` qui analyse les parties récentes d'un joueur.\n",
"\n",
"Renvoie : `nb_parties`, `victoires`, `kills_moyen` (arrondi à 1 décimale)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def performances_recentes(pseudo, parties):\n",
" nb_parties = 0\n",
" victoires = 0\n",
" total_kills = 0\n",
" \n",
" for partie in parties:\n",
" if partie[\"joueur\"] == pseudo:\n",
" # Votre code ici\n",
" pass\n",
" \n",
" if nb_parties > 0:\n",
" kills_moyen = round(total_kills / nb_parties, 1)\n",
" else:\n",
" kills_moyen = 0\n",
" \n",
" return {\n",
" \"nb_parties\": nb_parties,\n",
" \"victoires\": victoires,\n",
" \"kills_moyen\": kills_moyen\n",
" }\n",
"\n",
"# Test\n",
"for pseudo in [\"NinjaMaster\", \"SniperElite\", \"StreamerKing\"]:\n",
" perf = performances_recentes(pseudo, parties_recentes)\n",
" print(pseudo, \":\", perf[\"victoires\"], \"/\", perf[\"nb_parties\"], \"victoires, \", perf[\"kills_moyen\"], \"kills/partie\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 3.2 K/D Ratio (4 pts)\n",
"\n",
"Écrivez une fonction `kd_ratio(pseudo, joueurs)` qui calcule le ratio kills/deaths.\n",
"\n",
"Deaths = parties - victoires (on meurt une fois par partie perdue)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def kd_ratio(pseudo, joueurs):\n",
" stats = stats_globales(pseudo, joueurs)\n",
" \n",
" kills = stats[\"kills_totaux\"]\n",
" deaths = stats[\"parties_totales\"] - stats[\"victoires_totales\"]\n",
" \n",
" # Votre code ici : calculer le ratio (attention division par zero)\n",
" ratio = 0\n",
" \n",
" return ratio\n",
"\n",
"# Test\n",
"print(\"K/D Ratio :\")\n",
"for pseudo in joueurs:\n",
" print(\" \", pseudo, \":\", kd_ratio(pseudo, joueurs))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 3.3 Items les plus possédés (5 pts)\n",
"\n",
"Écrivez une fonction `items_populaires(joueurs)` qui compte combien de joueurs possèdent chaque item et renvoie la liste triée par popularité décroissante.\n",
"\n",
"Renvoie une liste de tuples `(nom_item, nb_joueurs)`."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def items_populaires(joueurs):\n",
" compteur = {}\n",
" \n",
" for pseudo, profil in joueurs.items():\n",
" for item in profil[\"inventaire\"]:\n",
" # Votre code ici : incrementer le compteur\n",
" pass\n",
" \n",
" # Convertir en liste de tuples et trier\n",
" liste = []\n",
" for item, nb in compteur.items():\n",
" liste.append((item, nb))\n",
" \n",
" # Votre code ici : trier par nb decroissant\n",
" pass\n",
" \n",
" return liste\n",
"\n",
"# Test\n",
"print(\"Items les plus possedes :\")\n",
"for item, nb in items_populaires(joueurs):\n",
" print(\" \", item, \":\", nb, \"joueur(s)\")"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"name": "python",
"version": "3.9.0"
}
},
"nbformat": 4,
"nbformat_minor": 4
}

339
representation_construits/evaluation/TP09_Fortnite_aide.md Normal file
View File

@@ -0,0 +1,339 @@
# Aide - TP09 Fortnite
## Rappels utiles
### Structure des joueurs (dictionnaire imbrique)
```python
joueurs = {
"NinjaMaster": {
"niveau": 250,
"vbucks": 3500,
"stats": {
"solo": {"parties": 450, "victoires": 89, "kills": 2340, "top10": 180},
"duo": {"parties": 320, "victoires": 65, "kills": 1890, "top5": 110},
"squad": {"parties": 280, "victoires": 72, "kills": 1650, "top3": 95}
},
"inventaire": ["Pioche Spectrale", "Planeur Dragon"]
}
}
# Acceder aux stats solo d'un joueur
solo = joueurs["NinjaMaster"]["stats"]["solo"]
victoires_solo = solo["victoires"]
# Parcourir tous les joueurs
for pseudo, profil in joueurs.items():
print(pseudo, ": niveau", profil["niveau"])
```
### Structure de la boutique
```python
boutique = {
"skins": [
{"nom": "Skin Crystal", "rarete": "rare", "prix": 1200},
{"nom": "Skin Phoenix", "rarete": "epique", "prix": 1500}
],
"pioches": [...],
"planeurs": [...]
}
# Parcourir toutes les categories
for categorie, articles in boutique.items():
for article in articles:
print(article["nom"], ":", article["prix"], "V-Bucks")
```
---
## Exercice 1
### 1.1 - Affichage de profil
```python
def afficher_profil(pseudo, joueurs):
if pseudo not in joueurs:
print("Joueur non trouve")
return
profil = joueurs[pseudo]
print("===", pseudo, "===")
print("Niveau:", profil["niveau"])
print("V-Bucks:", profil["vbucks"])
print()
print("Statistiques:")
for mode, stats in profil["stats"].items():
print(" ", mode, ":", stats["victoires"], "victoires /", stats["parties"], "parties")
```
### 1.2 - Statistiques globales
```python
def stats_globales(pseudo, joueurs):
profil = joueurs[pseudo]
stats = profil["stats"]
# Calculer les totaux
parties = 0
victoires = 0
kills = 0
for mode, s in stats.items():
parties = parties + s["parties"]
victoires = victoires + s["victoires"]
kills = kills + s["kills"]
# Winrate
if parties > 0:
winrate = round(victoires * 100 / parties, 2)
else:
winrate = 0
# KD = kills / morts, morts = parties - victoires
morts = parties - victoires
if morts > 0:
kd = round(kills / morts, 2)
else:
kd = kills
# Mode prefere = celui avec le plus de parties
mode_prefere = None
max_parties = 0
for mode, s in stats.items():
if s["parties"] > max_parties:
mode_prefere = mode
max_parties = s["parties"]
return {
"parties_totales": parties,
"victoires_totales": victoires,
"kills_totaux": kills,
"winrate": winrate,
"kd_ratio": kd,
"mode_prefere": mode_prefere
}
```
### 1.3 - Classement des joueurs
```python
def classement(joueurs, critere):
liste_joueurs = []
if critere == "niveau":
for pseudo, profil in joueurs.items():
liste_joueurs.append((pseudo, profil["niveau"]))
liste_joueurs = sorted(liste_joueurs, key=lambda x: x[1], reverse=True)
elif critere == "victoires":
for pseudo, profil in joueurs.items():
total_victoires = 0
for mode, s in profil["stats"].items():
total_victoires = total_victoires + s["victoires"]
liste_joueurs.append((pseudo, total_victoires))
liste_joueurs = sorted(liste_joueurs, key=lambda x: x[1], reverse=True)
# Renvoyer juste les pseudos
pseudos = []
for pseudo, valeur in liste_joueurs:
pseudos.append(pseudo)
return pseudos
```
---
## Exercice 2
### 2.1 - Articles achetables
```python
def articles_achetables(pseudo, joueurs, boutique):
budget = joueurs[pseudo]["vbucks"]
inventaire = joueurs[pseudo]["inventaire"]
achetables = []
for categorie, articles in boutique.items():
for article in articles:
if article["prix"] <= budget and article["nom"] not in inventaire:
achetables.append(article)
return achetables
```
### 2.2 - Panier optimise
```python
def panier_optimal(pseudo, joueurs, boutique, priorites):
budget = joueurs[pseudo]["vbucks"]
inventaire = joueurs[pseudo]["inventaire"]
panier = []
for categorie in priorites:
if categorie not in boutique:
continue
# Trier par prix croissant pour maximiser le nombre d'achats
articles = sorted(boutique[categorie], key=lambda a: a["prix"])
for article in articles:
if article["nom"] not in inventaire and article["prix"] <= budget:
panier.append(article)
budget = budget - article["prix"]
return panier, budget
```
### 2.3 - Analyse des inventaires
```python
def analyser_inventaires(joueurs):
# Compter les occurrences de chaque item
compteur = {}
for pseudo, profil in joueurs.items():
for item in profil["inventaire"]:
if item not in compteur:
compteur[item] = 0
compteur[item] = compteur[item] + 1
# Items communs (possedes par plusieurs joueurs)
items_communs = []
for item, count in compteur.items():
if count >= 2:
items_communs.append(item)
# Items rares (possedes par un seul joueur)
items_rares = []
for item, count in compteur.items():
if count == 1:
items_rares.append(item)
# Collectionneur (le plus d'items)
collectionneur = None
max_items = 0
for pseudo, profil in joueurs.items():
if len(profil["inventaire"]) > max_items:
collectionneur = pseudo
max_items = len(profil["inventaire"])
return {
"items_communs": items_communs,
"items_rares": items_rares,
"joueur_collectionneur": collectionneur
}
```
---
## Exercice 3 (Bonus)
### 3.1 - Performances recentes
```python
def performances_recentes(pseudo, parties):
# Filtrer les parties du joueur
mes_parties = []
for p in parties:
if p["joueur"] == pseudo:
mes_parties.append(p)
if len(mes_parties) == 0:
return None
# Calculer les statistiques
victoires = 0
total_kills = 0
total_degats = 0
total_duree = 0
for p in mes_parties:
if p["placement"] == 1:
victoires = victoires + 1
total_kills = total_kills + p["kills"]
total_degats = total_degats + p["degats"]
total_duree = total_duree + p["duree"]
kills_moyen = round(total_kills / len(mes_parties), 1)
degats_moyens = round(total_degats / len(mes_parties))
duree_moyenne = round(total_duree / len(mes_parties))
# Meilleure partie
meilleure = mes_parties[0]
for p in mes_parties:
if p["kills"] > meilleure["kills"]:
meilleure = p
return {
"nb_parties": len(mes_parties),
"victoires": victoires,
"kills_moyen": kills_moyen,
"degats_moyens": degats_moyens,
"duree_moyenne": duree_moyenne,
"meilleure_partie": meilleure
}
```
### 3.2 - Comparaison de joueurs
```python
def comparer_joueurs(pseudo1, pseudo2, joueurs):
stats1 = stats_globales(pseudo1, joueurs)
stats2 = stats_globales(pseudo2, joueurs)
comparaison = {}
# Comparer les stats
if stats1["kills_totaux"] > stats2["kills_totaux"]:
comparaison["kills"] = pseudo1
else:
comparaison["kills"] = pseudo2
if stats1["winrate"] > stats2["winrate"]:
comparaison["winrate"] = pseudo1
else:
comparaison["winrate"] = pseudo2
if stats1["kd_ratio"] > stats2["kd_ratio"]:
comparaison["kd"] = pseudo1
else:
comparaison["kd"] = pseudo2
return comparaison
```
### 3.3 - Prediction de rang
```python
def calculer_rang(pseudo, joueurs):
stats = stats_globales(pseudo, joueurs)
profil = joueurs[pseudo]
# Winrate solo
solo = profil["stats"]["solo"]
if solo["parties"] > 0:
winrate_solo = solo["victoires"] * 100 / solo["parties"]
else:
winrate_solo = 0
# Calcul des points
points = 0
points = points + winrate_solo * 3
points = points + stats["kd_ratio"] * 50
points = points + stats["victoires_totales"] * 0.1
points = points + profil["niveau"] * 0.05
# Attribution du rang
if points >= 100:
rang = "Champion"
elif points >= 70:
rang = "Diamond"
elif points >= 50:
rang = "Platinum"
elif points >= 30:
rang = "Gold"
elif points >= 15:
rang = "Silver"
else:
rang = "Bronze"
return rang, round(points)
```
---
## Pieges a eviter
1. **KD ratio** : attention a la division par zero ! `morts = parties - victoires` peut etre 0
2. **Stats par mode** : solo a "top10", duo a "top5", squad a "top3"
3. **Inventaire = liste de strings** : utilisez `in` pour verifier si un item est possede
4. **V-Bucks** : ne pas oublier de soustraire apres chaque achat
5. **Parties recentes** : filtrer d'abord par joueur avant de calculer les stats

541
representation_construits/evaluation/TP10_Voyage.ipynb Normal file
View File

@@ -0,0 +1,541 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# TP Évaluation - Planification de Voyage\n",
"\n",
"**Durée : 1h30**\n",
"\n",
"**Nom :** \n",
"\n",
"**Prénom :**\n",
"\n",
"---\n",
"\n",
"Dans ce TP de synthèse, vous allez créer un système de planification de voyage.\n",
"\n",
"**Compétences évaluées :**\n",
"- Listes de tuples et dictionnaires\n",
"- Filtrage et tri de données\n",
"- Algorithmes de recherche"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Données initiales\n",
"\n",
"**Exécutez cette cellule avant de commencer.**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Base de donnees des villes\n",
"# Chaque ville : (nom, pays, langue, monnaie, decalage_horaire)\n",
"villes = [\n",
" (\"Paris\", \"France\", \"Francais\", \"EUR\", 0),\n",
" (\"Londres\", \"Royaume-Uni\", \"Anglais\", \"GBP\", 0),\n",
" (\"New York\", \"Etats-Unis\", \"Anglais\", \"USD\", -6),\n",
" (\"Tokyo\", \"Japon\", \"Japonais\", \"JPY\", 8),\n",
" (\"Barcelone\", \"Espagne\", \"Espagnol\", \"EUR\", 0),\n",
" (\"Rome\", \"Italie\", \"Italien\", \"EUR\", 0),\n",
" (\"Amsterdam\", \"Pays-Bas\", \"Neerlandais\", \"EUR\", 0),\n",
" (\"Berlin\", \"Allemagne\", \"Allemand\", \"EUR\", 0),\n",
" (\"Dubai\", \"Emirats Arabes Unis\", \"Arabe\", \"AED\", 3),\n",
" (\"Sydney\", \"Australie\", \"Anglais\", \"AUD\", 9)\n",
"]\n",
"\n",
"# Base de donnees des hotels\n",
"# Chaque hotel est un dictionnaire\n",
"hotels = [\n",
" {\"nom\": \"Le Marais Boutique\", \"ville\": \"Paris\", \"etoiles\": 3, \"prix_nuit\": 120, \"note\": 8.5},\n",
" {\"nom\": \"Paris Luxury Palace\", \"ville\": \"Paris\", \"etoiles\": 5, \"prix_nuit\": 450, \"note\": 9.2},\n",
" {\"nom\": \"Eiffel Budget\", \"ville\": \"Paris\", \"etoiles\": 2, \"prix_nuit\": 65, \"note\": 7.1},\n",
" {\"nom\": \"London Central\", \"ville\": \"Londres\", \"etoiles\": 4, \"prix_nuit\": 180, \"note\": 8.8},\n",
" {\"nom\": \"Westminster Inn\", \"ville\": \"Londres\", \"etoiles\": 3, \"prix_nuit\": 95, \"note\": 7.9},\n",
" {\"nom\": \"Manhattan View\", \"ville\": \"New York\", \"etoiles\": 4, \"prix_nuit\": 220, \"note\": 8.6},\n",
" {\"nom\": \"Times Square Budget\", \"ville\": \"New York\", \"etoiles\": 2, \"prix_nuit\": 89, \"note\": 6.8},\n",
" {\"nom\": \"Tokyo Garden\", \"ville\": \"Tokyo\", \"etoiles\": 4, \"prix_nuit\": 150, \"note\": 9.0},\n",
" {\"nom\": \"Shibuya Capsule\", \"ville\": \"Tokyo\", \"etoiles\": 1, \"prix_nuit\": 35, \"note\": 7.5},\n",
" {\"nom\": \"Barcelona Beach\", \"ville\": \"Barcelone\", \"etoiles\": 4, \"prix_nuit\": 140, \"note\": 8.7},\n",
" {\"nom\": \"Roma Antica\", \"ville\": \"Rome\", \"etoiles\": 3, \"prix_nuit\": 110, \"note\": 8.3},\n",
" {\"nom\": \"Canal House\", \"ville\": \"Amsterdam\", \"etoiles\": 3, \"prix_nuit\": 130, \"note\": 8.4},\n",
" {\"nom\": \"Berlin Modern\", \"ville\": \"Berlin\", \"etoiles\": 3, \"prix_nuit\": 85, \"note\": 8.1},\n",
" {\"nom\": \"Burj Luxury\", \"ville\": \"Dubai\", \"etoiles\": 5, \"prix_nuit\": 380, \"note\": 9.4},\n",
" {\"nom\": \"Sydney Harbour\", \"ville\": \"Sydney\", \"etoiles\": 4, \"prix_nuit\": 200, \"note\": 8.9}\n",
"]\n",
"\n",
"# Base de donnees des vols (depuis Paris)\n",
"# Chaque vol : (compagnie, depart, arrivee, prix, escales)\n",
"vols = [\n",
" (\"Air France\", \"Paris\", \"Londres\", 120, 0),\n",
" (\"EasyJet\", \"Paris\", \"Londres\", 65, 0),\n",
" (\"Air France\", \"Paris\", \"New York\", 480, 0),\n",
" (\"Delta\", \"Paris\", \"New York\", 420, 0),\n",
" (\"United\", \"Paris\", \"New York\", 350, 1),\n",
" (\"JAL\", \"Paris\", \"Tokyo\", 750, 0),\n",
" (\"Air France\", \"Paris\", \"Tokyo\", 680, 0),\n",
" (\"ANA\", \"Paris\", \"Tokyo\", 620, 1),\n",
" (\"Vueling\", \"Paris\", \"Barcelone\", 85, 0),\n",
" (\"Air France\", \"Paris\", \"Barcelone\", 130, 0),\n",
" (\"Alitalia\", \"Paris\", \"Rome\", 110, 0),\n",
" (\"EasyJet\", \"Paris\", \"Rome\", 75, 0),\n",
" (\"KLM\", \"Paris\", \"Amsterdam\", 95, 0),\n",
" (\"Lufthansa\", \"Paris\", \"Berlin\", 110, 0),\n",
" (\"Emirates\", \"Paris\", \"Dubai\", 450, 0),\n",
" (\"Qantas\", \"Paris\", \"Sydney\", 980, 1),\n",
" (\"Emirates\", \"Paris\", \"Sydney\", 1100, 1)\n",
"]\n",
"\n",
"# Activites par ville\n",
"activites = {\n",
" \"Paris\": [\n",
" {\"nom\": \"Tour Eiffel\", \"prix\": 26, \"duree\": 2, \"type\": \"monument\"},\n",
" {\"nom\": \"Louvre\", \"prix\": 17, \"duree\": 4, \"type\": \"musee\"},\n",
" {\"nom\": \"Croisiere Seine\", \"prix\": 15, \"duree\": 1, \"type\": \"excursion\"}\n",
" ],\n",
" \"Londres\": [\n",
" {\"nom\": \"British Museum\", \"prix\": 0, \"duree\": 3, \"type\": \"musee\"},\n",
" {\"nom\": \"London Eye\", \"prix\": 32, \"duree\": 1, \"type\": \"attraction\"},\n",
" {\"nom\": \"Tower of London\", \"prix\": 28, \"duree\": 2, \"type\": \"monument\"}\n",
" ],\n",
" \"New York\": [\n",
" {\"nom\": \"Statue of Liberty\", \"prix\": 24, \"duree\": 4, \"type\": \"monument\"},\n",
" {\"nom\": \"Empire State Building\", \"prix\": 44, \"duree\": 2, \"type\": \"monument\"},\n",
" {\"nom\": \"Broadway Show\", \"prix\": 150, \"duree\": 3, \"type\": \"spectacle\"}\n",
" ],\n",
" \"Tokyo\": [\n",
" {\"nom\": \"Temple Senso-ji\", \"prix\": 0, \"duree\": 2, \"type\": \"monument\"},\n",
" {\"nom\": \"Tokyo Skytree\", \"prix\": 20, \"duree\": 2, \"type\": \"attraction\"},\n",
" {\"nom\": \"Robot Restaurant\", \"prix\": 80, \"duree\": 2, \"type\": \"spectacle\"}\n",
" ],\n",
" \"Barcelone\": [\n",
" {\"nom\": \"Sagrada Familia\", \"prix\": 26, \"duree\": 2, \"type\": \"monument\"},\n",
" {\"nom\": \"Parc Guell\", \"prix\": 10, \"duree\": 2, \"type\": \"parc\"},\n",
" {\"nom\": \"Camp Nou\", \"prix\": 28, \"duree\": 2, \"type\": \"sport\"}\n",
" ],\n",
" \"Rome\": [\n",
" {\"nom\": \"Colisee\", \"prix\": 16, \"duree\": 2, \"type\": \"monument\"},\n",
" {\"nom\": \"Vatican\", \"prix\": 20, \"duree\": 4, \"type\": \"monument\"},\n",
" {\"nom\": \"Fontaine de Trevi\", \"prix\": 0, \"duree\": 1, \"type\": \"monument\"}\n",
" ]\n",
"}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 1 - Exploration des données (25 min)\n",
"\n",
"### 1.1 Affichage d'une ville (4 pts)\n",
"\n",
"Écrivez une fonction `afficher_ville(ville)` qui affiche les informations d'une ville.\n",
"\n",
"Exemple :\n",
"```\n",
"Tokyo (Japon)\n",
"Langue : Japonais | Monnaie : JPY\n",
"Decalage horaire : +8h\n",
"```\n",
"\n",
"*Rappel : ville[0] = nom, ville[1] = pays, ville[2] = langue, ville[3] = monnaie, ville[4] = decalage*"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def afficher_ville(ville):\n",
" nom = ville[0]\n",
" pays = ville[1]\n",
" langue = ville[2]\n",
" monnaie = ville[3]\n",
" decalage = ville[4]\n",
" \n",
" # Votre code ici : afficher les informations\n",
" pass\n",
"\n",
"# Test\n",
"afficher_ville(villes[3]) # Tokyo"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1.2 Rechercher une ville (4 pts)\n",
"\n",
"Écrivez une fonction `rechercher_ville(nom, villes)` qui renvoie le tuple de la ville correspondante, ou `None` si non trouvée."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def rechercher_ville(nom, villes):\n",
" for ville in villes:\n",
" # Votre code ici\n",
" pass\n",
" return None\n",
"\n",
"# Test\n",
"v = rechercher_ville(\"Rome\", villes)\n",
"if v:\n",
" afficher_ville(v)\n",
"print()\n",
"print(\"Madrid :\", rechercher_ville(\"Madrid\", villes))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1.3 Villes par monnaie (4 pts)\n",
"\n",
"Écrivez une fonction `villes_par_monnaie(villes, monnaie)` qui renvoie la liste des noms de villes utilisant cette monnaie."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def villes_par_monnaie(villes, monnaie):\n",
" resultats = []\n",
" \n",
" for ville in villes:\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return resultats\n",
"\n",
"# Test\n",
"print(\"Villes en zone Euro :\", villes_par_monnaie(villes, \"EUR\"))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 2 - Recherche d'hôtels et vols (35 min)\n",
"\n",
"### 2.1 Hôtels dans une ville (5 pts)\n",
"\n",
"Écrivez une fonction `hotels_ville(ville, hotels)` qui renvoie la liste des hôtels d'une ville, triés par note décroissante."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def hotels_ville(ville, hotels):\n",
" resultats = []\n",
" \n",
" for hotel in hotels:\n",
" # Votre code ici\n",
" pass\n",
" \n",
" # Trier par note decroissante\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return resultats\n",
"\n",
"# Test\n",
"print(\"Hotels a Paris :\")\n",
"for h in hotels_ville(\"Paris\", hotels):\n",
" print(\" \", h[\"nom\"], \"-\", h[\"etoiles\"], \"etoiles -\", h[\"prix_nuit\"], \"euros/nuit - Note:\", h[\"note\"])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2.2 Vols vers une destination (5 pts)\n",
"\n",
"Écrivez une fonction `vols_vers(destination, vols)` qui renvoie la liste des vols vers cette destination, triés par prix croissant.\n",
"\n",
"*Rappel : vol[2] = arrivee, vol[3] = prix*"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def vols_vers(destination, vols):\n",
" resultats = []\n",
" \n",
" for vol in vols:\n",
" # Votre code ici\n",
" pass\n",
" \n",
" # Trier par prix croissant\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return resultats\n",
"\n",
"# Test\n",
"print(\"Vols vers Tokyo :\")\n",
"for v in vols_vers(\"Tokyo\", vols):\n",
" escales = \"direct\" if v[4] == 0 else str(v[4]) + \" escale(s)\"\n",
" print(\" \", v[0], \":\", v[3], \"euros (\", escales, \")\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2.3 Vol le moins cher (5 pts)\n",
"\n",
"Écrivez une fonction `vol_moins_cher(destination, vols, direct_seulement)` qui renvoie le vol le moins cher vers une destination.\n",
"\n",
"Si `direct_seulement` est `True`, ne considérer que les vols sans escale."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def vol_moins_cher(destination, vols, direct_seulement):\n",
" meilleur = None\n",
" meilleur_prix = 999999\n",
" \n",
" for vol in vols:\n",
" if vol[2] == destination:\n",
" # Verifier si on veut que des vols directs\n",
" if direct_seulement and vol[4] > 0:\n",
" continue\n",
" \n",
" # Votre code ici : garder le vol le moins cher\n",
" pass\n",
" \n",
" return meilleur\n",
"\n",
"# Tests\n",
"vol = vol_moins_cher(\"New York\", vols, True)\n",
"if vol:\n",
" print(\"Vol direct le moins cher vers New York :\", vol[0], \"-\", vol[3], \"euros\")\n",
"\n",
"vol = vol_moins_cher(\"New York\", vols, False)\n",
"if vol:\n",
" print(\"Vol le moins cher vers New York (avec escales) :\", vol[0], \"-\", vol[3], \"euros\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2.4 Budget hotel (6 pts)\n",
"\n",
"Écrivez une fonction `hotels_budget(ville, hotels, budget_max, etoiles_min)` qui renvoie les hôtels correspondant aux critères, triés par prix croissant."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def hotels_budget(ville, hotels, budget_max, etoiles_min):\n",
" resultats = []\n",
" \n",
" for hotel in hotels:\n",
" # Verifier ville, budget et etoiles\n",
" # Votre code ici\n",
" pass\n",
" \n",
" # Trier par prix croissant\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return resultats\n",
"\n",
"# Test\n",
"print(\"Hotels a Paris, max 150 euros, min 3 etoiles :\")\n",
"for h in hotels_budget(\"Paris\", hotels, 150, 3):\n",
" print(\" \", h[\"nom\"], \"-\", h[\"prix_nuit\"], \"euros/nuit\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n",
"\n",
"## Exercice 3 - Bonus (20 min)\n",
"\n",
"### 3.1 Calculer le budget voyage (5 pts)\n",
"\n",
"Écrivez une fonction `calculer_budget(destination, nuits, vol, hotel, activites_choisies, activites)` qui calcule le budget total.\n",
"\n",
"Budget = prix vol + (prix hotel × nuits) + somme des activités"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def calculer_budget(destination, nuits, vol, hotel, activites_choisies, activites):\n",
" budget = {}\n",
" \n",
" # Vol\n",
" budget[\"vol\"] = vol[3]\n",
" \n",
" # Hotel\n",
" budget[\"hotel\"] = hotel[\"prix_nuit\"] * nuits\n",
" \n",
" # Activites\n",
" budget[\"activites\"] = 0\n",
" if destination in activites:\n",
" for act in activites[destination]:\n",
" # Votre code ici : ajouter le prix si l'activite est choisie\n",
" pass\n",
" \n",
" budget[\"total\"] = budget[\"vol\"] + budget[\"hotel\"] + budget[\"activites\"]\n",
" \n",
" return budget\n",
"\n",
"# Test\n",
"vol_choisi = vols[6] # Air France Paris-Tokyo\n",
"hotel_choisi = hotels[7] # Tokyo Garden\n",
"acts = [\"Temple Senso-ji\", \"Tokyo Skytree\"]\n",
"\n",
"budget = calculer_budget(\"Tokyo\", 5, vol_choisi, hotel_choisi, acts, activites)\n",
"print(\"Budget voyage Tokyo :\")\n",
"for poste, montant in budget.items():\n",
" print(\" \", poste, \":\", montant, \"euros\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 3.2 Activités gratuites (4 pts)\n",
"\n",
"Écrivez une fonction `activites_gratuites(activites)` qui renvoie la liste de toutes les activités gratuites (prix = 0).\n",
"\n",
"Renvoie une liste de dictionnaires `{\"ville\": ..., \"activite\": ...}`."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def activites_gratuites(activites):\n",
" gratuites = []\n",
" \n",
" for ville, liste_acts in activites.items():\n",
" for act in liste_acts:\n",
" # Votre code ici\n",
" pass\n",
" \n",
" return gratuites\n",
"\n",
"# Test\n",
"print(\"Activites gratuites :\")\n",
"for a in activites_gratuites(activites):\n",
" print(\" \", a[\"ville\"], \":\", a[\"activite\"])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 3.3 Destination la moins chère (5 pts)\n",
"\n",
"Écrivez une fonction `destination_moins_chere(vols, hotels, nuits)` qui trouve la destination la moins chère (vol + hotel × nuits).\n",
"\n",
"Pour chaque destination, prendre le vol le moins cher et l'hotel le moins cher."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def destination_moins_chere(vols, hotels, nuits):\n",
" # Trouver toutes les destinations\n",
" destinations = []\n",
" for vol in vols:\n",
" if vol[2] not in destinations:\n",
" destinations.append(vol[2])\n",
" \n",
" meilleure = None\n",
" meilleur_prix = 999999\n",
" \n",
" for dest in destinations:\n",
" # Trouver le vol le moins cher\n",
" vol = vol_moins_cher(dest, vols, False)\n",
" if vol == None:\n",
" continue\n",
" \n",
" # Trouver l'hotel le moins cher\n",
" hotels_dest = hotels_ville(dest, hotels)\n",
" if len(hotels_dest) == 0:\n",
" continue\n",
" \n",
" hotel_min = hotels_dest[0]\n",
" for h in hotels_dest:\n",
" if h[\"prix_nuit\"] < hotel_min[\"prix_nuit\"]:\n",
" hotel_min = h\n",
" \n",
" # Calculer le prix total\n",
" # Votre code ici : mettre a jour meilleure si prix_total est inferieur\n",
" prix_total = 0\n",
" \n",
" return meilleure\n",
"\n",
"# Test\n",
"dest = destination_moins_chere(vols, hotels, 3)\n",
"if dest:\n",
" print(\"Destination la moins chere pour 3 nuits :\")\n",
" print(\" Destination :\", dest[\"destination\"])\n",
" print(\" Vol :\", dest[\"vol\"], \"-\", dest[\"prix_vol\"], \"euros\")\n",
" print(\" Hotel :\", dest[\"hotel\"], \"-\", dest[\"prix_hotel\"], \"euros/nuit\")\n",
" print(\" Total :\", dest[\"total\"], \"euros\")"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"name": "python",
"version": "3.9.0"
}
},
"nbformat": 4,
"nbformat_minor": 4
}

336
representation_construits/evaluation/TP10_Voyage_aide.md Normal file
View File

@@ -0,0 +1,336 @@
# Aide - TP10 Planification de Voyage
## Rappels utiles
### Structure des villes (tuples)
```python
# Ville = (nom, pays, langue, monnaie, decalage_horaire)
ville = villes[0]
nom = ville[0] # "Paris"
pays = ville[1] # "France"
langue = ville[2] # "Francais"
monnaie = ville[3] # "EUR"
decalage = ville[4] # 0
# Parcourir les villes
for ville in villes:
print(ville[0], "-", ville[1])
```
### Structure des hotels (dictionnaires)
```python
hotels = {
"Paris": [
{"nom": "Hotel Lumiere", "etoiles": 4, "prix_nuit": 150, "services": ["wifi", "spa"], "note": 8.5},
{"nom": "Petit Paris", "etoiles": 2, "prix_nuit": 65, "services": ["wifi"], "note": 7.2}
],
"Londres": [...]
}
# Acceder aux hotels de Paris
hotels_paris = hotels["Paris"]
for h in hotels_paris:
print(h["nom"], "-", h["prix_nuit"], "euros/nuit")
```
### Structure des vols (tuples)
```python
# Vol = (compagnie, depart, arrivee, heure_depart, heure_arrivee, prix, escales)
vol = vols[0]
compagnie = vol[0] # "Air France"
depart = vol[1] # "Paris"
arrivee = vol[2] # "Londres"
heure_dep = vol[3] # "08:00"
heure_arr = vol[4] # "09:15"
prix = vol[5] # 120
escales = vol[6] # 0
```
### Structure des activites (dictionnaires)
```python
activites = {
"Paris": [
{"nom": "Tour Eiffel", "duree": 3, "prix": 25, "type": "monument"},
{"nom": "Louvre", "duree": 4, "prix": 17, "type": "musee"}
]
}
# Acceder aux activites d'une ville
acts_paris = activites.get("Paris", []) # [] si la ville n'existe pas
```
---
## Exercice 1
### 1.1 - Fiche destination
```python
def fiche_destination(nom_ville, villes, hotels, vols):
# Trouver la ville
ville = None
for v in villes:
if v[0] == nom_ville:
ville = v
break
if ville == None:
return "Ville non trouvee"
print("===", ville[0], "-", ville[1], "===")
print("Langue:", ville[2])
print("Monnaie:", ville[3])
print("Decalage horaire:", ville[4], "h")
# Compter les hotels
if nom_ville in hotels:
nb_hotels = len(hotels[nom_ville])
else:
nb_hotels = 0
print("Hotels disponibles:", nb_hotels)
# Compter les vols
nb_vols = 0
for vol in vols:
if vol[2] == nom_ville: # arrivee
nb_vols = nb_vols + 1
print("Vols disponibles:", nb_vols)
```
### 1.2 - Recherche de destinations
```python
def rechercher_destinations(villes, monnaie, decalage_max):
resultats = []
for ville in villes:
# Verifier la monnaie
if monnaie is not None and ville[3] != monnaie:
continue
# Verifier le decalage horaire
if decalage_max is not None and abs(ville[4]) > decalage_max:
continue
resultats.append(ville)
return resultats
```
### 1.3 - Statistiques
```python
def stats_base(villes, hotels, vols):
# Prix moyen des hotels
total_prix_hotels = 0
nb_hotels = 0
for ville, liste_hotels in hotels.items():
for h in liste_hotels:
total_prix_hotels = total_prix_hotels + h["prix_nuit"]
nb_hotels = nb_hotels + 1
if nb_hotels > 0:
prix_hotel_moyen = total_prix_hotels / nb_hotels
else:
prix_hotel_moyen = 0
# Prix moyen des vols
total_prix_vols = 0
for vol in vols:
total_prix_vols = total_prix_vols + vol[5]
if len(vols) > 0:
prix_vol_moyen = total_prix_vols / len(vols)
else:
prix_vol_moyen = 0
return {
"nb_destinations": len(villes),
"nb_hotels": nb_hotels,
"nb_vols": len(vols),
"prix_hotel_moyen": round(prix_hotel_moyen, 2),
"prix_vol_moyen": round(prix_vol_moyen, 2)
}
```
---
## Exercice 2
### 2.1 - Trouver les meilleurs vols
```python
def trouver_vols(vols, destination, critere):
# Filtrer les vols vers la destination
vols_dest = []
for v in vols:
if v[2] == destination:
vols_dest.append(v)
if critere == "prix":
vols_dest = sorted(vols_dest, key=lambda v: v[5])
elif critere == "direct":
# Direct d'abord (escales = 0), puis par prix
vols_dest = sorted(vols_dest, key=lambda v: (v[6], v[5]))
return vols_dest
```
### 2.2 - Trouver l'hotel ideal
```python
def trouver_hotel(hotels, ville, budget_nuit, services_requis, etoiles_min):
if ville not in hotels:
return []
resultats = []
for h in hotels[ville]:
# Verifier le budget
if budget_nuit is not None and h["prix_nuit"] > budget_nuit:
continue
# Verifier les etoiles
if etoiles_min is not None and h["etoiles"] < etoiles_min:
continue
# Verifier les services
if services_requis is not None:
a_tous_services = True
for service in services_requis:
if service not in h["services"]:
a_tous_services = False
break
if not a_tous_services:
continue
resultats.append(h)
# Trier par note decroissante
resultats = sorted(resultats, key=lambda h: h["note"], reverse=True)
return resultats
```
### 2.3 - Planifier les activites
```python
def planifier_activites(ville, activites, jours, budget_max):
if ville not in activites:
return {"planning": [], "budget_utilise": 0}
acts_ville = activites[ville]
# Trier par note ou popularite (ici par prix croissant comme exemple)
acts_triees = sorted(acts_ville, key=lambda a: a["prix"])
planning = []
budget_utilise = 0
for act in acts_triees:
if budget_utilise + act["prix"] <= budget_max:
planning.append(act)
budget_utilise = budget_utilise + act["prix"]
return {
"planning": planning,
"budget_utilise": budget_utilise
}
```
---
## Exercice 3 (Bonus)
### 3.1 - Calculer le budget total
```python
def calculer_budget(vol, hotel, nuits, activites_choisies, activites, ville):
budget = {
"vol": vol[5],
"hotel": hotel["prix_nuit"] * nuits,
"activites": 0
}
if ville in activites:
for act in activites[ville]:
if act["nom"] in activites_choisies:
budget["activites"] = budget["activites"] + act["prix"]
budget["total"] = budget["vol"] + budget["hotel"] + budget["activites"]
return budget
```
### 3.2 - Voyage optimal
```python
def voyage_optimal(destination, budget_max, nuits, villes, hotels, vols):
# Trouver les vols
vols_dest = []
for v in vols:
if v[2] == destination:
vols_dest.append(v)
if len(vols_dest) == 0:
return None
# Trouver les hotels
if destination not in hotels:
return None
hotels_dest = hotels[destination]
# Trier par prix
vols_dest = sorted(vols_dest, key=lambda v: v[5])
hotels_dest = sorted(hotels_dest, key=lambda h: h["prix_nuit"])
# Essayer les combinaisons
for vol in vols_dest:
for hotel in hotels_dest:
cout_base = vol[5] + hotel["prix_nuit"] * nuits
if cout_base <= budget_max:
return {
"destination": destination,
"vol": vol,
"hotel": hotel,
"budget_total": cout_base
}
return None
```
### 3.3 - Comparateur de destinations
```python
def comparer_destinations(destinations, budget, nuits, villes, hotels, vols, activites):
comparaison = []
for dest in destinations:
voyage = voyage_optimal(dest, budget, nuits, villes, hotels, vols)
if voyage != None:
# Compter les activites possibles
budget_restant = budget - voyage["budget_total"]
nb_acts = 0
if dest in activites:
for act in activites[dest]:
if act["prix"] <= budget_restant:
nb_acts = nb_acts + 1
# Score = note hotel + nb activites possibles
score = voyage["hotel"]["note"] + nb_acts * 0.5
comparaison.append({
"ville": dest,
"budget": voyage["budget_total"],
"note_hotel": voyage["hotel"]["note"],
"nb_activites": nb_acts,
"score": score
})
# Trier par score decroissant
comparaison = sorted(comparaison, key=lambda x: x["score"], reverse=True)
return comparaison
```
---
## Pieges a eviter
1. **Tuples immutables** : impossible de modifier `vol[5] = 100`
2. **Services = liste** : utilisez `in` pour verifier si un service est disponible
3. **Escales** : 0 = vol direct, > 0 = avec escale(s)
4. **Decalage horaire** : peut etre negatif (New York = -6)
5. **Activites par ville** : utilisez `.get(ville, [])` pour eviter KeyError si ville sans activites
6. **Budget** : vol + (hotel x nuits) + activites
7. **Acces par indice pour les tuples** : ville[0]=nom, ville[1]=pays, vol[5]=prix, etc.