Mise à jour du cours 4

7676c9ed · BERNHARD Delphine · 0baa2e1f · 7676c9ed
Commit 7676c9ed authored 2 years ago by BERNHARD Delphine
--- a/4_Listes.ipynb
+++ b/4_Listes.ipynb
@@ -30,7 +30,6 @@
    "1. [✏️ Exercice : conversion jours-heures-minutes-secondes](#ex_conversion_jhms)\n",
    "1. [✏️ Exercice : décomposition d'un montant](#ex_decomposition_montant)\n",
    "1. [✏️ Exercice : conversion nombres romains](#ex_conversion_romains)\n",
-    "1. [✏️ Exercice noté : saisie de mots ](#ex_saisie_mots)\n",
    "\n",
    "## Qu'est-ce qu'une liste ? <a name=\"definition\"></a>\n",
    "Les listes permettent de stocker des séquences, c'est-à-dire des collections finies d'éléments ordonnés selon un ordre précis. Les éléments sont stockés dans des \"cellules\" ordonnées et indicées. L'indice est le numéro d'emplacement d'un élément dans la séquence. Il s'agit d'un entier positif ou négatif. Lorsque l'on déclare une liste, les éléments sont séparés par des virgules et l'ensemble est entouré par des crochets."

 %% Cell type:markdown id: tags:

 # Listes

 ## Sommaire
 1. [Qu'est-ce qu'une liste ?](#definition)
 1. [Ajout d'éléments à une liste](#ajout)
 1. [Suppression d'éléments](#suppression)
 1. [Longueur d'une liste](#longueur)
 1. [Concaténation de listes](#concatenation)
 1. [Tri de listes](#tri)
 1. [Assemblage de liste avec `join`](#join)
 1. [✏️ Exercice : liste de livres](#ex_livres)
 1. [✏️ Exercice : affichage du mois](#ex_aff_mois)
 1. [✏️ Exercice : traduction des jours de la semaine](#ex_jours_semaine)
 1. [Notion de pile](#pile)
 1. [Notion de file](#file)
 1. [Parcours de liste](#parcours)
  1. [Notion de parcours](#notion_parcours)
  1. [L'instruction for...in](#for_in)
  1. [Utilisation de `range` dans une boucle for](#range)
 1. [✏️ Exercice : traduction des jours de la semaine](#ex_traduction)
 1. [✏️ Exercice : conjugaison des verbes du deuxième groupe](#ex_conjugaison2)
 1. [✏️ Exercice : poids sur la Lune](#ex_poids_lune)
 1. [Division entière et modulo](#div)
 1. [✏️ Exercice : conversion jours-heures-minutes-secondes](#ex_conversion_jhms)
 1. [✏️ Exercice : décomposition d'un montant](#ex_decomposition_montant)
 1. [✏️ Exercice : conversion nombres romains](#ex_conversion_romains)
-1. [✏️ Exercice noté : saisie de mots ](#ex_saisie_mots)

 ## Qu'est-ce qu'une liste ? <a name="definition"></a>
 Les listes permettent de stocker des séquences, c'est-à-dire des collections finies d'éléments ordonnés selon un ordre précis. Les éléments sont stockés dans des "cellules" ordonnées et indicées. L'indice est le numéro d'emplacement d'un élément dans la séquence. Il s'agit d'un entier positif ou négatif. Lorsque l'on déclare une liste, les éléments sont séparés par des virgules et l'ensemble est entouré par des crochets.

 %% Cell type:code id: tags:

 ``` python
 jours = ["lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi", "dimanche"]
 ```

 %% Cell type:markdown id: tags:

 Indices de la liste :

 | lundi | mardi  | mercredi  | jeudi  | vendredi  | samedi  | dimanche  |
 |---|---|---|---|---|---|---|
 | 0  | 1  | 2  | 3  | 4  | 5  | 6  |

 %% Cell type:markdown id: tags:

 Le premier indice de la liste est `0` :

 %% Cell type:code id: tags:

 ``` python
 print(jours[0]) # Affiche lundi
 print(jours[6]) # Affiche dimanche
 print(jours[7]) # IndexError : il n'y a pas d'élément d'indice 7 dans la liste
 ```

 %% Cell type:markdown id: tags:

 Les listes sont modifiables et il est donc possible de changer le contenu d'une "cellule" :

 %% Cell type:code id: tags:

 ``` python
 jours[0] = "Monday"
 print(jours) # Affiche ['Monday', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche']
 ```

 %% Cell type:markdown id: tags:

 On peut également récupérer des sous-séquences d'une liste, appelées tranches (*slices*). Par exemple, pour récupérer les 5 premiers éléments (à noter que l'élément d'indice 5 est exclu) :

 %% Cell type:code id: tags:

 ``` python
 print(jours[0:5]) # Affiche ['Monday', 'mardi', 'mercredi', 'jeudi', 'vendredi']
 ```

 %% Cell type:markdown id: tags:

 On peut également faire des listes de listes :

 %% Cell type:code id: tags:

 ``` python
 fr = ["chat", "chien", "cheval"]
 en = ["cat", "dog", "horse"]
 de = ["Katze", "Hund", "Pferd"]
 animaux = [fr, en, de]
 print(animaux) # Affiche [['chat', 'chien', 'cheval'], ['cat', 'dog', 'horse'], ['Katze', 'Hund', 'Pferd']]
 print(animaux[1][2]) # Affiche horse
 ```

 %% Cell type:markdown id: tags:

 ## Ajout d'éléments à une liste <a name="ajout"></a>
 L'ajout d'éléments à une liste se fait à l'aide de la méthode `append()`. Une méthode est un code prédéfini qui réalise une action donnée.

 %% Cell type:code id: tags:

 ``` python
 fr.append("vache")
 print(fr) # Affiche ['chat', 'chien', 'cheval', 'vache']
 ```

 %% Cell type:markdown id: tags:

 Il est également possible d'insérer des éléments à une position donnée :

 %% Cell type:code id: tags:

 ``` python
 fr.insert(1, "hamster")
 print(fr)
 ```

 %% Cell type:markdown id: tags:

 ## Suppression d'éléments <a name="suppression"></a>
 La suppression se fait à l'aide du mot-clé `del`.

 %% Cell type:code id: tags:

 ``` python
 del(fr[1])
 print(fr)
 ```

 %% Cell type:markdown id: tags:

 Il est également possible d'utiliser la méthode `remove` (seul le premier élément correspondant est supprimé) :

 %% Cell type:code id: tags:

 ``` python
 fr.remove('vache')
 print(fr)
 ```

 %% Cell type:markdown id: tags:

 ## Longueur d'une liste <a name="longueur"></a>

 %% Cell type:markdown id: tags:

 La longueur d'une liste, c'est-à-dire le nombre d'éléments qu'elle contient, s'obtient à l'aide de la méthode `len()` :

 %% Cell type:code id: tags:

 ``` python
 print(len(fr))
 ```

 %% Cell type:markdown id: tags:

 ## Concaténation de listes <a name="concatenation"></a>
 Il est possible de concaténer des listes à l'aide de l'opérateur d'addition `+` :

 %% Cell type:code id: tags:

 ``` python
 fruits = ["pomme", "poire", "banane"]
 legumes = ["poireau", "chou", "carotte"]
 ingredients = fruits + legumes
 print(ingredients)
 ```

 %% Cell type:markdown id: tags:

 ## Tri de listes <a name="tri"></a>
 Les listes peuvent être triées à l'aide `sort()` :

 %% Cell type:code id: tags:

 ``` python
 ingredients.sort()
 print(ingredients)
 ```

 %% Cell type:markdown id: tags:

 ## Assemblage de liste avec `join` <a name="join"></a>
 `join()`permet d'assembler les éléments d'une liste à l'aide d'un séparateur donné

 %% Cell type:code id: tags:

 ``` python
 # Assemblage avec ;
 ";".join(['un', 'deux', 'trois', 'quatre', 'cinq'])
 ```

 %% Cell type:code id: tags:

 ``` python
 # Assemblage avec une tabulation
 s = "\t".join(['un', 'deux', 'trois', 'quatre', 'cinq'])
 print(s)
 ```

 %% Cell type:code id: tags:

 ``` python
 # Assemblage avec un saut de ligne
 s = "\n".join(['un', 'deux', 'trois', 'quatre', 'cinq'])
 print(s)
 ```

 %% Cell type:code id: tags:

 ``` python
 # ATTENTION : tous les éléments de la liste doivent être des chaînes de caractères
 s = "\n".join([1, 2, 3, 4, 5])
 print(s)
 ```

 %% Cell type:markdown id: tags:

 ## ✏️ Exercice : liste de livres <a name="ex_livres"></a>
 Créer une variable appelée `bons_livres` sous forme de liste vide. Ajouter vos livres préférés à la liste (au moins 3) puis afficher les deux derniers livres ajoutés à la liste.

 %% Cell type:code id: tags:

 ``` python
 # Exercice : liste de livres
 bons_livres = []
 ```

 %% Cell type:markdown id: tags:

 ## ✏️ Exercice : affichage du mois <a name="ex_aff_mois"></a>
 Source : http://ressources.unisciel.fr/sillages/informatique/python/ch03_listes_fonctions/co/exercice_10_03.html

 Écrire un programme qui demande à l'utilisateur un numéro de mois (de 1 à 12), puis affiche : « Vous avez sélectionné le mois de : xxxxxx » (avec xxxxxx janvier si l'utilisateur a choisi 1, août si l'utilisateur a choisi 8...). Les mois seront stockés sous forme de liste.

 %% Cell type:code id: tags:

 ``` python
 # Exercice : affichage du mois
 ```

 %% Cell type:markdown id: tags:

 ## ✏️ Exercice : traduction des jours de la semaine <a name="ex_jours_semaine"></a>
 Écrire un programme qui affiche les traductions des jours de la semaine en anglais et français.
 Les affichages du programme devraient être les suivants :
 ```
 Il y a 7 jours dans la semaine
 Le dernier jour de la semaine est dimanche
 Affichage des traductions des jours de la semaine en anglais et en allemand
 Le mot "lundi" se traduit par "monday" en anglais et par "Montag" en allemand
 Le mot "mardi" se traduit par "tuesday" en anglais et par "Dienstag" en allemand
 Le mot "mercredi" se traduit par "wednesday" en anglais et par "Mittwoch" en allemand
 Le mot "jeudi" se traduit par "thursday" en anglais et par "Donnerstag" en allemand
 Le mot "vendredi" se traduit par "friday" en anglais et par "Freitag" en allemand
 Le mot "samedi" se traduit par "saturday" en anglais et par "Samstag" en allemand
 Le mot "dimanche" se traduit par "sunday" en anglais et par "Sonntag" en allemand
 ```
 Compléter le programme ci-dessous :

 %% Cell type:code id: tags:

 ``` python
 # Exercice : traduction des jours de la semaine
 jours = ["lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi", "dimanche"]
 days = ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"]
 tage = ["Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag", "Sonntag"]

 # à compléter

 print("Affichage des traductions des jours de la semaine en anglais et en allemand")
 # à compléter
 ```

 %% Cell type:markdown id: tags:

 ## Notion de pile <a name="pile"></a>
 Une pile (*stack* en anglais) est une structure de données ayant pour particularité que le dernier élément à y être entré sera le premier à en sortir (LIFO : *last in-first out*) comme pour une pile d'assiettes sur une étagère de placard. On peut récupérer l'élément qui se situe en haut de la pile (dépiler) mais pas les éléments qui se trouvent au milieu.
 <img src="attachment:pile.png" width="400">

 Il est possible d'utiliser une liste comme une pile. Pour empiler, on utilise la méthode `append()` :

 %% Cell type:code id: tags:

 ``` python
 fruits = ["pomme", "poire", "banane", "kiwi"]
 fruits.append("framboise")
 ```

 %% Cell type:markdown id: tags:

 Pour dépiler, on utilise la méthode `pop()` :

 %% Cell type:code id: tags:

 ``` python
 dernier_fruit = fruits.pop()
 ```

 %% Cell type:markdown id: tags:

 ## Notion de file <a name="file"></a>
 Une file (*queue* en anglais) est une structure de données ayant pour particularité que le premier élément à y être entré sera le premier à en sortir (FIFO : *first in-first out*) comme pour une file d'attente  à la caisse d'un magasin.
 <img src="attachment:file.png" width="400">


 Il est possible d'utiliser une liste comme une file. Pour "enfiler", on utilise la méthode `append()` :

 %% Cell type:code id: tags:

 ``` python
 fruits = ["pomme", "poire", "banane", "kiwi"]
 fruits.append("framboise")
 ```

 %% Cell type:markdown id: tags:

 Pour "défiler", on utilise la méthode `pop()` :

 %% Cell type:code id: tags:

 ``` python
 fruits.pop(0)
 ```

 %% Cell type:markdown id: tags:

 ## Parcours de liste <a name="parcours"></a>
 ### Notion de parcours <a name="notion_parcours"></a>
 Le parcours permet d'appliquer le même traitement sur chaque élément d'une séquence, sans avoir à écrire plusieurs fois le même code. Par exemple, le parcours peut permettre d'afficher chaque élément d'une liste.
 ### L'instruction for...in <a name="for_in"></a>
 L'instruction `for` permet d'itérer sur l'ensemble des éléments d'une séquence :

 %% Cell type:code id: tags:

 ``` python
 fruits = ["pomme", "poire", "banane", "kiwi"]
 for f in fruits:
    print(f)
 ```

 %% Cell type:markdown id: tags:

 A chaque tour de boucle, la variable `f` prendra la valeur d'un élément de la liste. La liste est parcourue dans l'ordre. Toutes les lignes d'instruction qui se situent à l'intérieur de la boucle doivent commencer par une indentation (touche tabulation).

 %% Cell type:markdown id: tags:

 ### Utilisation de `range` dans une boucle for <a name="range"></a>
 Il est également possible de parcourir un tableau en itérant sur les indices :

 %% Cell type:code id: tags:

 ``` python
 fruits = ["pomme", "poire", "banane", "kiwi"]
 for i in range(len(fruits)):
    print(fruits[i])
 ```

 %% Cell type:markdown id: tags:

 `range` renvoie ici un itérateur, c'est-à-dire un objet particulier qui à chaque itération va renvoyer l'élément suivant dans la séquence (ici la séquence sera constituée par la suite d'entiers qui varie de 0 au dernier indice dans la liste `fruits`). L'avantage de cette méthode est que l'on connaît la position (l'indice) de l'élément dans la liste.

 On peut aussi utiliser range pour faire un nombre donné d'itérations, comme suit :

 %% Cell type:code id: tags:

 ``` python
 for x in range(0,5):
    print(f'Bonjour {x}')
 ```

 %% Cell type:markdown id: tags:

 `range(0,5)` indique que le comptage doit démarrer à 0 et se terminer avant d'atteindre 5.

 %% Cell type:markdown id: tags:

 ## ✏️ Exercice : traduction des jours de la semaine <a name="ex_traduction"></a>
 Reprendre l'exercice sur la traduction des jours de la semaine en utilisant une boucle `for`

 %% Cell type:code id: tags:

 ``` python
 # Exercice : traduction des jours de la semaine avec boucle for
 ```

 %% Cell type:markdown id: tags:

 ## ✏️Exercice : conjugaison des verbes du deuxième groupe <a name="ex_conjugaison2"></a>
 Écrire un programme Python pour la conjugaison des verbes du deuxième groupe. Les affichages et entrées de l'utilisateur sont détaillés ci-dessous, l'infinitif du verbe est entré par l'utilisateur :
 ```
 Entrez l'infinitif d'un verbe du deuxième groupe :
 bondir
 La conjugaison de "bondir" au présent de l'indicatif :
 je bondis
 tu bondis
 il/elle/on bondit
 nous bondissons
 vous bondissez
 ils/elles bondissent
 ```
 Pour cela, vous aurez besoin d'une liste qui contient les pronoms personnels du français ("je", "tu", "il/elle/on", "nous", "vous", "ils/elles"), et d'une liste qui contient les terminaisons des verbes du deuxième groupe ("is", "is, "it", "issons", "issez", "issent").

 %% Cell type:code id: tags:

 ``` python
 # Exercice : conjugaison des verbes du deuxième groupe

 pronoms = ["je", "tu", "il/elle/on", "nous", "vous", "ils/elles"]
 terminaisons = ["is", "is", "it", "issons", "issez", "issent"]

 verbe = input("Entrez l'infinitif d'un verbe du deuxième groupe : ")
 # Compléter ci-dessous

 print('La conjugaison de "'+verbe+'" au présent de l\'indicatif :')
 # Compléter ci-dessous
 ```

 %% Cell type:markdown id: tags:

 ## ✏️ Exercice : poids sur la Lune <a name="ex_poids_lune"></a>
 Le poids (exprimé en Newton N) se calcule en multipliant la masse (exprimée en kg) par l'accélération de la pesanteur (cf. http://phys.free.fr/maspoids.htm). L'accélération de la pesanteur de la Lune est six fois moins importante que celle de la Terre. Par conséquent, une personne "pèse" six fois moins lourd sur la Lune que sur la Terre : une personne qui a une masse de 70kg a un poids de 687 N sur la Terre et de 112 N sur la Lune.

 Supposons maintenant que cette personne prend un kilo par an pendant les 15 prochaines années. Écrire un programme qui utilise une boucle `for` pour afficher la masse, le poids sur la Terre et le poids sur la Lune pour chacune de ces années.

 L'affichage obtenu devrait être le suivant :
 ```
 La masse initiale est de 70 kg
 Le poids initial sur la Terre est de 687.00 N
 Le poids initial sur la Lune est de 112.00 N
 ****
 An 1
 Masse : 71 kg
 Poids sur la Terre : 696.81 N
 Poids sur la Lune : 113.60 N
 ****
 An 2
 Masse : 72 kg
 Poids sur la Terre : 706.63 N
 Poids sur la Lune : 115.20 N
 ....
 ```

 %% Cell type:code id: tags:

 ``` python
 # Exercice : poids sur la Lune
 ```

 %% Cell type:markdown id: tags:

 ## Division entière et modulo <a name="div"></a>
 L'opération modulo (notée `%`) correspond au reste de la division de nombres entiers. Par exemple, `11 % 3` donne `2`, car `11 = 3 x 3 + 2`.

 Il est également possible de faire une division entière, afin de trouver le quotient :

 %% Cell type:code id: tags:

 ``` python
 20 // 3 # donne 6 car 20 = 6 * 3 + 2
 ```

 %% Cell type:markdown id: tags:

 Notez la différence avec la division décimale (le résultat est un nombre décimal) :

 %% Cell type:code id: tags:

 ``` python
 20 / 3 # donne 6.666666666666667
 ```

 %% Cell type:markdown id: tags:

 Il est également possible d'obtenir directement à la fois le quotient et le reste d'une division entière à l'aide de la fonction prédéfinie `divmod()` :

 %% Cell type:code id: tags:

 ``` python
 x = divmod(20, 3)
 print(x[0])
 print(x[1])
 (q,r) = divmod(20,3)
 print(q)
 ```

 %% Cell type:markdown id: tags:

 `divmod` renvoie la paire (`q`, `r`) où q est le quotient et r le reste.

 %% Cell type:markdown id: tags:

 ## ✏️ Exercice : conversion jours-heures-minutes-secondes <a name="ex_conversion_jhms"></a>
 Écrire un programme qui, pour un nombre donné de secondes inférieur à 1 000 000 calcule son équivalent en jour(s), heure(s), minute(s) et seconde(s).
 Par exemple, étant donné le nombre 309 639, le programme devra afficher "3 jours 14 heures 0 minutes et 39 secondes".
 Rappel :
  * 1 minute = 60 secondes
  * 1 heure = 60 minutes = 3600 secondes
  * 1 jour = 24 heures = 1440 minutes = 86400 secondes

 %% Cell type:code id: tags:

 ``` python
 # Exercice : conversion jours-heures-minutes-secondes
 ```

 %% Cell type:markdown id: tags:

 ## ✏️ Exercice : décomposition d'un montant <a name="ex_decomposition_montant"></a>
 Écrire un programme afin d'aider les caissiers et caissières d'un magasin à minimiser le nombre de pièces et de billets lorsqu'ils et elles rendent la monnaie. Par exemple, 58 € se décompose en 1 billet de 50 €, 1 billet de 5 €, 1 pièce de 2 € et 1 pièce de 1 €. Pour simplifier, on ne va considérer que les montants sans centimes. Les caissiers et caissières disposent des billets et des pièces suivants : 50, 20, 10, 5, 2 et 1 €.

 Exemple d'affichage :
 ```
 Veuillez entrer le montant : 28
 La décomposition du montant est la suivante :
 0 fois 50 €
 1 fois 20 €
 0 fois 10 €
 1 fois 5 €
 1 fois 2 €
 1 fois 1 €
 ```

 %% Cell type:code id: tags:

 ``` python
 # Exercice : décomposition d'un montant
 ```

 %% Cell type:markdown id: tags:

 ## ✏️ Exercice : conversion nombres romains <a name="ex_conversion_romains"></a>
 Écrire un programme qui convertit un entier compris entre 1 et 3 999 sous forme de nombre romain.
 La numérotation romaine dispose des 7 symboles suivants :

 | Symbole | Valeur |
 | ------- | ------ |
 | I | 1 |
 | V | 5 |
 | X | 10 |
 | L | 50 |
 | C | 100 |
 | D | 500 |
 | M | 1000 |

 Un nombre romain est composé suivant les règles suivantes :
  * Les symboles sont écrits du plus grand au plus petit et leur valeur s'ajoute. Par exemple, 123 s'écrit C XX III
  * Il n'est pas possible d'utiliser plus de trois symboles identiques à la suite : on utilise alors la notation soustractive. Dans ce cas, un symbole placé directement avant un symbole plus grand lui est retranché. Par exemple, 400 s'écrit CD au lieu de CCCC

 Vous pouvez vérifier les conversions sur le site suivant : https://www.periodni.com/fr/convertisseur_chiffres_romains.html

 **Indice 1 :**
 Utilisez deux listes, l'une pour les symboles et l'autre pour les valeurs correspondantes :

 %% Cell type:code id: tags:

 ``` python
 tab_symboles = ['M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I']
 tab_valeurs = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
 ```

 %% Cell type:markdown id: tags:

 **Indice 2 :** utilisez `divmod`

 %% Cell type:code id: tags:

 ``` python
 # Exercice : conversion nombres romains
 ```