edit cours compréhension et ajout exercices

2026-01-13 14:01:13 +01:00
parent 0399f4bd45
commit 9124579a03
3 changed files with 519 additions and 1 deletions
--- a/representation_construits/chapitre_3/README.md
+++ b/representation_construits/chapitre_3/README.md
@@ -33,7 +33,7 @@ On peut également accéder directement à l'abscisse ou à l'ordonnée d'un poi
 lst[2][1]
 ```

-Ici, on accède donc à la première valeur du tuple n°2.
+Ici, on accède donc à la seconde valeur (indice 1) du tuple n°2.

 --------

--- a/representation_construits/chapitre_3/exercices/CORRECTION.md
+++ b/representation_construits/chapitre_3/exercices/CORRECTION.md
@@ -0,0 +1,287 @@
+## Correction - Structures imbriquées et compréhensions
+
+---
+
+### Exercice 1 : Manipulation de structures imbriquées
+
+```python
+eleves = [
+    {"nom": "Dupont", "prenom": "Alice", "notes": [12, 15, 14, 18]},
+    {"nom": "Martin", "prenom": "Bob", "notes": [8, 11, 9, 13]},
+    {"nom": "Durand", "prenom": "Claire", "notes": [16, 17, 19, 15]},
+    {"nom": "Petit", "prenom": "David", "notes": [10, 12, 11, 14]}
+]
+```
+
+#### Question 1
+
+```python
+eleves[0]["prenom"]        # 'Alice'
+eleves[2]["notes"][0]      # 16
+len(eleves[1]["notes"])    # 4
+eleves[3]["nom"]           # 'Petit'
+```
+
+#### Question 2
+
+```python
+def moyenne_eleve(eleve):
+    """
+    Calcule la moyenne d'un élève
+    :param eleve: (dict) un dictionnaire représentant un élève
+    :return: (float) la moyenne des notes de l'élève
+    """
+    notes = eleve["notes"]
+    total = 0
+    for note in notes:
+        total = total + note
+    return total / len(notes)
+```
+
+#### Question 3
+
+```python
+def meilleur_eleve(eleves):
+    """
+    Trouve l'élève ayant la meilleure moyenne
+    :param eleves: (list) liste de dictionnaires représentant des élèves
+    :return: (str) le nom complet de l'élève avec la meilleure moyenne
+    """
+    meilleur = eleves[0]
+    meilleure_moyenne = moyenne_eleve(eleves[0])
+
+    for eleve in eleves:
+        moyenne = moyenne_eleve(eleve)
+        if moyenne > meilleure_moyenne:
+            meilleure_moyenne = moyenne
+            meilleur = eleve
+
+    return meilleur["prenom"] + " " + meilleur["nom"]
+```
+
+#### Question 4
+
+```python
+def eleves_au_dessus(eleves, seuil):
+    """
+    Renvoie les prénoms des élèves au-dessus du seuil
+    :param eleves: (list) liste de dictionnaires représentant des élèves
+    :param seuil: (float) la moyenne minimale
+    :return: (list) liste des prénoms des élèves au-dessus du seuil
+    """
+    resultat = []
+    for eleve in eleves:
+        if moyenne_eleve(eleve) >= seuil:
+            resultat.append(eleve["prenom"])
+    return resultat
+```
+
+---
+
+### Exercice 2 : Compréhensions de listes
+
+#### Question 1
+
+```python
+[i ** 2 for i in range(1, 21)]
+# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400]
+```
+
+#### Question 2
+
+```python
+[i for i in range(1, 51) if i % 2 == 0]
+# [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50]
+```
+
+#### Question 3
+
+```python
+mots = ["python", "java", "javascript", "c", "ruby", "go"]
+
+[mot for mot in mots if len(mot) > 4]
+# ['python', 'javascript', 'ruby']
+```
+
+#### Question 4
+
+```python
+[mot.upper() for mot in mots]
+# ['PYTHON', 'JAVA', 'JAVASCRIPT', 'C', 'RUBY', 'GO']
+```
+
+#### Question 5
+
+```python
+nombres = [3, -1, 4, -1, 5, -9, 2, 6, -5, 3]
+
+[n * 2 for n in nombres if n > 0]
+# [6, 8, 10, 4, 12, 6]
+```
+
+---
+
+### Exercice 3 : Compréhensions de dictionnaires
+
+#### Question 1
+
+```python
+{i: i ** 2 for i in range(1, 11)}
+# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100}
+```
+
+#### Question 2
+
+```python
+prenoms = ["Alice", "Bob", "Claire", "David"]
+
+{prenom: len(prenom) for prenom in prenoms}
+# {'Alice': 5, 'Bob': 3, 'Claire': 6, 'David': 5}
+```
+
+#### Question 3
+
+```python
+temperatures_c = {"Paris": 20, "Lyon": 22, "Marseille": 25, "Lille": 18}
+
+{ville: temp * 9/5 + 32 for ville, temp in temperatures_c.items()}
+# {'Paris': 68.0, 'Lyon': 71.6, 'Marseille': 77.0, 'Lille': 64.4}
+```
+
+#### Question 4
+
+```python
+notes = {"Alice": 15, "Bob": 8, "Claire": 12, "David": 17, "Eve": 9}
+
+{nom: note for nom, note in notes.items() if note >= 10}
+# {'Alice': 15, 'Claire': 12, 'David': 17}
+```
+
+---
+
+### Exercice 4 : Structures complexes
+
+```python
+tournoi = {
+    "nom": "Championship 2024",
+    "jeu": "League of Legends",
+    "equipes": [
+        {
+            "nom": "Team Alpha",
+            "joueurs": ["Faker", "Zeus", "Oner"],
+            "victoires": 5
+        },
+        {
+            "nom": "Team Beta",
+            "joueurs": ["Caps", "Jankos", "Mikyx"],
+            "victoires": 3
+        },
+        {
+            "nom": "Team Gamma",
+            "joueurs": ["Chovy", "Deft", "Keria"],
+            "victoires": 4
+        }
+    ]
+}
+```
+
+#### Question 1
+
+```python
+tournoi["nom"]                          # 'Championship 2024'
+len(tournoi["equipes"])                  # 3
+tournoi["equipes"][0]["joueurs"][1]      # 'Zeus'
+tournoi["equipes"][2]["victoires"]       # 4
+```
+
+#### Question 2
+
+```python
+def equipe_gagnante(tournoi):
+    """
+    Trouve l'équipe avec le plus de victoires
+    :param tournoi: (dict) dictionnaire représentant le tournoi
+    :return: (str) le nom de l'équipe gagnante
+    """
+    equipes = tournoi["equipes"]
+    gagnante = equipes[0]
+
+    for equipe in equipes:
+        if equipe["victoires"] > gagnante["victoires"]:
+            gagnante = equipe
+
+    return gagnante["nom"]
+```
+
+#### Question 3
+
+```python
+def tous_les_joueurs(tournoi):
+    """
+    Renvoie la liste de tous les joueurs du tournoi
+    :param tournoi: (dict) dictionnaire représentant le tournoi
+    :return: (list) liste de tous les joueurs
+    """
+    return [joueur for equipe in tournoi["equipes"] for joueur in equipe["joueurs"]]
+```
+
+Ou en version sans double compréhension :
+
+```python
+def tous_les_joueurs(tournoi):
+    """
+    Renvoie la liste de tous les joueurs du tournoi
+    :param tournoi: (dict) dictionnaire représentant le tournoi
+    :return: (list) liste de tous les joueurs
+    """
+    resultat = []
+    for equipe in tournoi["equipes"]:
+        for joueur in equipe["joueurs"]:
+            resultat.append(joueur)
+    return resultat
+```
+
+#### Question 4
+
+```python
+def ajouter_victoire(tournoi, nom_equipe):
+    """
+    Ajoute une victoire à l'équipe spécifiée
+    :param tournoi: (dict) dictionnaire représentant le tournoi
+    :param nom_equipe: (str) le nom de l'équipe
+    """
+    for equipe in tournoi["equipes"]:
+        if equipe["nom"] == nom_equipe:
+            equipe["victoires"] = equipe["victoires"] + 1
+```
+
+---
+
+### Exercice 5 : Double compréhension (Pour aller plus loin)
+
+#### Question 1
+
+```python
+[(x, y) for x in range(3) for y in range(3)]
+# [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
+```
+
+#### Question 2
+
+```python
+[[1 if i == j else 0 for j in range(4)] for i in range(4)]
+# [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]
+```
+
+#### Question 3
+
+```python
+matrice = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+
+[element for ligne in matrice for element in ligne]
+# [1, 2, 3, 4, 5, 6, 7, 8, 9]
+```
+
+---
+
+Source : Florian Mathieu - Licence CC BY NC SA
--- a/representation_construits/chapitre_3/exercices/README.md
+++ b/representation_construits/chapitre_3/exercices/README.md
@@ -0,0 +1,231 @@
+## Exercices - Structures imbriquées et compréhensions
+
+---
+
+### Exercice 1 : Manipulation de structures imbriquées
+
+On considère la structure suivante représentant des élèves et leurs notes :
+
+```python
+eleves = [
+    {"nom": "Dupont", "prenom": "Alice", "notes": [12, 15, 14, 18]},
+    {"nom": "Martin", "prenom": "Bob", "notes": [8, 11, 9, 13]},
+    {"nom": "Durand", "prenom": "Claire", "notes": [16, 17, 19, 15]},
+    {"nom": "Petit", "prenom": "David", "notes": [10, 12, 11, 14]}
+]
+```
+
+#### Question 1
+
+Sans exécuter le code, déterminer ce que renvoient les instructions suivantes :
+
+```python
+eleves[0]["prenom"]
+eleves[2]["notes"][0]
+len(eleves[1]["notes"])
+eleves[3]["nom"]
+```
+
+#### Question 2
+
+Écrire une fonction `moyenne_eleve(eleve)` qui prend un dictionnaire représentant un élève et renvoie sa moyenne.
+
+```python
+>>> moyenne_eleve(eleves[0])
+14.75
+```
+
+#### Question 3
+
+Écrire une fonction `meilleur_eleve(eleves)` qui prend la liste des élèves et renvoie le nom complet (prénom + nom) de l'élève ayant la meilleure moyenne.
+
+```python
+>>> meilleur_eleve(eleves)
+'Claire Durand'
+```
+
+#### Question 4
+
+Écrire une fonction `eleves_au_dessus(eleves, seuil)` qui renvoie la liste des prénoms des élèves ayant une moyenne supérieure ou égale au seuil.
+
+```python
+>>> eleves_au_dessus(eleves, 14)
+['Alice', 'Claire']
+```
+
+---
+
+### Exercice 2 : Compréhensions de listes
+
+#### Question 1
+
+Écrire en compréhension une liste contenant les carrés des entiers de 1 à 20.
+
+#### Question 2
+
+Écrire en compréhension une liste contenant uniquement les nombres pairs de 1 à 50.
+
+#### Question 3
+
+Soit la liste suivante :
+
+```python
+mots = ["python", "java", "javascript", "c", "ruby", "go"]
+```
+
+Écrire en compréhension une liste contenant uniquement les mots de plus de 4 caractères.
+
+#### Question 4
+
+Écrire en compréhension une liste contenant les mots de la liste précédente, mais en majuscules.
+
+#### Question 5
+
+Soit la liste suivante :
+
+```python
+nombres = [3, -1, 4, -1, 5, -9, 2, 6, -5, 3]
+```
+
+Écrire en compréhension une liste contenant uniquement les nombres positifs, multipliés par 2.
+
+---
+
+### Exercice 3 : Compréhensions de dictionnaires
+
+#### Question 1
+
+Écrire en compréhension un dictionnaire associant chaque entier de 1 à 10 à son carré.
+
+```python
+>>> # Résultat attendu
+{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100}
+```
+
+#### Question 2
+
+Soit la liste suivante :
+
+```python
+prenoms = ["Alice", "Bob", "Claire", "David"]
+```
+
+Écrire en compréhension un dictionnaire associant chaque prénom à sa longueur.
+
+```python
+>>> # Résultat attendu
+{'Alice': 5, 'Bob': 3, 'Claire': 6, 'David': 5}
+```
+
+#### Question 3
+
+Soit le dictionnaire suivant représentant des températures en Celsius :
+
+```python
+temperatures_c = {"Paris": 20, "Lyon": 22, "Marseille": 25, "Lille": 18}
+```
+
+Écrire en compréhension un dictionnaire convertissant ces températures en Fahrenheit.
+
+Rappel : F = C × 9/5 + 32
+
+#### Question 4
+
+Soit le dictionnaire suivant :
+
+```python
+notes = {"Alice": 15, "Bob": 8, "Claire": 12, "David": 17, "Eve": 9}
+```
+
+Écrire en compréhension un dictionnaire ne contenant que les élèves ayant une note supérieure ou égale à 10.
+
+---
+
+### Exercice 4 : Structures complexes
+
+On représente un tournoi de jeux vidéo avec la structure suivante :
+
+```python
+tournoi = {
+    "nom": "Championship 2024",
+    "jeu": "League of Legends",
+    "equipes": [
+        {
+            "nom": "Team Alpha",
+            "joueurs": ["Faker", "Zeus", "Oner"],
+            "victoires": 5
+        },
+        {
+            "nom": "Team Beta",
+            "joueurs": ["Caps", "Jankos", "Mikyx"],
+            "victoires": 3
+        },
+        {
+            "nom": "Team Gamma",
+            "joueurs": ["Chovy", "Deft", "Keria"],
+            "victoires": 4
+        }
+    ]
+}
+```
+
+#### Question 1
+
+Écrire les instructions permettant d'accéder à :
+- Le nom du tournoi
+- Le nombre d'équipes participantes
+- Le nom du deuxième joueur de la première équipe
+- Le nombre de victoires de "Team Gamma"
+
+#### Question 2
+
+Écrire une fonction `equipe_gagnante(tournoi)` qui renvoie le nom de l'équipe ayant le plus de victoires.
+
+#### Question 3
+
+Écrire une fonction `tous_les_joueurs(tournoi)` qui renvoie la liste de tous les joueurs du tournoi (en utilisant une compréhension).
+
+#### Question 4
+
+Écrire une fonction `ajouter_victoire(tournoi, nom_equipe)` qui ajoute une victoire à l'équipe spécifiée.
+
+---
+
+### Exercice 5 : Double compréhension (Pour aller plus loin)
+
+#### Question 1
+
+Écrire en compréhension une liste contenant toutes les coordonnées (x, y) d'une grille 3×3, sous forme de tuples.
+
+```python
+>>> # Résultat attendu
+[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
+```
+
+#### Question 2
+
+Écrire en compréhension une matrice identité 4×4 (1 sur la diagonale, 0 ailleurs).
+
+```python
+>>> # Résultat attendu
+[[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]
+```
+
+#### Question 3
+
+Soit la matrice suivante :
+
+```python
+matrice = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+```
+
+Écrire en compréhension une liste contenant tous les éléments de la matrice "aplatis" en une seule liste.
+
+```python
+>>> # Résultat attendu
+[1, 2, 3, 4, 5, 6, 7, 8, 9]
+```
+
+---
+
+Source : Florian Mathieu - Licence CC BY NC SA