Ajoute TP1 Python CIEL2

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

@@ -89,7 +89,7 @@ En utilisant la [documentation du module `math`](https://docs.python.org/3/libra
 
 1. Donnez les expressions qui permettront de calculer :
     - la racine carrée de 81
-    - la valeur absolue de -12
+    - 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
@@ -168,7 +168,7 @@ Les variables peuvent contenir differents types de données. Nous avons surtout
 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. Donnez une expression permettant d'affecter le *texte* `'21'` à la variable "mon_age_str" en utilsant uniquement la variable `mon_age` (question 1) et la fonction `str`. Utilisez la fonction type pour vérifier. Qu'en déduisez-vous sur la fonction `str` ? 
+7. Donnez une expression permettant d'affecter le *texte* `'21'` à la variable `mon_age_str` en utilsant uniquement la variable `mon_age` (question 1) et la fonction `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` ?
 ```
 
@@ -182,7 +182,7 @@ Voici un tableau recensant les principaux types de base de Python
 | 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 apostrphe en français) ou des guillemets doubles `"` (touche <kbd>3</kbd>).
+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"`
@@ -338,7 +338,7 @@ Dans un nouveau fichier que vous appellerez `tp-01-conditions.py`
 
 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.
+    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'
@@ -357,7 +357,7 @@ else:
 - 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
+    - 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
 ```

src/cours/CIEL1/01-bases-python/tp/02_fonctions.md

@@ -213,25 +213,10 @@ Si on reprend le code de la partie précédente, on voit qu'il permet d'afficher
     ~~~
    Que fait l'instruction `return` selon vous ? N'hésitez pas à expérimenter
 2. Donnez le code permettant d'affecter le résultat de la fonction à une variable pour ensuite l'afficher. Vous pourrez calculer l'aire d'un carré de côté 3m pour cet exemple.
-3. Modifiez la fonction comme suit :
-    ~~~python
-    def aire_carre(cote):
-        aire = cote * cote
-        print("Avant return")
-        return aire
-        print("Après return")
-    ~~~
-    Exécutez la fonction. Que se passe-t-il ? Pourquoi à votre avis ? 
-    
-    Vous pouvez retirer les deux lignes `print` pour la suite.
-4. Modifiez la fonction comme suit:
-    ~~~python
-    def aire_carre(cote):
-        aire = cote * cote
-        return
-    ~~~
-    1. Affectez le résultat de la fonction à une variable, puis affichez cette variable. Quelle valeur a la variable ? pourquoi ?
-    1. Retirez la ligne return et recommencez. Est-ce que cela change quelque chose ?
+1. Expérimentez pour répondre aux questions suivantes. Donnez le code utilisé à chaque fois.
+    a. Que retourne une fonction qui utilise l'instruction `return` sans préciser de valeur ?
+    b. Que se passe-t-il si une instruction se trouve après l'instruction `return` dans votre fonction ?
+    c. Que retourne une fonction qui n'a pas d'instruction `return` ?
 1. Nous voulons maintenant que notre fonction renvoie l'aire **et** le périmètre d'un carré. Pour cela, modifions la fonction comme suit.
    ~~~python
    def carre(cote):

src/cours/CIEL1/01-bases-python/tp/roulette.py

@@ -1,70 +0,0 @@
-from random import randint
-from math import ceil
-
-def miser(argent_restant):
-    numero = choisir_nombre()
-    mise = miser_argent(argent_restant)
-    return numero, mise
-
-def choisir_nombre():
-    nombre = -1
-    while not (0 <= nombre <= 49):
-        nombre = int(input("Choisissez un nombre (0-49) : "))
-        if not (0 <= nombre <= 49):
-            print("Erreur : le nombre doit être compris entre 0 et 49")
-    return nombre
-
-def miser_argent(argent_restant):
-    mise = -1
-    while not (0 < mise <= argent_restant):
-        mise = int(input(f"Choisissez votre mise (argent disponible : {argent_restant}) : "))
-        if not (0 < mise <= 49):
-            print(f"Erreur : la mise doit être comprise entre 1 et {argent_restant}")
-    return mise
-
-def tourner_la_roulette():
-    numero = randint(0, 49)
-    print(f"Le croupier tourne la roulette. Le numéro {numero} est le numéro gagnant !")
-    return numero
-
-def calculer_gains_couleur(mise):
-    return ceil(mise*0.5)
-
-def calculer_gains_numero(mise):
-    return mise * 3
-
-def continuer_de_jouer(argent):
-    if argent <= 0:
-        print("Vous êtes ruiné.e. C'est la fin de la partie.")
-        return False
-    else:
-        print(f"Il vous reste {argent}")
-        rejouer = input("Souhaitez-vous continuer ? (o/n)")
-        if rejouer == "o" or rejouer == "O":
-            return True
-        else:
-            print(f"Vous quittez le jeu avec {argent}")
-            return False
-
-argent = 100
-continuer = True
-
-while continuer:
-    gains = 0
-    numero_misé, mise = miser(argent)
-
-    numero_gagnant = tourner_la_roulette()
-    if numero_misé == numero_gagnant:
-        gains = calculer_gains_numero(mise)
-        print(f"Bravo, vous avez misé sur le numéro gagnant. Vous gagnez {gains}")
-    elif numero_misé % 2 == numero_gagnant % 2:
-        gains = calculer_gains_couleur(mise)
-        print(f"Bravo, vous avez misé sur la bonne couleur. Vous gagnez {gains}")
-    else:
-        gains = -mise
-        print(f"Dommage, vous avez perdu votre mise : {mise}")
-
-    argent += gains
-    continuer = continuer_de_jouer(argent)
-
-

src/cours/CIEL1/01-bases-python/tp/roulette_final.py

@@ -1,6 +1,5 @@
 from math import ceil
 from random import randint
-#TODO
 
 def miser(jetons_restants):
     nombre = choisir_nombre()

src/cours/CIEL2/01-revisions-python/tp/tp1_bases.md

@@ -0,0 +1,486 @@
+# TP Python - Bases
+
+Dans ce TP nous allons revoir les bases de la programmation en python. Nous commencerons par utiliser VSCode, qui nous sevrira d'éditeur de texte pour les TP Python cette année, puis nous verrons quelques exercices permettant de revoir les notions principales :
+- Les variables, l'affichage d'informations et la saisie de l'utilisateurice
+- Les structures conditionnelles : `if ... elif ... else`
+- Les boucles `for` et `while`
+- Et les fonctions
+
+Nous en profiterons pour ajouter quelques remarques sur les bonnes pratiques de code au fil de l'eau.
+
+## Travailler avec Visual Studio Code
+
+Visual Studio Code est un éditeur de texte libre édité par Microsoft, compatible avec toutes les plateformes. Il est un logiciel très utilisé en entreprise et pourra vous servir pour de nombreux langages de programmation. C'est pour cela que nous allons commencer (continuer ?) à l'utiliser, et vous vous habituerez à son fonctionnement au fil du temps.
+
+```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)
+```
+
+Lancez Visual Studio Code depuis le menu démarrer de votre machine. Vous verrez une interface comme ci-dessous. Sur la capture d'écran, les sections dont vous aurez besoin lors de ce TP sont indiquées par des flèches.
+
+![alt text](image-3.png)
+
+![alt text](image-8.png)
+
+```admonish travail
+1. Ouvrez un répertoire : créez un sous-répertoire dans votre espace personnel, sous `projets/python/tp1_bases/` et selectionnez-le. Cochez la case et cliquez sur `Yes, I trust the authors` si la fenêtre ci-dessous s'ouvre.
+    ![alt text](image-4.png)
+1. Vérifiez dans le menu extensions que l'extension Python proposée par Microsoft soit bien installée. Sinon, recherchez-la dans la barre de recherche du menu des extensions et installez-la. 
+
+    ![alt text](image-6.png)
+
+    Cette extension vous permettra d'avoir une coloration syntaxique ainsi que des suggestions pour écrire le code qui vous seront très utiles. Elle vous permettra aussi de détecter des erreurs de syntaxe, ce qui pourra vous permettre de progresser plus vite.
+1. Ouvrez l'explorateur. Vous verrez qu'il n'y a aucun fichier, ce qui est normal. Nous en créerons un tout à l'heure.
+1. Ouvrez le menu Terminal, et cliquez sur `Nouveau terminal`. Vous verrez apparaître un volet en bas avec un terminal prêt à l'emploi. 
+
+    ![alt text](image-7.png)
+
+1. Dans le terminal, tapez la commande `python`. Vous verrez apparaître l'invite de commande de l'interpréteur python. Vous pourrez l'utiliser pour essayer des commandes python au cours du TP. En attendant, essayez de taper `print("Hello, World!")` dans l'interpréteur pour vérifier que tout fonctionne.
+
+    ![alt text](image-9.png)
+
+1. Dans l'explorateur, faites un clic droit et créez un nouveau fichier que vous appellerez `main.py`. Dans ce fichier, ajoutez la ligne `print("Hello, World!")`. 
+    ![alt text](image-5.png)
+1. Via l'explorateur Windows, allez dans le répertoire de travail que vous avez sélectionné à la première étape. Vous y trouverez votre fichier main.py nouvellement créé : l'explorateur de VSCode montre le contenu de votre répertoire de travail. Mais vous l'avez toujours sous les yeux, ce qui est bien plus pratique.
+1. Dans un nouveau terminal (vous pouvez cliquer sur le petit + en haut à droite du volet terminal actuel) tapez `python main.py`. Vous devriez voir s'afficher `Hello, World!` dans le terminal.
+    ![alt text](image-10.png)
+
+1. Cliquez maintenant sur le triangle en haut à droite de votre fichier. Vous devriez voir un nouveau terminal s'ouvrir et votre script sera exécuté. Vous connaissez maintenant deux méthodes pour lancer un script Python dans VSCode. 
+
+    ![alt text](image-11.png)
+
+    Remarquez que dans ce second cas, VSCode utilise des chemins absolus (depuis `C:/`), tandis que vous avez utilisé un chemin relatif (depuis le répertoire de travail).
+
+Nous voilà prêts à travailler.
+```
+
+
+## Variables, opérations, entrées-sorties et chaînes de caractères
+
+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.
+```
+
+### Opérateurs
+
+```admonish travail
+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 euclidiuenne 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.
+```
+
+Nous allons maintenant travailler avec le module `math`. 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()`
+```
+
+### 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
+
+1. Expliquez brièvement ce que fait le code suivant. Ecrivez-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
+~~~
+
+1. Modifiez la valeur de `tva` pour qu'elle prenne la valeur de 20%. Quelle valeur a `prix_ttc` ? Pourquoi ?
+
+1. 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.
+
+1. 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**.
+
+1. Donnez l'expression qui permet d'augmenter la TVA de 1%, quel que soit sont taux actuel.
+```
+
+### 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 travail
+1. En utilisant la fonction `type`, donnez le type des valeurs suivantes:
+    - 2 
+    - 3.14
+    - True
+    - "<votre prénom>"
+    - '85' (attention aux guillemets)
+1. Donnez une expression permettant d'affecter le *texte* `'21'` à la variable `mon_age` en utilisant la fonction `str` et l'entier `21`
+```
+
+```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"'`
+```
+
+### Print et input
+
+Pour la suite nous allons commencer à utiliser le fichier `main.py` créé au début de ce TP. Ouvrez-le dans VSCode.
+
+```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`
+```
+
+```admonish travail
+1. Écrivez un script permettant d'afficher le texte `Hello, World!` grâce à la fonction `print`
+2. Écrivez un script permettant de demander à l'utilisateurice d'entrer son âge et le stocker dans une variable. Attention, la variable devra être de type `int`. 
+3. En utilisant une **chaîne de caractères formatée**, complétez le script pour afficher la phrase suivante : `Votre nom est <votre nom> et vous avez <votre âge> ans.`
+```
+
+```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
+
+### Opérateurs de comparaison et booléens
+
+```admonish travail
+1. Déclarez les variables suivantes : `a = 1`, `b = 3` et `c = 4` et donnez les expressions et les résultats des opérations suivantes
+    - a strictement supérieur à b
+    - b égal à '3' (attention aux guillemets)
+    - c inférieur ou égal à 5
+    - b compris entre a et c
+    - a différent de 1
+    - a et b différents de c
+    - a égal c ou b égal à 3
+    - l'inverse de c égal à 5
+```
+
+```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'
+```
+
+### Les conditions
+
+```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
+~~~
+```
+
+Nous allons é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 revoir 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 demander à l'utilisateurice de saisir une année, et de la stocker dans une variable. N'oubliez pas de convertir en entier 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. Écrivez 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|
+
+## Structures répétitives : `for` et `while`
+
+```admonish travail 
+1. Donnez le code permettant d'afficher la table de multiplication par 7 en allant de 1 à 10. Utilisez une boucle `while`.
+2. Donnez le code permettant d'afficher la même table mais en utilisant cette fois une boucle `for`
+```
+
+```admonish help title='Aide'
+Vous pouvez utiliser la fonction `range`, qui permet de renvoyer un **générateur** (sorte de liste dynamique) de séquence de nombres dans un intervalle. Ex: `range(1, 6)` renverra tour à tour les nombres de 1 à 5 (le dernier nombre de l'intervalle 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
+```
+
+## 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`.
+```
+
+Nous allons maintenant créer une fonction par nous-mêmes à partir du code de la partie précédente, permettant d'afficher la table de multiplication par 7.
+
+```admonish travail
+1. Modifiez votre code pour mettre le calcul et l'affichage de la table de 7 dans une fonction `table`. Appelez cette fonction à la fin de votre script.
+1. Bon, maintenant nous avons une fonction qui fait la même chose qu'avant. Mais si on veut calculer la table par 5 ou 8, il nous faudrait pouvoir passer la table en paramètre. Modifiez votre code pour prendre en paramètre la table à afficher. Modifiez l'appel en conséquence et vérifiez que ça marche si vous passez 5 ou 8 par exemple.
+1. Ajoutez un nouveau paramètre `maximum` qui servira à déterminer le nombre de lignes à afficher. Par exemple, si `nb` vaut 5 et `maximum` vaut 20, on affichera la table de 5 avec les valeurs de 1 à 20. 
+    
+    Modifiez les appels à votre fonction en conséquence et vérifiez que tout fonctionne comme prévu.
+
+6. Dans la majorité des cas on voudra probablement afficher la table jusqu'à 10. Pour nous éviter de devoir préciser `maximum` à chaque fois, nous allons mettre une valeur par défaut à `maximum` pour que la fonction affiche les 10 premières lignes si le paramètre n'est pas précisé. 
+
+    Exécutez votre fonction avec `table(5, 20)` puis `table(7)` et vérifiez que nous avons bien la table par 5 de 1 à 20 dans le premier cas, et la table par 7 de 1 à 10 dans le second
+
+7. Copiez le code suivant à la suite de votre fichier, puis exécutez-le. Quelle est la dernière ligne qui s'affiche ? À votre avis pourquoi ? 
+    ~~~python
+    def exemple():
+        print("Ma première fonction d'exemple")
+
+    def exemple():
+        print("Ma deuxième fonction d'exemple")
+
+    exemple()
+    ~~~
+
+8. Créez une fonction `aire_carre` permettant de retourner l'aire d'un carré de côté passé en paramètre. Exécutez la fonction et affichez son résultat avec `print`
+
+1. Modifiez la fonction pour retourner à la fois l'aire d'un carré et le périmètre d'un carré. Appelez la fonction, stockez les deux résultats dans deux variables
+
+1. Expérimentez pour répondre aux questions suivantes. Donnez le code utilisé à chaque fois.
+    a. Que retourne une fonction qui utilise l'instruction `return` sans préciser de valeur ?
+    b. Que se passe-t-il si une instruction se trouve après l'instruction `return` dans votre fonction ?
+    c. Que retourne une fonction qui n'a pas d'instruction `return` ?
+```
+
+```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
+    ~~~
+```

src/cours/SUMMARY.md

@@ -19,5 +19,6 @@
     - [Une application web complète avec Python](./CIEL1/07-appli-web/appli-web.md)
 - [CIEL 2e année](./CIEL2/ciel2.md)
     - [Révisions Python](./CIEL2/01-revisions-python/python-revisions.md)
+        - [TP1 - Bases de Python](./CIEL2/01-revisions-python/tp/tp1_bases.md)
     - [Python objet](./CIEL2/02-python-objet/python-objet.md)
     - [Bases de données](./CIEL2/03-base-de-donnees/bases-de-donnees.md)