ajout exercices, corrections diverses, glossaire

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

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

representation_construits/evaluation/TP06_Pokemon_aide.md

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