Réécriture complète du TP Python B1

2025-09-06 20:28:19 +02:00 · 2025-09-06 20:28:19 +02:00 · eca1cf7e77
commit eca1cf7e77
parent eebf8d7a03
9 changed files with 756 additions and 889 deletions
--- a/src/cours/CIEL1/01-bases-python/cours/python-bases-1-variables-operateurs.md
+++ b/src/cours/CIEL1/01-bases-python/cours/python-bases-1-variables-operateurs.md
@ -0,0 +1,303 @@
 # Bases de Python - Partie 1
 ## Qu'est-ce que Python ?
 Python est un langage de programmation **interprété** et **multiplateformes** sous **licence libre**. 
 - **interprété** : contrairement aux langages compilés comme le C ou le C++, Python analyse le code et le traduit en langage machine à la volée, lors de son exécution, et à chaque fois qu'il est exécuté. Il a donc besoin d'un interpréteur : l'exécutable Python
 - **multiplateformes** : Un même programme python est compatible avec plusieurs systèmes d'exploitation : Linux, Windows, MacOS... 
 - **Licence libre** : L'ensemble du langage, sa spécification ainsi que CPython, l'interpréteur classique, est libre, c'est à dire qu'elle permet aux utilisateurs de l'utiliser, l'étudier pour le comprendre ou l'adapter, le modifier, et le diffuser à d'autres utilisateurs
 ## Mode interactif ou script
 Il existe deux modes d'utilisation de Python
 ### Mode interactif
 Cela nous permettra de saisir des instructions, que Python va exécuter. On utilise souvent ce mode pour essayer des choses ou comprendre des mécanismes.
 Le mode interactif fonctionne de la manière suivante : 
 1. Il y a une **invite de commande**, qui est symbolisée par les `>>>`. Comme son nom l'indique, elle est là pour vous inviter à taper une commande.
 2. Vous pouvez taper une commande et la valider avec la touche <kbd>Entrée</kbd>
 3. Il **évalue l'expression saisie** : il l'analyse et l'exécute
 4. Il affiche enfin le résultat.
 ```admonish tip title="Astuce"
 Si vous utilisez les flèches <kbd>&uarr;</kbd> et <kbd>&darr;</kbd> dans l'invite de commande, vous pourrez naviguer dans l'historique des commandes tapées, et réutiliser d'anciennes commandes pour les modifier ou les réexécuter.
 ```
 ### Script
 On peut aussi utiliser Python avec des fichiers contenant le programme. C'est la manière la plus courante de faire pour avoir un programme qu'on peut réutiliser au cours du temps.
 Un fichier contenant du code Python s'appelle un **script**. Les scripts python ont un nom se finissant par l'**extension** `.py`.
 Pour cela, il faut éditer un fichier avec un **éditeur de texte**, et l'exécuter avec la commande suivante : `python mon_fichier.py`.
 ```admonish success title='À retenir'
 Un **éditeur de texte** est différent d'un **logiciel de traitement de texte**.
 - Un éditeur de texte permet de manipuler du texte brut, sans mise en forme. Il pourra avoir des fonctionnalités de coloration automatique ou de suggestions pour vous aider à écrire dans des langages de programmation. Ex: VSCode, Notepad++, Geany, Gedit, Kate, Sublime Text (non libre)...
 - Un logiciel de traitement de texte ne peut pas être utilisé pour écrire du code : il contient de nombreuses informations de mise en forme et travaille généralement avec des fichiers binaires ou un format spécifique très éloigné du texte brut nécessaire à la programmation. Ex: Libre Office Writer, Only Office Document, Microsoft Office Word (non-libre)
 ```
 ### Utilisation de Thonny
 Pour écrire du code Python, nous allons dans un premier temps utiliser le logiciel Thonny, qui vous donne accès à la fois à l'interpréteur Python et vous permet d'écrire et exécuter des scripts très simplement.
 Pour cela, commençons par lancer le logiciel Thonny. Cliquez sur le menu en bas à gauche dans Windows, puis recherchez Thonny.
 ```admonish tip title="Astuce"
 Thonny est un logiciel qui va nous permettre d'utiliser très simplement Python. Il est libre, c'est à dire que vous pouvez l'utiliser librement et gratuitement, y compris chez vous. N'hésitez donc pas à l'installer sur votre propre machine pour vous entraîner à écrire du Python chez vous, ou préparer vos exercices. 
 Vous pourrez le trouver sur ce site : https://thonny.org/
 ```
 Vous verrez dans le logiciel plusieurs encadrés :
 - Un premier encadré représentant le fichier
 - Un second intitulé `Console` dans lequel vous trouverez un interpréteur Python.
 - Eventuellement un troisième appelé `Assistant` qui vous aidera à comprendre vos erreurs.
 ![Thonny init](thonny.png)
 ## Variables
 - Une variable est un espace mémoire dans lequel l'ordinateur stocke une information.
 - Cette information peut être un nombre, une chaîne de caractères, ou des données plus complexes.
 - Elles sont nommées et on peut les **affecter** en écrivant `ma_variable = <contenu de ma variable>` (attention la variable est toujours à gauche, le contenu toujours à droite). Affecter signifie mettre un contenu dans la variable.
 - Les noms des variables en Python :
    - Peuvent comporter des caratères **alphanumériques**, c'est à dire des lettres minuscules ou majuscules et des chiffres
    - Peuvent comporter des `_` (tiret du bas, sur la touche <kbd>8</kbd> de votre clavier)
    - Les noms des variables ne peuvent pas commencer par un chiffre
    - Les noms des variables sont **sensibles à la casse** : c'est à dire qu'une variable écrite avec des majuscules sera différente d'une variable écrite avec des minuscules (par exemple ma variable `age` sera différente de `Age`)
    - Certains mots-clés ne peuvent pas être utilisés comme des noms de variables parce qu'ils sont **réservés**, c'est à dire qu'ils ont une autre signification dans le langage. Vous les verrez plus tard, mais vous pouvez trouver la liste [ici](https://docs.python.org/3/reference/lexical_analysis.html#keywords)
 ```admonish tip title="Convention"
 En python, la **convention** veut que l'on écrive les variables sous la forme dite `snake_case` (imaginez un serpent qui rampe au sol) : on va l'écrire avec uniquement des minuscules en remplaçant les espaces par des `_`. Par exemple, une variable représentant la date de naissance pourra s'écrire : `date_de_naissance`
 Une autre façon d'écrire serait le `camelCase` (imaginez les bosses du chameau), où chaque mot commence par une majuscule. C'est utilisé aussi en Python mais nous verrons plus tard dans quels cas. Ce n'est pas utilisé pour les variables.
 ```
 ```admonish warning title="Important"
 Python utilise beaucoup de **conventions** dans son langage. Une convention est une règle qui n'est pas obligatoire mais que tout le monde respecte par habitude, parce que cela permet d'avoir un code qui est facile à lire par tout le monde. 
 Même si elles sont parfois arbitraires, elles ont en général été pensées et établies par la communauté suite à des retours d'expérience. Par ailleurs, certaines conventions permettent de donner des informations supplémentaires importantes (nous en verrons régulièrement par la suite). 
 Pour la suite de ce TP, mais également dans vos TD, projets ou évaluations, vous devrez respecter les conventions que nous verrons pour prendre les bonnes habitudes, sinon je les considèrerai comme des erreurs.
 ```
 ## Types
 Les variables peuvent contenir differents **types** de données. Chaque type a son utilité pour représenter une donnée particulière. Il en existe des simples, ci-dessous, ou de plus complexes que nous verrons plus tard.
 - Python est capable de trouver le type d'une donnée tout seul, et la variable prend le type souhaité lors de l'affectation. On appelle ça du **typage dynamique**
 - Python possède une fonction `type` qui permet d'afficher le type de chaque variable. On l'appelle de la manière suivante : `type(ma_variable)`
 Voici un tableau recensant les principaux types de base de Python
 | Type | Explication | Exemple |
 |------|-------------|---------|
 | int  | Nombre entier | `1` |
 | float | Nombre décimal (à virgule "flottante") | `1.23` |
 | bool | Booléen : une valeur pouvant être soit vraie soit fausse | `True` ou `False` |
 | str | Chaîne de caractères : des caractères qui se suivent pour représenter du texte | `'Hello !'` |
 ```admonish warning title="Attention"
 Python utilise la notation anglo-saxonne pour les nombres non entiers (c'est à dire un point au lieu d'une virgule) : on écrira `4.5` et non pas `4,5`.
 ```
 ### Conversions
 Il est possible, *dans certains cas* de convertir des variables d'un type à un autre. On utilisera pour cela le type dans lequel on veut convertir comme une fonction. Les conversions sont possibles entre la plupart des types courants.
 ```admonish example title="Exemple"
 On récupère le texte `"22"` dans la variable `ma_variable` depuis une saisie utilisateur. Pour traiter ce texte comme un nombre entier, on écrira `int(ma_variable)`.
 ```
 ## Afficher et saisir du texte
 ### Afficher du texte
 - 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
 ```admonish example title="Exemple"
 ~~~python
 >>> print("Je veux afficher ce texte")
 Je veux afficher ce texte
 >>> print("Je veux afficher ce texte", "Puis celui-ci")
 Je veux afficher ce texte Puis celui-ci
 ~~~
 ```
 ### Saisir du texte
 - 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
 ```admonish example title="Exemple"
 ~~~python
 input("Veuillez saisir un nombre")
 ~~~
 ```
 ```admonish tip title="Astuces"
 - 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.
 ~~~python
 ma_variable = int(input("Veuillez saisir un nombre"))
 ~~~
 ```
 ### Les chaînes de caractères
 Les chaînes de caractères sont des suites de caractères représentant du texte.
 Les chaînes de caractères peuvent s'écrire avec des guillemets simples `'` (touche <kbd>4</kbd>) (qui est aussi utilisé en apostrophe en français) ou des guillemets doubles `"` (touche <kbd>3</kbd>).
 Vous pourrez utiliser des `"` lorsque que votre chaîne contiendra des `'` et inversement. Exemples:
 - `"J'aime les spaghettis"`
 - `'Elle a dit "Hello"'`
 Les chaînes de caractères peuvent être **formatées** : 
 - On écrira `f"chaine de caractère {variable}"`, 
 - Cela va 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.
 ```python
 mon_age = 22
 print(f"J'ai {mon_age} ans")
 # Résultat affiché :
 # J'ai 22 ans
 ```
 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.
 ## Opérateurs
 Les opérateurs sont des symboles permettant d'effectuer des calculs. Il en existe de nombreux en python.
 ### Opérateurs de calcul
 Voici les principaux opérateurs mathématiques :
 |Opérateur|Explication|
 |-|-|
 |`+`|Addition|
 |`-`|Soustraction|
 |`*`|Multiplication|
 |`/`|Division|
 |`//`|Division entière (renvoie un quotient entier)|
 |`%`|Modulo (renvoie le reste de la division euclidienne)|
 |`**`|Puissance|
 ```admonish example title="Exemples"
 ~~~python
 >>> 3+4
 7
 >>> 3-1
 2
 >>> 2*2
 4
 >>> 5/3
 1.6666666666666667
 >>> 5//3
 1
 >>> 5%3
 2
 >>> 10**3
 1000
 ~~~
 ```
 ### Opérateurs de comparaison
 |Opérateur|Description|
 |---------|-----------|
 |`==`| Égal à|
 |`!=`| Différent de|
 |`<`| Strictement inférieur à|
 |`>`| Strictement supérieur à|
 |`<=`| Inférieur ou égal à|
 |`>=`| Supérieur ou égal à|
 ```admonish warning title="Attention"
 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 example title="Exemples"
 ~~~python
 >>> 2 == 4
 False
 >>> 3 != '3'
 True
 >>> 3 < 4
 True
 >>> 3 <= 3
 True
 ~~~
 ```
 ### Opérateurs booléens
 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. 
 ```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'
 ```
 ```admonish example title="Exemples"
 ~~~python
 >>> True and True
 True
 >>> 3 < 4 or 6 == 4
 True
 >>> not 0 != 0
 True
 ~~~
 ```
 ### Opérateurs bit à bit
 Les **opérateurs bit à bit** servent à appliquer des opérations logiques bit à bit entre deux nombres. Ils sont différents des opérateurs booléens qui eux s'appliquent entre deux booléens. Dit autrement les opérateurs booléens vont faire une opération logique entre des valeurs True ou False, alors que les opérateurs bit à bit travaillent avec la représentation binaire du nombre et vont effectuer des opérations logiques entre tous les bits de même rang.
 |Opérateur|Description|
 |-|-|
 |`&`|Applique l'opération ET logique bit à bit entre les deux éléments|
 |`|`|Applique l'opération OU logique bit à bit entre les deux éléments|
 |`^`|Applique l'opération XOR (ou exclusif) logique bit à bit entre les deux éléments|
 |`~`|Applique l'opération NOT (inversion) logique bit à bit entre les deux éléments|
 ```admonish example title="Exemples"
 Dans l'exemple ci dessous, la fonction `bin` permet d'afficher le résultat sous forme binaire, pour vous aider à comprendre ce que font les opérateurs
 ~~~python
 >>> bin(0b1111 & 0b0101)
 '0b101'
 >>> bin(0b1111 | 0b0101)
 '0b1111'
 >>> bin(0b1111 ^ 0b0101)
 '0b1010'
 >>> bin(~0b1111)
 '-0b10000'
 ~~~
 ```
 ### Autres usages des opérateurs en Python
 Certains opérateurs peuvent être utilisés avec des types spécifiques et avoir une signification différente avec ce type précis. Nous en verrons en temps et en heure.
 Par exemple, l'opérateur `+` entre deux chaînes de caractères vient les concaténer (c'est à dire les coller bout à bout). En effet, l'addition (au sens mathématique) de chaînes de caractères n'a aucun sens, mais la concaténation de chaînes de caractères est un besoin courant.
--- a/src/cours/CIEL1/01-bases-python/cours/python-bases-2-structures-controle.md
+++ b/src/cours/CIEL1/01-bases-python/cours/python-bases-2-structures-controle.md
@ -0,0 +1,188 @@
 # Bases de Python - Partie 2 - Structures de contrôle
 Les structures de contrôle vous permettent de contrôler l'exécution de votre programme, c'est-à-dire choisir quelles instructions seront exécutées selon quels cas.
 ## Les conditions
 ### Si - alors
 Les **structures conditionnelles** ou conditions permettent d'exécuter un code différent selon des conditions : 
 ```python
 if condition:
    print("Faire quelque chose")
 ```
 Cette structure signifie :
 - **Si** (`if`) la condition est vraie (`True`)
 - **Alors** on exécute le bloc d'instructions
 ```admonish warning title="Important"
 Vous remarquerez que l'on va à la ligne après les `:` marquant la fin de la condition, et que l'on ajoute un décalage de la ligne suivante pour entamer le bloc d'instructions.
 Cela s'appelle **l'indentation**. En Python, c'est un élément de syntaxe du langage. C'est à dire que votre code sera erroné si vous n'indentez pas votre code correctement, et cela pourra déclencher des erreurs.
 ```
 ### Si - alors - sinon
 ```python
 if condition:
    print("Faire quelque chose")
 else:
    print("Faire autre chose")
 ```
 Cette structure signifie:
 - **Si** (`if`) la condition est vraie (`True`)
 - **Alors** on exécute le bloc d'instructions
 - **Sinon** (`else`) on exécute l'autre bloc d'instructions
 Remarquez qu'il y a toujours une indentation pour marquer le bloc. En revanche, on revient au niveau précédent pour le `else` car on sort du bloc d'instructions sous le `if`
 ### Si - alors - sinon, si - sinon
 ```python
 if condition:
    print("Faire quelque chose")
 elif autre_condition: 
    print("Faire autre chose")
 else:
    print("Faire encore autre chose")
 ```
 Cette structure signifie:
 - **Si** (`if`) la condition est vraie (`True`)
 - **Alors** on exécute le bloc d'instructions
 - **Sinon, si** (`elif` contraction de else if) l'autre condition est vraie
 - **Alors** On exécute l'autre bloc
 - **Sinon** (`else`) on exécute le dernier bloc d'instructions
 ```admonish warning title="Attention"
 Ne pas oublier le symbole `:` à la fin de chaque ligne commençant par `if`, `elif` ou `else`
 ```
 ```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
 ~~~
 ```
 ### Un exemple complet
 Nous allons ici écrire un exemple complet avec un code comportant plusieurs conditions complexes. Nous voulons Savoir si une année est bissextile.
 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
 Prenez le temps de bien réfléchir aux termes du problème et les comprendre. **Essayez de le résoudre par vous-même dans un premier temps.**
 Nous allons procéder par étapes :
 1. Nous allons demander à l'utilisateur de saisir une année. Si vous avez des doutes, revenez à la partie 1 de ce cours.
    ```python
    annee = int(input("Veuillez saisir une année : ")) # On convertit bien notre entrée en int pour pouvoir faire des calculs dessus
    ```
 2. Nous allons gérer la première condition, la plus simple : une année est bissextile si c'est un multiple de 4. Un nombre est multiple d'un autre si l'opération `nombre_1 % nombre_2` donne `0`. L'opérateur `%` est l'opérateur modulo (voir partie 1) et permet de savoir le reste de la division entière de deux nombres. 
    - Nous utilisons donc `annee % 4` pour voir quel est le reste de la division entière par 4. Si c'est zéro, notre année est divisible par 4.
    - Nous utilisons l'opérateur de comparaison `==` pour savoir si notre résultat vaut 0
    ```python
    annee = int(input("Veuillez saisir une année : "))
    if annee % 4 == 0: # Si annee est multiple de 4
        print("Année bissextile") # Alors elle est bissextile
    else: # Sinon
        print("Année non-bissextile") # Elle ne l'est pas
    ```
 3. On veut maintenant calculer le cas où notre nombre est un multiple de 400 mais pas un multiple de 100. Nous allons rajouter une condition sous la première (dans le cas où notre nombre est multiple de 4). Pour bien comprendre toutes les conditions, n'hésitez pas à revoir les opérateurs booléens, en partie 1.
    ```python
    annee = int(input("Veuillez saisir une année : "))
    if annee % 4 == 0:
        if (annee % 100 == 0) and not (annee % 400 == 0): # Si annee est multiple de 100 et qu'elle n'est pas (and not) multiple de 400
            print("Année non-bissextile") # Alors elle n'est pas bissextile
        else: # Sinon
            print("Année bissextile") # Alors elle est bissextile
    else: # Sinon
        print("Année non-bissextile") # Elle ne l'est pas
    ```
 ## Les boucles
 Les boucles servent à répéter des instructions autant de fois que nécessaire. Il en existe deux types.
 - La boucle `while` (tant que) quand on ne sait pas exactement combien d'itérations on va devoir faire
 - La boucle `for` (pour tous les éléments) quand on sait combien de fois on veut répéter, ou que l'on parcourt un ensemble de données
 En pratique, en Python on cherche la plupart du temps à utiliser une boucle `for`, mais les deux peuvent être utilisées et doivent être connues.
 ### Boucle `while`
 ```python
 while condition_est_respectee :
    print("Je fais quelque chose")
 ```
 Cette structure peut se lire de la manière suivante :
 - **Tant que** la condition est vraie, 
 - **Faire** : on exécute le bloc d'instructions
 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. Cela peut être voulu, ou peut être une source de bugs.
 - Il faut donc prévoir, dans votre boucle, un moyen de faire évoluer la validité de la condition.
 ```admonish warning title="Attention"
 - Attention à l'indentation : comme avec les conditions, le bloc de code est décalé par rapport à la ligne précédente pour indiquer le bloc de code à exécuter.
 - Attention au `:` comme pour les conditions
 - La boucle `do-while` présente en C++ n'existe pas en Python.
 ```
 ```admonish example title="Exemple"
 On souhaite itérer sur les nombres de 0 à 10 pour afficher une table de multiplication. 
 ~~~python
 i = 0 # On initialise notre variable i à 0
 while i <= 10: # Tant que i est inférieur ou égal à zéro
    print(f"{i} * 7 = {i*7}") # On affiche la ligne suivante
    i = i+1 # Et on augment i pour la prochaine itération
 ~~~
 Notre code nécessite de gérer une variable `i` que l'on va augmenter régulièrement pour afficher nos lignes
 ```
 ### Boucle `for`
 La boucle for est très intéressante. Elle permet de parcourir un ensemble, et d'exécuter du code pour chaque élément de l'ensemble.
 ```python
 for variable in ensemble:
    print(variable)
 ```
 Elle peut se lire de la manière suivante : 
 - **Pour tous** les *éléments* dans *l'ensemble*, 
 - **Faire** : on exécute le bloc d'instructions
 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.
 - Chose intéressante, la boucle `for` met à disposition dans une variable l'élément sur lequel on est en train de travailler.
 - L'ensemble peut être une liste, une chaîne de caractères, mais également plein d'autres choses.
 - Attention au `:` et à l'indentation
 ```admonish example title="Exemple"
 On souhaite itérer sur les nombres de 0 à 10 pour afficher une table de multiplication. 
 ~~~python
 for i in range(0, 11):
    print(f"{i} * 7 = {i*7}")
 ~~~
 Notre variable `i` vaudra tour à tour toutes les valeurs de 0 à 10, grâce à la fonction `range` qui met à notre disposition tous les nombres de 0 à 10 dans l'ordre. 
 Nous n'avons pas besoin de l'initialiser ni de l'incrémenter (=l'augmenter de 1), c'est la boucle `for` qui s'en charge, en passant à l'élément suivant de l'ensemble que nous donne `range`
 ```
--- a/src/cours/CIEL1/01-bases-python/cours/python-bases-3-fonctions.md
+++ b/src/cours/CIEL1/01-bases-python/cours/python-bases-3-fonctions.md
@ -0,0 +1,77 @@
 # Bases de Python - Partie 3 - Fonctions
 ## Fonctions
 Vous connaissez déjà certaines fonctions, celles que vous avez utilisées lors du précédent TP : `print`, `input`, `range` ... Ce sont des fonctions que vous avez **appelées** mais qui existent déjà par défaut dans le langage Python.
 ### Appeler une fonction
 - Les fonction s'utilisent avec la syntaxe suivante : `nom_de_la_fonction(parametre_1, parametre_2, ...., parametre_n)`
    - Vous mettez le nom de la fonction, suivi de parenthèses
    - Entre les parenthèses vous mettez les paramètres séparés par des virgules
    - Si une fonction n'a pas besoin de paramètres, les parenthèses sont quand même indispensables.
 - Certaines fonctions peuvent prendre des paramètres nommés, avec la syntaxe suivante : `nom_de_la_fonction(nom_parametre=valeur_parametre)`. Les paramètres nommés sont toujours à la fin et leur ordre n'a pas d'importance.
 - Une fonction peut renvoyer un résultat, que l'on peut alors affecter à une variable.
 - Si une fonction ne renvoie rien, alors elle renverra en réalité la valeur spéciale `None`.
 ```admonish success title='À retenir'
 - Les fonctions servent à rendre votre code plus clair et mieux découpé. Elles permettent de réutiliser du code.
 - Pour déclarer une fonction en python :
    ~~~python
    def nom_de_la_fonction(parametre_1, parametre_2, ..., parametre_n):
        # Instructions
    ~~~
    - On utilise le mot-clé `def` suivi du nom de la fonction. 
    - Entre parenthèses on ajoute les paramètres qu'il faudra fournir
    - À la fin de la ligne on met `:` (encore et toujours)
    - On passe à la ligne suivante et on indente pour écrire les instructions.
 - Les paramètres fonctionnent comme des variables : on peut les utiliser dans la fonction avec leur nom.
 - On peut définir une valeur par défaut à un paramètre : il suffit d'écrire `parametre=valeur_par_defaut` lors de la déclaration. On peut alors omettre le paramètre, qui prendra automatiquement la valeur par défaut.
 - Deux fonctions ne peuvent pas avoir le même nom, sinon, la dernière a avoir été déclarée écrase la précédente.
 ```
 ```admonish success title="À retenir"
 - L'instruction `return` permet de sortir immédiatement d'une fonction. Rien ne s'exécutera après le `return`
 - `return` permet de retourner un résultat, avec la syntaxe `return valeur`. Si aucune valeur n'est mentionnée, elle retournera `None`
 - Si `return` n'est pas mentionnée, la fonction s'exécute jusqu'au bout et sortira à la fin du bloc d'instructions en retournant `None`
 - On peut retourner plusieurs valeurs en les séparant par une virgule. 
    - Ces valeurs peuvent être affectées à une seule variable sous forme d'un **tuple** (nous en parlerons au prochain TP)
    - Chaque valeur peut être affectée à une variable différente avec la syntaxe `variable_1, variable_2 ... = nom_de_la_fonction(...)`.
 ```
 ```admonish tip title='Bonnes pratiques'
 - Faites des fonctions courtes qui vont à l'essentiel (20 lignes est un bon maximum)
 - Choisissez bien les noms de vos fonctions et de vos paramètres pour qu'ils soient clairs et explicites
 - Vous pouvez documenter vos fonctions à l'aide d'une **docstring** : après l'en-tête de la fonction, avant le bloc d'instructions vous pouvez écrire une chaîne de caractères qui commence par 3 `"` ou `'`. 
    Exemple:
    ~~~python
    def ma_fonction(arg_1, arg2):
        """Ceci est une docstring qui vient documenter ma fonction.
        Une docstring peut prendre plusieurs lignes.
        """
        # Bloc d'instructions
    ~~~
 ```
 # Annexes
 ## Un petit peu d'anglais
 |Français|Anglais|
 |--------|-------|
 |Interpréteur|Interpreter|
 |Invite de commande|Command prompt|
 |Opérateur|Operator|
 |Fonction|Function|
 |Racine carrée|Square root|
 |Affecter une variable|Assign a variable|
 |Sensible à la casse|Case sensitive|
 |Mot-clé|Keyword|
 |Mot clé réservé|Reserved keyword|
 |Typage dynamique|Dynamic typing|
 |Chaîne de caractères|String|
 |Chaîne de caractères formatée|Formatted string|
 |Boucle|Loop|
--- a/src/cours/CIEL1/01-bases-python/cours/thonny.png
+++ b/src/cours/CIEL1/01-bases-python/cours/thonny.png
--- a/src/cours/CIEL1/01-bases-python/tp/01_decouverte.md
+++ b/src/cours/CIEL1/01-bases-python/tp/01_decouverte.md
@ -1,597 +1 @@
-# Découverte de Python
+# TP1 - Découverte de Python
 ## 1 - Découverte de l'interpréteur Python
 Nous allons commencer par découvrir l'interpréteur python que nous allons utiliser de manière interactive.
 ```admonish travail
 Pour cela, commençons par lancer le logiciel Thonny. Cliquez sur le menu en bas à gauche dans Windows, puis recherchez Thonny.
 ```
 ```admonish tip title="Astuce"
 Thonny est un logiciel qui va nous permettre d'utiliser très simplement Python. Il est libre, c'est à dire que vous pouvez l'utiliser librement et gratuitement, y compris chez vous. N'hésitez donc pas à l'installer sur votre propre machine pour vous entraîner à écrire du Python chez vous, ou préparer vos exercices. 
 Vous pourrez le trouver sur ce site : https://thonny.org/
 ```
 Nous allons commencer par utiliser Python en mode interactif. Cela nous permettra de saisir des instructions, que Python va exécuter. Regardez la fenêtre de Thonny, et trouvez la section qui s'appelle `Console`. Vous y verrez la mention `Python 3.13.5 (/usr/bin/python)` (le texte exact peut être différent), et sur la ligne suivante trois chevrons (le symbole `>`).
 ![Mode interactif de Python dans Thonny](image.png)
 Le mode interactif fonctionne de la manière suivante : 
 1. Il y a une **invite de commande**, qui est symbolisée par les `>>>`. Comme son nom l'indique, elle est là pour vous inviter à taper une commande.
 2. Vous pouvez taper une commande (nous verrons lesquelles juste après) et les valider avec la touche <kbd>Entrée</kbd>
 3. Il **évalue l'expression saisie** : il l'analyse et l'exécute
 4. Il affiche enfin le résultat.
 ```admonish tip title="Astuce"
 Si vous utilisez les flèches <kbd>&uarr;</kbd> et <kbd>&darr;</kbd> dans l'invite de commande, vous pourrez naviguer dans l'historique des commandes tapées, et réutiliser d'anciennes commandes pour les modifier ou les réexécuter.
 ```
 ## 2 - Python est une calculatrice
 Vous pouvez utiliser l'interpréteur de python comme une calculatrice. C'est évidemment bien plus puissant, mais nous allons commencer par découvrir ses capacités de calcul.
 ### 2.1 - Une calculatrice simple
 ```admonish travail
 1. Tout d'abord, essayez de taper l'expression `2 + 3` dans l'invite de commande et appuyez sur <kbd>Entrée</kbd>. Que se passe-t-il ?
 2. Dans l'invite de commande, essayez d'effectuer les opérations suivantes. Notez les expressions utilisées et leur résultat.
    - 4 plus 7
    - 3 moins 12
    - 6 fois 7
    - 9 divisé par 2
    - 4,2 plus 1,5
    - 5 modulo 2
    - le quotient de la division euclidienne de 5 par 2
    - 2 puissance 10
    - 37 fois la somme de 13 et 24
 3. Divisez 10 par 3. Que remarquez-vous ?
 ```
 ```admonish success title="À retenir"
 - Python utilise la notation anglo-saxonne pour les nombres non entiers (c'est à dire un point au lieu d'une virgule) : il écrira `4.5` et non pas `4,5`. Il en va de même lorsque vous écrirez des nombres en Python.
 - Les symboles `+`, `-`, `*`, `/`... sont appelés **opérateurs** en Python
 - L'opérateur modulo `%` est souvent utilisé pour savoir si un nombre est multiple d'un autre. Il vaut mieux s'en souvenir. Il permet de calculer le reste de la division euclidienne de deux nombres. Par exemple si on divise 5 par 2 on obtient 2 et il reste 1. 1 est donc notre reste et `5 % 2` nous donnera 1.
 - Si l'on veut effectuer la division euclidienne d'un nombre par un autre, on peut le faire avec l'opérateur `//` qui est différent de `/`. Par exemple `5//2` nous donnera 2, alors que `5/2` nous donnera `2.5`
 - Les nombres décimaux ont parfois des valeurs approximatives. Il faut être vigilant lorsqu'on les utilise dans des calculs.
 ```
 ### 2.2 - Mais aussi une calculatrice scientifique
 Après avoir utilisé les opérateurs mathématiques simples, nous allons voir que Python permet également de faire des opérations plus complexes, comme celles que l'on retrouve sur une calculatrice scientifique. Elles ne se retrouvent pas directement sous forme d'**opérateurs** mais sous forme de **fonctions**. 
 Nous verrons dans le prochain TP ce que sont les fonctions plus en détail. Pour le moment, l'important est de retenir qu'une fonction est un ensemble d'instructions que l'on a regroupées sous un nom pour les exécuter ensemble sans avoir à les taper à chaque fois. 
 Il existe des fonctions par défaut dans Python (voir [Built-in functions](https://docs.python.org/3/library/functions.html)) mais celles qui nous intéressent ici sont situées dasn un **module** appelé `math`. Nous verrons plus tard ce que sont les modules. Ici nous allons nous contenter de l'importer. 
 Dans l'invite de commande, écrivez :
 ~~~python
 >>> import math
 ~~~
 Nous pouvous ensuite appeler tout un tas de nouvelles fonctions liées aux mathématiques. Par exemple, si nous voulons la racine carré de 2 ('racine carrée' c'est 'square root' en anglais), nous pouvons écrire : 
 ```python
 >>> math.sqrt(2)
 1.4142135623730951
 ```
 Explication :
 - On appelle la fonction `sqrt` en la précédant du nom du module `math`, séparés par un point
 - Les parenthèses servent à donner les **arguments** à la fonction, ici `2` car nous voulons calculer la racine carrée de 2.
 - Python nous donne ensuite le résultat : `1.4142135623730951`
 ```admonish travail
 En utilisant la [documentation du module `math`](https://docs.python.org/3/library/math.html)
 1. Donnez les expressions qui permettront de calculer :
    - la racine carrée de 81
    - la valeur absolue de -12 (celle-ci n'est pas dans `math` mais existe par défaut)
    - la valeur de $\pi$
    - le cosinus de $\pi$
    - la partie entière de 3.56
 2. Expliquez la différence entre les fonctions `math.floor()` et `math.ceil()`
 ```
 ## 3 - Les variables et les types
 ### 3.1 - Les variables
 Dans la suite nous allons apprendre à utiliser des variables. Que sont les variables ? C'est la base de tout programme informatique : elles vous permettent de stocker une information (un nombre, le résultat d'un calcul, une phrase sous forme de chaîne de caractères...) pour la réutiliser plus tard.
 ```admonish success title="À retenir"
 - Les variables sont une donnée de votre programme stockée dans l'ordinateur.
 - Elles sont nommées et on peut les **affecter** en écrivant `ma_variable = <contenu de ma variable>` (attention la variable est toujours à gauche, le contenu toujours à droite). Affecter signifie mettre un contenu dans la variable.
 - Les noms des variables peuvent comporter:
    - Des caratères **alphanumériques**, c'est à dire des lettres minuscules ou majuscules et des chiffres
    - Des `_` (tiret du bas, sur la touche <kbd>8</kbd> de votre clavier)
 - Les noms des variables ne peuvent pas commencer par un chiffre
 - Les noms des variables sont **sensibles à la casse** : c'est à dire qu'une variable écrite avec des majuscules sera différente d'une variable écrite avec des minuscules (par exemple ma variable `age` sera différente de `Age`)
 - Certains mots-clés ne peuvent pas être utilisés comme des noms de variables parce qu'ils sont **réservés**, c'est à dire qu'ils ont une autre signification dans le langage.
 - En python, la **convention** veut que l'on écrive les variables sous la forme dite **snake case** : on va l'écrire avec uniquement des minuscules en remplaçant les espaces par des `_`. Par exemple, une variable représentant la date de naissance pourra s'écrire : `date_de_naissance`
 ```
 Vous verrez la plupart des mots **réservés** par la suite, et comprendrez vite pourquoi on ne peut pas les utiliser comme variables, tout en les retenant facilement, mais vous pourrez trouver la liste de ces mot-clés dans la [documentation python](https://docs.python.org/3/reference/lexical_analysis.html#keywords)
 ```admonish warning title="Important"
 Python utilise beaucoup de **conventions** dans son langage. Une convention est une règle qui n'est pas obligatoire mais que tout le monde respecte par habitude, et parce que cela permet d'avoir un code qui est facile à lire par tout le monde. Même si elles sont parfois arbitraires, elles ont en général été pensées et établies par la communauté suite à des retours d'expérience. Par ailleurs, certaines conventions permettent de donner des informations supplémentaires importantes (nous en verrons régulièrement par la suite). 
 Pour la suite de ce TP, mais également dans vos TD, projets ou évaluations, vous devrez respecter les conventions que nous verrons pour prendre les bonnes habitudes, sinon je les considèrerai comme des erreurs.
 ```
 ```admonish travail
 Nous allons donc affecter et utiliser nos premières variables. 
 1. Pour cela, dans l'interpréteur, écrivez `mon_age = 19` puis appuyez sur <kbd>Entrée</kbd>. Que se passe-t-il ?
 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
    ~~~
 5. 
    a. Le code suivant calcule le prix TTC d'un article à partir de son prix hors taxes (45€), en lui ajoutant la TVA. Écrivez-le dans l'interpréteur. Quel résultat obtenez-vous pour le prix TTC ?
    ~~~python
    >>> prix_ht = 45
    >>> tva = 5.5 / 100
    >>> prix_ttc = prix_ht * (1 + tva)
    >>> prix_ttc
    ~~~
    b. Modifiez la valeur de `tva` pour qu'elle prenne la valeur de 20%. Quelle valeur a `prix_ttc` ? Pourquoi ?
    c. Recalculez la valeur de `prix_ttc` pour prendre en compte la modification de `tva` (Astuce: vous pouvez utiliser <kbd>&uarr;</kbd> pour retrouver la ligne déjà tapée). Donnez la ligne que vous avez réexécutée.
    d. Donnez l’expression qui permet d’évaluer le prix à payer par le client lorsqu’on lui accorde une réduction de 5% sur le prix **hors taxes**.
    e. Donnez l'expression qui permet d'augmenter la TVA de 1%, quel que soit sont taux actuel.
 ```
 ### 3.2 - Les types de données et la fonction `type`
 Les variables peuvent contenir differents types de données. Nous avons surtout vu des nombres jusqu'à maintenant, mais elles peuvent aussi contenir des **chaînes de caractères** ou d'autres types plus complexes. Nous verrons dans un premier temps les plus courants. 
 ```admonish success title="À retenir"
 - Python est capable de trouver le type d'une donnée tout seul, et cette variable prend le type souhaité lors de l'affectation. On appelle ça du **typage dynamique**
 - Python possède une fonction `type` qui permet d'afficher le type de chaque variable. 
 ```
 ```admonish travail
 1. Affecter le valeur `21` à une variable `mon_age`. Donner le type de cette variable en utilisant la fonction `type`.
 2. Affecter la valeur `3.14` à une variable `pi`. Donner le type de cette variable.
 3. Affecter la valeur `True` (ou `False`) à une variable `j_aime_les_spaghettis`. Donnez son type.
 4. Affecter la valeur `"<votre prénom>"` à une variable `prenom` et donnez son type. 
 5. Ecrivez `age = '85'` (Attention aux guillemets) dans l'interpréteur. Donnez le type de `age`.
 6. Ecrivez maintenant `age * 2`. Que se passe-t-il ? comment se comporte l'opérateur `*` lorsqu'il est utilisé avec des chaînes de caractères ? 
 7. En utilisant la variable `mon_age` (question 1) et la fonction `str`, donnez une expression permettant d'affecter le *texte* `'21'` à la variable `mon_age_str`. Utilisez la fonction type pour vérifier. Qu'en déduisez-vous sur la fonction `str` ? 
 8. De même donnez une expression permettant de d'affecter le *nombre* 85 à la variable `age_int` en utilisant uniquement `age` (question 6) et la fonction `int`. Qu'en déduisez-vous sur ce que fait la fonction `int` ?
 ```
 ```admonish success title="À retenir"
 Voici un tableau recensant les principaux types de base de Python
 | Type | Explication | Exemple |
 |------|-------------|---------|
 | int  | Nombre entier | `1` |
 | float | Nombre décimal (à virgule "flottante") | `1.23` |
 | bool | Booléen : une valeur pouvant être soit vraie soit fausse | `True` ou `False` |
 | str | Chaîne de caractères : des caractères qui se suivent pour représenter du texte | `'Hello !'` |
 Les chaînes de caractères peuvent s'écrire avec des guillemets simples `'` (touche <kbd>4</kbd>) (qui est aussi utilisé en apostrophe en français) ou des guillemets doubles `"` (touche <kbd>3</kbd>).
 Vous pourrez utiliser des `"` lorsque que votre chaîne contiendra des `'` et inversement. Exemples:
 - `"J'aime les spaghettis"`
 - `'Elle a dit "Hello"'`
 ```
 ## 4 - Un premier script
 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é, au dessus de l'interpréteur, 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.
 ### 4.1 - 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.
 ```
 ### 4.2 - 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.
 ```
 ## 5 - Structure conditionnelle
 ### 5.1 - 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. 
    1. Copiez et exécutez le code de l'exemple ci-dessus. Vérifiez que la phrase `Ma variable vaut 1` s'affiche correctement.
    1. 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.
    1. Réexécutez le programme en testant différentes valeurs (dont `1` pour vérifier qu'il marche toujours comme en 1.1.). 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.
 ```
 ```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 commençant par `if`, `elif` ou `else`
    - 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
 ~~~
 ```
 ### 5.2 - 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'
 ```
 ### 5.3 - 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. 
 ```
 ## 6 - Les boucles
 ```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
 ```
 ## 7 - 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.
 ### 7.1 - 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|
 ### 7.2 - 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.
 ```
 # Annexes
 ## Un petit peu d'anglais
 |Français|Anglais|
 |--------|-------|
 |Interpréteur|Interpreter|
 |Invite de commande|Command prompt|
 |Opérateur|Operator|
 |Fonction|Function|
 |Racine carrée|Square root|
 |Affecter une variable|Assign a variable|
 |Sensible à la casse|Case sensitive|
 |Mot-clé|Keyword|
 |Mot clé réservé|Reserved keyword|
 |Typage dynamique|Dynamic typing|
 |Chaîne de caractères|String|
 |Chaîne de caractères formatée|Formatted string|
 |Boucle|Loop|
--- a/src/cours/CIEL1/01-bases-python/tp/TP_MDP01_menu.md
+++ b/src/cours/CIEL1/01-bases-python/tp/TP_MDP01_menu.md
@ -0,0 +1,182 @@
 L'objectif de cette série de TP est de construire un générateur de mots de passe sécurisés.
 # Itération 1 - Menu interactif en Python
 ## Objectifs du TP
 ### Apprendre
 - **Variables** : Déclarer et utiliser une variable
 - **Sorties** : Afficher du texte avec `print`
 - **Entrée** : Récupérer du texte saisi par l'utilisateur
 - **Conditions** : Utiliser `if`, `elif` et `else`
 - **Boucles** : Pour répéter le programme
 ### Objectif technique
 Créer un menu interactif pour que l'utilisateurice puisse choisir son option
 ```
 ================================================
 CIEL - Générateur de mots de passe
 ================================================
 Quel type de mot de passe souhaitez-vous créer ?
 1 - Mot de passe avec configuration par défaut
 2 - Mot de passe avec configuration personnalisée
 3 - Phrase de passe avec configuration par défaut
 4 - Phrase de passe avec configuration personnalisée
 0 - Quitter
 Saisissez votre choix : 1
 Mot de passe par défaut
 ```
 ## Étapes
 ### 1 - Préparation
 **Objectif :** Préparer votre fichier de script et commencer à travailler avec Thonny
 ```admonish travail
 - Créer un fichier `main.py` dans votre répertoire de travail
 ```
 ### 2 - Affichage du titre et du menu
 **Objectif :** Afficher le titre et toutes les options du menu
 ```admonish tip title="A utiliser"
 - La fonction `print`
 ```
 **Résultat attendu :**
 ```
 ================================================
 CIEL - Générateur de mots de passe
 ================================================
 Quel type de mot de passe souhaitez-vous créer ?
 1 - Mot de passe avec configuration par défaut
 2 - Mot de passe avec configuration personnalisée
 3 - Phrase de passe avec configuration par défaut
 4 - Phrase de passe avec configuration personnalisée
 0 - Quitter
 ```
 ```admonish travail
 - Utilisez du code pour afficher exactement le texte ci-dessus
 ```
 ### 3 - Demander le choix à l'utilisateur
 **Objectif :** Afficher "Saisissez votre choix : " et récupérer la réponse de l'utilisateur 
 ```admonish tip title="A utiliser"
 - La fonction `input`
 ```
 ```admonish question
 1. Quel est le type de la donnée récupérée via `input`
 2. Comment allez-vous stocker cette donnée ? Quel type aura la variable ?
 ```
 ### 4 - Gérer les choix valides
 **Objectif :** Utiliser des conditions pour gérer les choix de l'utilisateur (1, 2, 3, 4 et 0)
 ```admonish tip title="A utiliser"
 - `if` 
 - `elif`
 - Opérateurs de comparaison
 ```
 **Résultat attendu :** Afficher le texte pour chacun des cas
 |Choix|Texte à afficher|
 |-|-|
 |1|Mot de passe par défaut|
 |2|Mot de passe personnalisé|
 |3|Phrase de passe par défaut|
 |4|Phrase de passe personnalisée|
 |0|Vous quittez le programme|
 ### 5 - Gérer les choix invalides
 **Objectif :** Traiter le cas où l'utilisateur saisit un choix non valide
 ```admonish tip title="A utiliser"
 - Ajouter un `else` pour capturer les autres cas
 - Utiliser une chaîne formatée
 ```
 **Résultat attendu :** Afficher le texte `Erreur : l'option 6 n'existe pas` (si le choix de l'utilisateur est 6 par exemple)
 ```admonish question
 1. Que se passe-t-il lorsque l'utilisateurice saisit une lettre au lieu d'un chiffre lors du choix de l'option ? Pourquoi à votre avis ? Nous ignorerons cette possibilité pour le moment, et verrons plus tard dans l'année comment le gérer.
 ```
 ### 6 - Ajouter une boucle
 **Objectif :** Le programme doit pouvoir être répété autant que l'utilisateur le veut.
 ```admonish tip title="Quelle boucle utiliser ?"
 - La boucle `for` s'utilise pour un nombre connu d'itérations
 - La boucle `while` s'utilise pour un nombre non défini à l'avance d'itérations
 ```
 ```admonish warning title="Gestion de la pause"
 Si le choix de l'utilisateurice est différent de zéro (pour quitter), il faut avoir le temps de lire avant de réafficher le menu. 
 Pour cela on peut demander une entrée (avec `input`) à l'utilisateurice, mais ignorer sa saisie. On peut alors simplement lui proposer d'appuyer sur Entrée. Une fois la saisie effectuée, on pourra alors reboucler.
 ```
 ```admonish question
 1. Quelle boucle sera la plus adaptée ? Pourquoi ?
 2. Comment éviter de déclencher la pause lorsque l'utilisateurice souhaite quitter le programme ?
 ```
 ## Validation
 ### Checklist
 - [ ] Le programme se lance sans erreur
 - [ ] Le titre s'affiche correctement
 - [ ] Toutes les options s'affichent
 - [ ] La saisie utilisateur fonctionne
 - [ ] Chaque option affcihe le bon message
 - [ ] Un choix (nombre entier) invalide affiche une erreur claire
 - [ ] Le code est propre, les variables sont correctement nommées et avec des noms compréhensibles
 ### Critères d'évaluation
 - Le programme fonctionne correctement
 - Le code est propre : nommage des variables, lisibilité
 - Documentation : commentaires pertinents
 - Réponse aux questions dans le compte-rendu
 ## Pour aller plus loin
 ### Bonus - Améliorations
 - Personnaliser le titre avec votre nom
 - Améliorer le texte des options et les messages
 - Amélioration de la présentation du menu
 ### Bonus difficile - Utiliser l'instruction `match`
 ```admonish warning title='Attention'
 Cette question n'est à faire **que si le reste du TP est terminé**. Elle demande plus d'autonomie et est beaucoup moins guidée.
 Si vous n'êtes pas très à l'aise avec Python ou la programmation il vaut mieux se concentrer sur le reste et bien comprendre.
 Cette section n'est pas nécessaire à la bonne exécution du TP ni des séances suivantes. On peut terminer sans la faire. 
 **Faites une copie de votre code dans un nouveau fichier avant toute modification afin de pouvoir revenir en arrière au prochain TP si vous ne terminez pas cette question.**
 ```
 **Objectif :** Utiliser la documentation Python pour remplacer les conditions du menu par la structure `match`.
 ```admonish tip title="A utiliser"
 - Utiliser la documentation officielle de Python pour comprendre la structure `match` : [Documentation](https://docs.python.org/3/tutorial/controlflow.html#match-statements)
 - Utiliser la structure match pour remplacer la suite de conditions
 ```
 ```admonish question
 - Comment gérer les cas non prévus dans le menu (ce que faisait le `else`) avec `match` ?
 ```
--- a/src/cours/CIEL1/01-bases-python/tp/image.png
+++ b/src/cours/CIEL1/01-bases-python/tp/image.png
--- a/src/cours/CIEL2/01-revisions-python/cours/python-bases.md
+++ b/src/cours/CIEL2/01-revisions-python/cours/python-bases.md
@ -1,291 +1 @@
-# Bases de Python
+# Cours
 ## Mode interactif ou script
 ### Mode interactif
 Nous allons commencer par utiliser Python en mode interactif. Cela nous permettra de saisir des instructions, que Python va exécuter. Ouvrez le terminal vu en 5. dans la partie précédente.
 Le mode interactif fonctionne de la manière suivante : 
 1. Il y a une **invite de commande**, qui est symbolisée par les `>>>`. Comme son nom l'indique, elle est là pour vous inviter à taper une commande.
 2. Vous pouvez taper une commande et la valider avec la touche <kbd>Entrée</kbd>
 3. Il **évalue l'expression saisie** : il l'analyse et l'exécute
 4. Il affiche enfin le résultat.
 ```admonish tip title="Astuce"
 Si vous utilisez les flèches <kbd>&uarr;</kbd> et <kbd>&darr;</kbd> dans l'invite de commande, vous pourrez naviguer dans l'historique des commandes tapées, et réutiliser d'anciennes commandes pour les modifier ou les réexécuter.
 ```
 ### Script
 ```admonish success title='À retenir'
 Un **éditeur de texte** est différent d'un **logiciel de traitement de texte**.
 - Un éditeur de texte permet de manipuler du texte brut, sans mise en forme. Il pourra avoir des fonctionnalités de coloration automatique ou de suggestions pour vous aider à écrire dans des langages de programmation. Ex: VSCode, Notepad++, Geany, Gedit, Kate, Sublime Text (non libre)...
 - Un logiciel de traitement de texte ne peut pas être utilisé pour écrire du code : il contient de nombreuses informations de mise en forme et travaille généralement avec des fichiers binaires ou un format spécifique très éloigné du texte brut nécessaire à la programmation. Ex: Libre Office Writer, Only Office Document, Microsoft Office Word (non-libre)
 ```
 ```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`
 ```
 ## Opérateurs, variables, types
 ### Opérateurs
 #### Opérateurs de calcul
 ```admonish success title="À retenir"
 - Python utilise la notation anglo-saxonne pour les nombres non entiers (c'est à dire un point au lieu d'une virgule) : il écrira `4.5` et non pas `4,5`. Il en va de même lorsque vous écrirez des nombres en Python.
 - Opérateurs courants en python :
 |Opérateur|Explication|
 |-|-|
 |`+`|Addition|
 |`-`|Soustraction|
 |`*`|Multiplication|
 |`/`|Division|
 |`//`|Division entière (renvoie un quotient entier)|
 |`%`|Modulo (renvoie le reste de la division euclidienne)|
 |`**`|Puissance|
 - Les nombres décimaux ont parfois des valeurs approximatives. Il faut être vigilant lorsqu'on les utilise dans des calculs.
 ```
 #### 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.
 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. 
 ```
 ```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'
 ```
 #### Opérateurs booléens
 #### Opérateurs bit à bit
 ### Variables
 Que sont les variables ? C'est la base de tout programme informatique : elles vous permettent de stocker une information (un nombre, le résultat d'un calcul, une phrase sous forme de chaîne de caractères...) pour la réutiliser plus tard.
 ```admonish success title="À retenir"
 - Les variables sont une donnée de votre programme stockée dans l'ordinateur.
 - Elles sont nommées et on peut les **affecter** en écrivant `ma_variable = <contenu de ma variable>` (attention la variable est toujours à gauche, le contenu toujours à droite). Affecter signifie mettre un contenu dans la variable.
 - Les noms des variables peuvent comporter:
    - Des caratères **alphanumériques**, c'est à dire des lettres minuscules ou majuscules et des chiffres
    - Des `_` (tiret du bas, sur la touche <kbd>8</kbd> de votre clavier)
 - Les noms des variables ne peuvent pas commencer par un chiffre
 - Les noms des variables sont **sensibles à la casse** : c'est à dire qu'une variable écrite avec des majuscules sera différente d'une variable écrite avec des minuscules (par exemple ma variable `age` sera différente de `Age`)
 - Certains mots-clés ne peuvent pas être utilisés comme des noms de variables parce qu'ils sont **réservés**, c'est à dire qu'ils ont une autre signification dans le langage.
 - En python, la **convention** veut que l'on écrive les variables sous la forme dite **snake case** : on va l'écrire avec uniquement des minuscules en remplaçant les espaces par des `_`. Par exemple, une variable représentant la date de naissance pourra s'écrire : `date_de_naissance`
 ```
 Vous verrez la plupart des mots **réservés** par la suite, et comprendrez vite pourquoi on ne peut pas les utiliser comme variables, tout en les retenant facilement, mais vous pourrez trouver la liste de ces mot-clés dans la [documentation python](https://docs.python.org/3/reference/lexical_analysis.html#keywords)
 ```admonish warning title="Important"
 Python utilise beaucoup de **conventions** dans son langage. Une convention est une règle qui n'est pas obligatoire mais que tout le monde respecte par habitude, et parce que cela permet d'avoir un code qui est facile à lire par tout le monde. Même si elles sont parfois arbitraires, elles ont en général été pensées et établies par la communauté suite à des retours d'expérience. Par ailleurs, certaines conventions permettent de donner des informations supplémentaires importantes (nous en verrons régulièrement par la suite). 
 Pour la suite de ce TP, mais également dans vos TD, projets ou évaluations, vous devrez respecter les conventions que nous verrons pour prendre les bonnes habitudes, sinon je les considèrerai comme des erreurs.
 ```
 ### Types
 Les variables peuvent contenir differents types de données. Nous avons surtout vu des nombres jusqu'à maintenant, mais elles peuvent aussi contenir des **chaînes de caractères** ou d'autres types plus complexes. Nous verrons dans un premier temps les plus simples. 
 ```admonish success title="À retenir"
 - Python est capable de trouver le type d'une donnée tout seul, et cette variable prend le type souhaité lors de l'affectation. On appelle ça du **typage dynamique**
 - Python possède une fonction `type` qui permet d'afficher le type de chaque variable. 
 ```
 ```admonish success title="À retenir"
 Voici un tableau recensant les principaux types de base de Python
 | Type | Explication | Exemple |
 |------|-------------|---------|
 | int  | Nombre entier | `1` |
 | float | Nombre décimal (à virgule "flottante") | `1.23` |
 | bool | Booléen : une valeur pouvant être soit vraie soit fausse | `True` ou `False` |
 | str | Chaîne de caractères : des caractères qui se suivent pour représenter du texte | `'Hello !'` |
 Les chaînes de caractères peuvent s'écrire avec des guillemets simples `'` (touche <kbd>4</kbd>) (qui est aussi utilisé en apostrophe en français) ou des guillemets doubles `"` (touche <kbd>3</kbd>).
 Vous pourrez utiliser des `"` lorsque que votre chaîne contiendra des `'` et inversement. Exemples:
 - `"J'aime les spaghettis"`
 - `'Elle a dit "Hello"'`
 ```
 #### Conversions
 ### Affichage et saisie de données
 ```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
 - 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.
 - Les chaînes de caratères peuvent être **formatées** : 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.
 ```
 ## Structures conditionnelles
 ```admonish success title='À retenir'
 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 commençant par `if`, `elif` ou `else`
    - 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
 ~~~
 ```
 ## Structures répétitives
 ```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
 ```
 ### For
 #### Fonction range
 ### While
 ## Fonctions
 Vous connaissez déjà certaines fonctions, celles que vous avez utilisées lors du précédent TP : `print`, `input`, `math.sqrt`, `range` ... Ce sont des fonctions que vous avez **appelées** mais qui existent déjà, soit par défaut dans le langage Python, soit dans une bibliothèque (`math`).
 ```admonish success title="À retenir"
 - Les fonction s'utilisent avec la syntaxe suivante : `nom_de_la_fonction(parametre_1, parametre_2, ...., parametre_n)`
    - Vous mettez le nom de la fonction, suivi de parenthèses
    - Entre les parenthèses vous mettez les paramètres séparés par des virgules
    - Si une fonction n'a pas besoin de paramètres, les parenthèses sont quand même indispensables
 - Certaines fonctions peuvent prendre des paramètres nommés, avec la syntaxe suivante : `nom_de_la_fonction(nom_parametre=valeur_parametre)`. Les paramètres nommés sont toujours à la fin et leur ordre n'a pas d'importance.
 - Une fonction peut renvoyer un résultat, que l'on peut alors affecter à une variable.
    - Si une fonction ne renvoie rien, alors elle renverra en réalité la valeur spéciale `None`.
 ```
 `
 ```admonish success title='À retenir'
 - Les fonctions servent à rendre votre code plus clair et mieux découpé. Elles permettent de réutiliser du code.
 - Pour déclarer une fonction en python :
    ~~~python
    def nom_de_la_fonction(parametre_1, parametre_2, ..., parametre_n):
        # Instructions
    ~~~
    - On utilise le mot-clé `def` suivi du nom de la fonction. 
    - Entre parenthèses on ajoute les paramètres qu'il faudra fournir
    - À la fin de la ligne on met `:` (encore et toujours)
    - On passe à la ligne suivante et on indente pour écrire les instructions.
 - Les paramètres fonctionnent comme des variables : on peut les utiliser dans la fonction avec leur nom.
 - On peut définir une valeur par défaut à un paramètre : il suffit d'écrire `parametre=valeur_par_defaut` lors de la déclaration. On peut alors omettre le paramètre, qui prendra automatiquement la valeur par défaut.
 - Deux fonctions ne peuvent pas avoir le même nom, sinon, la dernière a avoir été déclarée écrase la précédente.
 ```
 ```admonish success title="À retenir"
 - L'instruction `return` permet de sortir immédiatement d'une fonction. Rien ne s'exécutera après le `return`
 - `return` permet de retourner un résultat, avec la syntaxe `return valeur`. Si aucune valeur n'est mentionnée, elle retournera `None`
 - Si `return` n'est pas mentionnée, la fonction s'exécute jusqu'au bout et sortira à la fin du bloc d'instructions en retournant `None`
 - On peut retourner plusieurs valeurs en les séparant par une virgule. 
    - Ces valeurs peuvent être affectées à une seule variable sous forme d'un **tuple** (nous en parlerons au prochain TP)
    - Chaque valeur peut être affectée à une variable différente avec la syntaxe `variable_1, variable_2 ... = nom_de_la_fonction(...)`.
 ```
 ```admonish tip title='Bonnes pratiques'
 - Faites des fonctions courtes qui vont à l'essentiel (20 lignes est un bon maximum)
 - Choisissez bien les noms de vos fonctions et de vos paramètres pour qu'ils soient clairs et explicites
 - Vous pouvez documenter vos fonctions à l'aide d'une **docstring** : après l'en-tête de la fonction, avant le bloc d'instructions vous pouvez écrire une chaîne de caractères qui commence par 3 `"` ou `'`. 
    Exemple:
    ~~~python
    def ma_fonction(arg_1, arg2):
        """Ceci est une docstring qui vient documenter ma fonction.
        Une docstring peut prendre plusieurs lignes.
        """
        # Bloc d'instructions
    ~~~
 ```
--- a/src/cours/SUMMARY.md
+++ b/src/cours/SUMMARY.md
@ -5,7 +5,10 @@
        - [TD1 - Représentation des nombres](./CIEL1/02-reseau/td/td01-numeration.md)
        - [TD2 - Adresse IP](./CIEL1/02-reseau/td/td02_adresse_IP.md)
    - [Bases de l'algorithmique avec Python](./CIEL1/01-bases-python/algorithmique-python.md)
-        - [TP1 - Découverte de Python](./CIEL1/01-bases-python/tp/01_decouverte.md)
+        - [Cours - 1 - Bases](./CIEL1/01-bases-python/cours/python-bases-1-variables-operateurs.md)
        - [Cours - 2 - Structures de contrôle](./CIEL1/01-bases-python/cours/python-bases-2-structures-controle.md)
        - [Cours - 3 - Fonctions](./CIEL1/01-bases-python/cours/python-bases-3-fonctions.md)
        - [TP1 - Générateur de mots de passe - Menu interactif](./CIEL1/01-bases-python/tp/TP_MDP01_menu.md)
        - [TP2 - Fonctions](./CIEL1/01-bases-python/tp/02_fonctions.md)
        - [TD1 - Bases](./CIEL1/01-bases-python/td/td01-python.md)
        - [TD2 - Fonctions ](./CIEL1/01-bases-python/td/td02-fonctions.md)