tp 1

src/cours/CIEL1/01-bases-python/tp/01_decouverte.md

@@ -129,11 +129,11 @@ Nous allons donc affecter et utiliser nos premières variables.
 2. Essayez d'entrer un nom de variable **illégal** (c'est à dire qu'il n'est pas autorisé dans le langage et qu'il causera une erreur). Notez-le. Que se passe-t-il ?
 3. Essayez d'écrire `3 = x`. que se passe-t-il ?
 4. Ecrivez le code suivant. Expliquez ce qu'il fait
-~~~python
->>> mon_age = 19
->>> mon_age = mon_age * 2
->>> mon_age
-~~~
+    ~~~python
+    >>> mon_age = 19
+    >>> mon_age = mon_age * 2
+    >>> mon_age
+    ~~~
 5. 
     a. Le code suivant calcule le prix TTC d'un article à partir de sont prix hors taxes (45€), en lui ajoutant la TVA. Ecrivez-le dans l'interpréteur. Quel résultat obtenez-vous pour le prix TTC ?
     ~~~python
@@ -189,19 +189,392 @@ Vous pourrez utiliser des `"` lorsque que votre chaîne contiendra des `'` et in
 - `'Elle a dit "Hello"'`
 ```
 
-
 ## Un premier script
-- print
-- chaines de caractères + formatage
+
+Pour la suite de ce TP nous allons arrêter d'utiliser l'interpréteur. L'interpréteur est très pratique pour tester des expressions ou des commandes. Mais il n'est pas pratique pour réexécuter ou modifier des programmes : il faut retaper toutes les commandes dans le bon ordre à chaque fois. Et en plus de ça, dès que l'on ferme l'interpréteur, tout ce qui a été écrit est perdu.
+
+Nous allons utiliser des fichiers, désormais, pour écrire nos programmes. Pour cela on peut utiliser n'importe quel **éditeur de texte**. 
+
+```admonish warning title="Important"
+Un **éditeur de texte** est différent d'un logiciel de **traitement de texte** comme peut l'être Microsoft Word ou Libre Office Writer. 
+
+Il permet d'écrire du texte brut, sans aucune mise en forme, contrairement aux logiciels de traitement de texte qui contiennent des informations invisibles. Pour écrire du code, il faut uniquement du texte brut, c'est pour cela qu'on utilisera un éditeur de texte : par exemple, on peut utiliser Thonny comme dans ce TP, ou Notepad++ ou Visual Studio Code sous Windows, Geany, Gedit, nano, vim ou également VSCode sous Linux. Il en existe plein d'autres, avec plus ou moins de fonctionnalités avancées.
+
+L'une d'entre elles, probablement la plus importante, c'est la **coloration syntaxique** : les mots du code sont colorés de différentes manières pour vous aider à identifier la structure et les mots clés, les variables etc... 
+```
+
+Dans Thonny, nous allons utiliser l'autre encadré, celui qui s'appelle `<sans nom>` pour l'instant. Nous verrons dans un prochain TP comment travailler avec Visual Studio Code, un logiciel très performant et puissant pour écrire du code. Pour l'instant, gardons les choses simples et continuons avec Thonny. Vous pouvez continuer à utiliser Thonny chez vous également, il comporte le nécessaire pour utiliser Python. 
+
+Nous allons donc écrire un premier fichier comportant du code que vous pourrez exécuter autant de fois que nécessaire pour le tester, le modifier etc. 
+
+```admonish success title="À retenir"
+Un fichier contenant du code Python s'appelle un **script**. Les scripts python ont un nom se finissant par l'**extension** `.py`
+```
+
+Pour commencer nous allons enregistrer notre script dans un fichier. Cliquez sur le bouton Enregistrer comme sur l'image ci-dessous. Vous pouvez aussi appuyer sur <kbd>CTRL</kbd>+<kbd>S</kbd>.
+
+![enregistrer le fichier](image-1.png)
+
+Allez dans votre espace personnel, choisissez un nom, par exemple `tp01-hello-world.py`, et cliquez sur `Sauvegarder`. Voilà, nous sommes prêts à travailler.
+
+### La fonction print
+
+```admonish travail
+1. Recopiez le code suivant, sauvegardez vos modifications, et cliquez sur le bouton en forme de rond vert avec un triangle à l'intérieur. Vous pouvez aussi appuyer sur <kbd>F5</kbd> pour exécuter le script. Que fait-il ?
+
+    ~~~python
+    print("Hello, world!")
+    ~~~
+
+    ![Exécuter votre script](image-2.png)
+
+2. Créez, à la suite du programme existant, une variable `a` à laquelle vous affecterez la valeur 3. Donnez maintenant l'expression pour d'afficher la valeur de `a` à l'aide de `print`.
+3. Copiez le programme suivant :
+    ~~~python
+    a = 3
+    print(a)
+    a = a + 3
+    b = a - 2
+    ~~~
+
+    Que valent `a` et `b` à votre avis ? Vérifiez à l'aide de print en écrivant la ligne suivante : `print("a =", a, "et b =", b)`
+
+4. Nous allons voir une autre manière d'écrire le print précédent, avec une **chaîne de caractères formatée**. Ajoutez la ligne : `print(f"a = {a} et b = {b}")`. Vérifiez que le résultat est bien identique au print précédent.
+
+5. Donnez le code qui permettra, sur le même modèle, d'afficher la chaîne `Je m'appelle <prénom>` où prénom sera remplacé par votre prénom.
+```
+
+```admonish question
+Pourquoi utiliser la fonction print, alors que dans l'interpréteur, écrire une chaîne de caractères ou le nom d'une variable permet déjà de l'afficher ?  
+```
+
+L'interpréteur affiche les valeurs des variables pour vous aider à comprendre les étapes du programme, mais dans un script cela n'aura aucun effet. De plus l'interpréteur affiche les guillemets, et parfois d'autres informations que vous ne voulez pas forcément voir affichées. La fonction print permet d'afficher les informations dans la console, et de les **formater** (c'est à dire les organiser) comme cela vous arrange.
+
+```admonish success title="À retenir"
+- La fonction `print` permet d'afficher des chaînes de caractères et/ou des variables.
+- Elle peut prendre plusieurs arguments, et affichera les arguments séparés par un espace
+- Elle peut également prendre une chaîne de caractères **formatée** : on l'écrira sous la forme `f"chaine de caractère {variable}"`, ce qui permettra de remplacer les variables entre accolades `{}` par leur valeur dans la chaîne de caractères. Le `f` avant les guillemets est important car il permet de dire à Python que la chaîne est formatée. Si vous l'oubliez, il ne cherchera pas à remplacer les variables par leur valeur.
+
+Les chaînes formatées sont très utilisées en python. Elles servent à afficher des informations dynamiques en fonction de variables, mais vous aideront aussi à comprendre ce que font vos programmes et vous aider à les corriger.
+```
+
+### La fonction input
+
+Pouvoir afficher du texte est déjà très bien, mais pouvoir en saisir est également très utile, par exemple pour que la personne qui utilisera votre programme puisse entrer des données sans modifier votre programme. Nous allons maintenant voir comment faire ça.
+
+- La fonction `input` permet de demander une saisie de texte dans la console, et il suffit de taper <kbd>Entrée</kbd> pour valider votre saisie.
+- Cette fonction prend un argument *optionnel* : une chaîne de caractères à afficher dans la console, pour dire ce que vous demandez de saisir. 
+- On peut affecter le résultat de input à une variable directement, comme dans l'exemple ci-dessous.
+
+```admonish travail
+1. Testons dans un premier temps dans l'interpréteur. Utilisez la fonction `type` pour vérifier le type de la variable `nombre`. Quel est ce type ? 
+    ~~~python
+    >>> nombre = input("Saisissez un nombre : ")
+    Saisissez un nombre : 42
+    ~~~
+2. Nous allons donc devoir convertir la variable `nombre` en un nombre entier. Pour cela, utilisons la fonction `int` sur `nombre`
+   ~~~python
+   >>> nombre = int(nombre)
+   ~~~
+3. Repassons sur un fichier de script : ouvrez un nouvel onglet, et sauvegardez le fichier sous le nom `tp01-input.py`. 
+
+    Ensuite, écrivez un programme permettant de saisir un nombre et de l'afficher avec `print`. Votre programme devra afficher `Vous avez entré le nombre : ` suivi du nombre saisi. Aidez vous des questions précédentes. 
+    
+    Mettez le script dans votre compte rendu.
+```
+
+```admonish success title="À retenir"
+- La fonction `input` permet de demander la personne utilisant votre programme de saisir du texte
+- Elle prend en argument optionnel une chaîne de caractère qui s'affichera avant la saisie
+- Elle renvoie ce qui a été saisi sous forme d'une chaîne de caractères. Il faut donc penser à convertir si vous avez besoin d'un autre type.
+- Le résultat de la fonction peut être immédiatement affecté à une variable.
+```
 
 ## Structure conditionnelle
-- if
-- if elif else
-- opérateurs de comparaison
-- booléens
-- opérateurs logiques and, or, not
+
+### if ... elif ... else ...
+Nous allons maintenant voir l'un des éléments les plus importants dans l'écriture d'un programme. Jusqu'à maintenant nos programmes exécutaient les instructions les unes à la suite des autres. Mais il est parfois pratique d'effectuer quelque chose dans un cas, et autre chose dans un autre cas. Pour cela, il nous faut un moyen de séparer les cas : les **structures conditionnelles**.
+
+En python, pour écrire une structure conditionnelle, on va utiliser le mot clé `if`, qui signifie "si" en anglais. Par exemple, pour faire quelque chose si une variable vaut `1`, on va écrire le programme suivant :
+
+```python
+ma_variable = 1
+if ma_variable == 1:
+    print("Ma variable vaut 1")
+```
+
+Décorticons un peu ce programme. 
+- Nous avons le mot clé `if`, qui veut dire "si" 
+- puis `ma_variable == 1`, ce qui s'appelle un **test**. 
+    - `ma_variable` est le nom de notre variable, celle que l'on veut tester
+    - `==` est un **opérateur de comparaison** pour tester l'égalité. Ici on veut vérifier que `ma_variable` vaut la valeur `1`. Remarquez qu'il est différent du `=` simple, qui sert pour affecter une variable.
+- Nous avons `:` à la fin de la ligne. C'est pour marquer la fin de la condition, et indiquer qu'après cela, nous passerons aux instructions exécutées si la condition est vraie
+- Enfin, nous avons la ligne `    print("Ma variable vaut 1")` qui vient afficher du texte. Mais remarquons une chose très importante : elle est décalée par rapport à la ligne précédente avec des espaces. C'est ce qu'on appelle **l'indentation**, et en python c'est indispensable. Si le code n'est pas correctement identé, c'est une erreur et votre programme ne marchera pas. Ici on indente tout ce qui sera exécuté si la condition est réalisée. Notez aussi que cela permet de rendre le code beaucoup plus facile à lire, car il s'organise en blocs plus ou moins décalés, ce qui vous permet de savoir en un coup d'oeil ce qui est exécuté ou non. 
+
+```admonish travail
+Dans un nouveau fichier que vous appellerez `tp-01-conditions.py`
+
+1. 
+    a. Copiez et exécutez le code de l'exemple ci-dessus. Vérifiez que la phrase `Ma variable vaut 1` s'affiche correctement.
+    b. Au début du programme, nous avons déclaré `ma_variable`. Remplacez cette déclaration pour pouvoir saisir un nombre de manière interactive, avec `input`. Mettez la ligne modifiée dans le compte rendu.
+    c. Réexécutez le programme en testant différentes valeurs (dont `1` pour vérifier qu'il marche toujours comme en a.). Qu'affiche le programme et pourquoi ?
+
+2. Maintenant, nous allons essayer d'écrire quelque chose lorsque la condition est respectée mais autre chose quand elle ne l'est pas. Pour cela, nous allons utiliser le mot clé `else` qui signifie "sinon". En faisant ça on pourra avoir un programme qui fera "**Si** ma condition est vraie *alors* je fais ça, **sinon** je fais ça". 
+
+    Écrivez le programme suivant, et modifiez la valeur d'âge en réexécutant le programme pour voir dans quel cas s'affiche quel texte. Que signifie le symbole `>` à votre avis ?
+    ~~~python
+    age = 17
+    if age > 18:
+        print("Vous êtes majeur.e")
+    else:
+        print("Vous êtes mineur.e")
+    ~~~
+
+3. Imaginons maintenant que nous ayons 3 cas possibles : majeur, mineur et retraité. 
+    
+    Nous pouvons enchaîner plusieurs conditions grâce au mot clé `elif` (contraction de de "else if", c'est à dire "sinon, si..."). `elif` s'utilise exactement comme `if` mais doit forcément se trouver après une première condition `if`. 
+    
+    Modifiez le code précédent en rajoutant le cas des retraités, pour afficher une phrase `Vous êtes en retraite` lorsque la variable `age` est supérieure à 60 (Allez, on y croit !). Mettez ce code dans votre rapport de TP.
+
+4. **Bonus :** Imaginons maintenant que l'on ait une autre variable, `annees_de_cotisation`. À partir de 60 ans, si on a 40 années de cotisation, on peut prendre la retraite. Sinon, il faut atteindre 40 années de cotisation. 
+
+Nous allons donc devoir rajouter une condition supplémentaire pour les personnes ayant plus de 60 ans, en fonction de la variable `annee_cotisation`. Rajoutez cette variable, et rajoutez une **condition imbriquée** dans la branche qui concerne les plus de 60 ans.
+```
+
+```admonish success title='À retenir'
+En résumé, les **structures conditionnelles** ressemblent à ceci : 
+~~~python
+if condition:
+    # Faire quelque chose
+elif autre_condition:
+    # Faire autre chose
+else:
+    # Dans tous les autres cas, faire cette chose
+~~~
+
+- Elles permettent d'exécuter un code différent selon des conditions.
+- Le mot-clé `if` est celui qui indique le début d'une structure conditionnelle. Il est obligatoire.
+- Le mot-clé `elif` permet de rajouter des conditions. On peut en mettre autant que l'on veut. Il est optionnel.
+- Le mot-clé `else` permet de gérer tous les cas qui n'entrent pas dans les précédentes conditions. Il est forcément en dernier et est optionnel.
+- Il est important de ne pas oublier
+    - Le symbole `:` à la fin de chaque ligne
+    - D'indenter votre code, pour indiquer à python ce qui est concerné par une condition. 
+- Ne pas indenter correctement un code python est une **erreur de syntaxe**, c'est à dire que le code n'est pas valide et ne pourra pas s'exécuter
+```
+
+```admonish tip title='Astuce'
+Il est possible d'imbriquer plusieurs conditions, en indentant correctement votre code de la manière suivante:
+~~~python
+if condition:
+   if sous_condition:
+        # Faire qqch
+    elif sous_condition_2 :
+        # Faire autre chose
+else:
+    # Traiter les autres cas
+~~~
+```
+
+### Les opérateurs de comparaison
+
+```admonish success title='À retenir'
+Nous avons vu dans l'activité précédente les opérateurs `==`, `<` et `>`. On les appelle les **opérateurs de comparaison**. Il en existe d'autres :
+
+|Opérateur|Description|
+|---------|-----------|
+|`==`| Égal à|
+|`!=`| Différent de|
+|`<`| Strictement inférieur à|
+|`>`| Strictement supérieur à|
+|`<=`| Inférieur ou égal à|
+|`>=`| Supérieur ou égal à|
+
+Attention, l'opérateur d'égalité est bien `==`, et non pas `=`. Utiliser l'opérateur d'affectation `=` pourra produire un code qui s'exécute, mais n'aura pas le résultat que vous attendez.
+```
+
+```admonish travail 
+Reprenez l'interpréteur python, déclarez les variables `a = 1`, `b = 3` et `c = 4` et testez les expressions suivantes. Que retournent-elles ? 
+
+1. `b > a`
+1. `c <= a`
+1. `a != b`
+1. `b == '3'` (attention aux guillemets simples). Qu'en déduisez-vous ?
+1. `a < b < c`
+```
+
+Ces opérateurs de comparaison retournent des booléens (le type `bool` que nous avons vu plus haut). Nous pouvons même stocker le résultat d'une comparaison dans une variable (qui sera de type `bool`) pour la réutiliser plus tard.
+
+De même, si vous écrivez `if True: ...` la condition sera toujours vraie, donc toujours réalisée. L'inverse également.
+
+```admonish tip title="Astuce"
+Les opérateurs `>`, `<`, `>=`, `<=` peuvent être chaînés pour faire des comparaisons d'intervalles. Par exemple, pour vérifier que la variable a est comprise entre 0 et 100, vous pouvez écrire '0 < a < 100'
+```
+
+### Les opérateurs booléens
+
+```admonish travail
+En utilisant l'interpréteur, déclarez les variables `a = 3`, `b = 1`, `c = 4` puis donnez le résultat des expressions suivantes:
+1. `a == 3 and (a + b) == c`
+1. `a < 0 or b > 1`
+1. `not a != b`
+1. `bool(c)`
+1. `bool(0)`
+1. Que déduisez-vous des deux questions précédentes ?
+```
+
+```admonish success title='À retenir'
+Les **opérateurs booléens** servent à faire des opérations avec des types `bool` ou pour créer des conditions plus complexes.
+
+|Opérateur| Description|
+|---------|------------|
+|`and`| Si les deux conditions sont vraies, retourne `True`, sinon `False`|
+|`or` | Si **au moins** l'une des deux conditions est vraie, retourne `True`, sinon `False`|
+|`not`| Inverse le résultat de la condition|
+
+Les opérateurs booléens peuvent être chainés et combinés pour faire des conditions plus complexes.
+
+Les nombres (et plein d'autres types) peuvent être considérés comme `True` ou `False` dans une condition (ou convertis avec la fonction `bool`).
+- Un entier non nul sera considéré comme `True`, un `0` sera considéré comme `False`
+- Une chaîne de caractères sera considérée comme `True`, sauf si elle est vide. 
+```
+
 
 ## Les boucles
-- while
-- for
-- break + continue
+
+```admonish travail
+Créez un nouveau script que vous appellerez `tp01-boucles.py`
+1. À l'aide de la fonction print et d'une chaîne formatée, donnez un code vous permettant d'afficher la table de multiplication par 7, en allant de 0 à 5. 
+    
+    **Aide**: La chaîne de caractères pourra avoir la forme suivante : `f"0 x 7 = {0 * 7}"`
+
+1. C'était pénible, n'est-ce pas <span>&#128513;</span> ? Imaginez si j'avais poussé en vous demandant d'aller jusqu'à 1000... On ne vas pas pouvoir continuer comme ça, bien évidemment. Les répétitions de code, en plus d'être pénibles sont une source d'erreurs infinie, et à chaque changement il faut mettre toutes les copies à jour. Pour cela nous allons donc utiliser des **boucles**, parfois appelées **structures répétitives**.
+
+    a. Nous allons utiliser le mot-clé `while` ("tant que" en anglais). `while` fonctionne un peu comme if : il prend une condition, et tant que cette condition est vraie, il continue de répéter les instructions qui sont dans son bloc. Commençons par écrire le code suivant. Exécutez-le et expliquez ce qu'il fait, ligne par ligne.
+    ~~~python
+    i = 0
+    while i <= 5:
+       print(f"{i} x 7 = {i * 7}")
+       i = i + 1
+    ~~~
+    b. Modifiez le pour qu'il affiche la même table de multiplication, mais cette fois de 0 à 100. Donnez la ligne modifiée dans votre compte rendu.
+
+    c. Modifiez le pour qu'il commence à partir de 50 jusqu'à 100. Donnez la ligne modifiée dans le compte rendu
+
+    d. Modifiez le pour qu'il n'affiche qu'une ligne sur deux. Donnez la ligne modifiée dans le compte rendu
+
+2. La boucle `while` permet déjà bcp de choses, mais il en existe une autre encore plus pratique pour ce cas : la boucle `for`. Modifiez le code précédent de la manière suivante, exécutez-le et vérifiez que le résultat soit identique à celui de la question 1.a. :
+    ~~~python
+    for i in range(0, 6):
+        print(f"{i} x 7 = {i * 7}")
+    ~~~
+    
+    Quels sont les changements que vous remarquez par rapport à la boucle `while` ? 
+    
+    **Aide**: `range` renvoie une sorte de liste des nombres entiers situés dans l'intervalle de nombres qu'on lui passe en paramètre. Ici il renvoie les nombres de 0 à 5 (6 est exclu).
+
+```
+
+```admonish success title="À retenir"
+- Les boucles permettent de répéter des instructions plusieurs fois.
+- Il y a deux formes, la boucle `while` et la boucle `for`. En pratique, en Python, on préfère utiliser la boucle `for` la majorité du temps.
+- La boucle `while` a la syntaxe suivante :
+    ~~~python
+    while condition_est_respectee :
+        # Je fais quelque chose
+    ~~~
+   - Elle peut se lire de la manière suivante : "Tant que la condition est vraie, faire ..." 
+   - Dès que la condition n'est plus respectée la boucle se termine. 
+        - Si la condition n'est jamais respectée, le code de la boucle n'est jamais exécuté. 
+        - Si la condition est toujours respectée, la boucle s'exécute à l'infini.
+        - Il faut donc prévoir, dans votre boucle, un moyen de faire évoluer la condition.
+   - Attention au `:` et à l'indentation !
+- La boucle `for` a la syntaxe suivante : 
+    ~~~python
+    for variable in ensemble:
+        # Je fais quelque chose
+    ~~~
+    - Elle peut se lire de la manière suivante : "Pour tous les éléments dans l'ensemble, faire ..."
+    - La boucle `for` va **itérer** sur un ensemble de données. Itérer signifie répéter sur chaque élément de l'ensemble en passant au suivant, dans l'ordre.
+    - L'ensemble peut être une liste, une chaîne de caractères, mais également plein d'autres choses. Nous aurons un TP quasiment entier consacré à ça.
+    - Attention au `:` et à l'indentation
+```
+
+## Mises en pratique
+
+L'heure de faire des vrais programmes est venue. N'hésitez pas à tester vos syntaxes dans l'interpréteur de commande avant de les mettre dans votre script. Procédez par étapes, prenez le temps de réfléchir avec un papier et un crayon. 
+
+Ces exercices sont moins guidés que le reste du TP. N'hésitez donc pas à vous entraider, ou demander de l'aide si vous êtes coincés.
+
+### Les années bissextiles
+
+Nous allons commencer par écrire un programme qui permet de déterminer si une année saisie par l'utilisateur ou l'utilisatrice est une année bissextile. 
+
+Ce script va vous permettre de mettre en pratique les structures conditionnelles mais également les entrées sorties (`print` et `input`), les variables, et certains opérateurs. N'hésitez donc pas à revenir à ces sections en cas de doute pour bien comprendre.
+
+Une année est bissextile si c'est un multiple de 4, sauf si c'est un multiple de 100. Mais si c'est un multiple de 400 alors elle est quand même bissextile.
+
+Si on pose les choses de manière structurée :
+- Si une année n'est pas un multiple de 4, on s'arrête là : elle n'est pas bissextile.
+- Si une année est un multiple de 4 alors on regarde si elle est multiple de 100
+    - Si oui, on regarde si c'est un multiple de 400
+        - Si oui elle est bissextile
+        - Sinon elle ne l'est pas
+    - Si elle n'est pas un multiple de 100, elle est bissextile
+
+Les termes du problème sont bien posés, prenez le temps d'y réfléchir et de bien comprendre. Un fois que vous pensez avoir bien compris, vous pouvez passer à la suite.
+
+```admonish travail
+1. Commencez par dessiner un schéma permettant de bien distinguer toutes les possibilités, sous forme d'arbre, chaque embranchement représentant une condition. L'important à ce stade est de bien cerner le problème.
+1. Créez un nouveau script appelé `tp01-bissextile.py`
+1. Écrivez le code vous permettant de saisir une année, et de la stocker dans une variable. N'oubliez pas de convertir en nombre votre année.
+1. Ensuite, écrivez la première condition, la plus simple pour vérifier si votre nombre est un multiple de 4 ou non. Nous ne tenons pas compte tout de suite des multiples de 100 et 400. Ecrivez dans chaque branche votre `print` pour dire si l'année est bissextile ou non.
+
+    Pour rappel, pour vérifier si un nombre est un multiple de 4, vous pouvez utiliser l'opérateur `%` : `nombre % 4`. Si cela renvoie 0, c'est un multiple de 4. Par ailleurs, le zéro est considéré comme `False` dans une condition.
+
+    Testez bien votre programme, avec différents nombres. Pour vous aider, utilisez le tableau plus bas qui contient quelques années bissextiles ou non.
+
+    Vous pouvez ajouter le code de votre script à cette étape au compte rendu.
+1. Maintenant que vous savez vérifier si une année est multiple de 4, vérifions les autres conditions.
+    
+    Modifiez votre code pour ajouter la nouvelle condition. Testez bien cette nouvelle condition.
+
+1. Maintenant, pour finaliser, vous allez devoir **valider** votre programme, c'est à dire vérifier qu'il fonctionne avec un certain nombre de cas prévus. Testez avec les années du tableau ci-dessous, et vérifiez que les résutats correspondent bien à la dernière colonne. Prenez des captures d'écran de vos résultats pour le compte rendu, et ajoutez le code final de votre script dedans également.
+```
+
+Quelques années, selon les critères :
+
+|Année|Multiple de 4|Multiple de 100|Multiple de 400|Bissextile|
+|-----|-------------|---------------|---------------|----------|
+|2025|non|non|non|non|
+|2024|oui|non|non|oui|
+|1900|oui|oui|non|non|
+|2000|oui|oui|oui|oui|
+
+
+### Le jeu du plus ou moins
+
+Nous allons maintenant réaliser un petit jeu où la personne qui y joue doit deviner un nombre entre 1 et 100 choisi aléatoirement par l'ordinateur. L'ordinateur renvoie l'information "Plus" quand le nombre qu'il a choisi est plus grand que celui saisi, et "Moins" dans l'autre cas.
+
+Pour que l'ordinateur vous fournisse un nombre aléatoire, vous pouvez utiliser le code suivant :
+```python
+import random # On importe le module random
+
+random.seed() # On initialise la génération de nombres aléatoires
+nombre_aleatoire = random.randint(1,100) # On récupère le nombre
+```
+```admonish note
+Les portions de code qui se trouvent après des `#` en python sont considérées comme des **commentaires**, c'est à dire du texte que la personne ayant écrit le code a mis pour aider les personnes lisant le code. Ce qui se trouve en commentaire est totalement ignoré par Python.
+```
+
+```admonish travail
+1. Créez un nouveau script appelé `tp01-plus-ou-moins.py`
+1. Écrivez le code permettant à l'ordinateur de générer le nombre aléatoire. Affichez-le pour vérifier que cela fonctionne.
+1. Écrivez le code permettant de demander à la personne qui joue d'entrer un nombre. N'oubliez pas les conversions
+1. Écrivez le code permettant de comparer les deux nombres et afficher "Plus", "Moins" ou "Gagné !" selon les cas. Mettez le code de votre programme à ce stade dans le compte rendu.
+1. Il faut maintenant boucler pour laisser plusieurs chances à l'utilisateur sans devoir relancer le programme à chaque fois. Écrivez une première version de votre boucle avec `while`. 
+    La boucle devra demander de saisir un nombre, le comparer, et afficher le texte. Si l'utilisateur a trouvé le bon nombre, le programme doit afficher "Gagné !" et s'arrêter tout seul. En revanche, le nombre aléatoire ne devra être choisi qu'une seule fois, faites donc attention.
+
+    Mettez le code de votre programme à ce stade dans le compte rendu.
+1. Ecrivez une nouvelle version de votre boucle, en utilisant `for` cette fois. L'utilisateur aura maximum 10 essais, et s'il dépasse le jeu affichera "Perdu !" avant de s'arrêter. 
+    Mettez le code final de votre programme dans le compte rendu.
+```