Ajouts et corrections diverses avant rentrée

src/cours/CIEL1/01-bases-python/td/td02-fonctions.md

@@ -15,10 +15,10 @@
 
 1. Un gardien de phare va aux toilettes cinq fois par jour. Or les WC sont au rez-de-chaussée. Écrire une procédure (fonction qui ne renvoie rien) qui reçoit deux paramètres : la hauteur d'une marche et le nombre de marches. Cette fonction devra afficher le nombre de mètres en hauteur parcourus chaque semaine par le gardien. La phrase affichée sera de la forme : `Pour x marches de y centimètres il parcourt z mètres par semaine`
 
-Attention : 
-- Une semaine comporte 7 jours (pas de repos pour les gardiens de phare...)
-- Une fois en bas le gardien doit remonter
-- Les hauteurs de marches sont en centimètres, mais le résultat est à exprimer en mètres
+    Attention : 
+    - Une semaine comporte 7 jours (pas de repos pour les gardiens de phare...)
+    - Une fois en bas le gardien doit remonter
+    - Les hauteurs de marches sont en centimètres, mais le résultat est à exprimer en mètres
 
 
 ## Exercices avancés :

src/cours/CIEL1/01-bases-python/td/td02.md

@@ -1 +0,0 @@
-# TD2 - Python

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

@@ -1,6 +1,6 @@
 # Découverte de Python
 
-## Découverte de l'interpréteur 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.
 
@@ -28,11 +28,11 @@ Le mode interactif fonctionne de la manière suivante :
 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.
 ```
 
-## Python est une calculatrice
+## 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.
 
-### Une calculatrice simple
+### 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 ?
@@ -59,7 +59,7 @@ Vous pouvez utiliser l'interpréteur de python comme une calculatrice. C'est év
 - Les nombres décimaux ont parfois des valeurs approximatives. Il faut être vigilant lorsqu'on les utilise dans des calculs.
 ```
 
-### Mais aussi une calculatrice scientifique
+### 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**. 
 
@@ -96,9 +96,9 @@ En utilisant la [documentation du module `math`](https://docs.python.org/3/libra
 2. Expliquez la différence entre les fonctions `math.floor()` et `math.ceil()`
 ```
 
-## Les variables et les types
+## 3 - Les variables et les types
 
-### Les variables
+### 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.
 
@@ -152,7 +152,7 @@ Nous allons donc affecter et utiliser nos premières variables.
     e. Donnez l'expression qui permet d'augmenter la TVA de 1%, quel que soit sont taux actuel.
 ```
 
-### Les types de données et la fonction `type`
+### 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. 
 
@@ -189,7 +189,7 @@ Vous pourrez utiliser des `"` lorsque que votre chaîne contiendra des `'` et in
 - `'Elle a dit "Hello"'`
 ```
 
-## Un premier script
+## 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.
 
@@ -217,7 +217,7 @@ Pour commencer nous allons enregistrer notre script dans un fichier. Cliquez sur
 
 Allez dans votre espace personnel, choisissez un nom, par exemple `tp01-hello-world.py`, et cliquez sur `Sauvegarder`. Voilà, nous sommes prêts à travailler.
 
-### La fonction print
+### 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 ?
@@ -258,7 +258,7 @@ L'interpréteur affiche les valeurs des variables pour vous aider à comprendre
 Les chaînes formatées sont très utilisées en python. Elles servent à afficher des informations dynamiques en fonction de variables, mais vous aideront aussi à comprendre ce que font vos programmes et vous aider à les corriger.
 ```
 
-### La fonction input
+### 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.
 
@@ -290,9 +290,9 @@ Pouvoir afficher du texte est déjà très bien, mais pouvoir en saisir est éga
 - Le résultat de la fonction peut être immédiatement affecté à une variable.
 ```
 
-## Structure conditionnelle
+## 5 - Structure conditionnelle
 
-### if ... elif ... else ...
+### 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 :
@@ -371,7 +371,7 @@ else:
 ~~~
 ```
 
-### Les opérateurs de comparaison
+### 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 :
@@ -406,7 +406,7 @@ De même, si vous écrivez `if True: ...` la condition sera toujours vraie, donc
 Les opérateurs `>`, `<`, `>=`, `<=` peuvent être chaînés pour faire des comparaisons d'intervalles. Par exemple, pour vérifier que la variable a est comprise entre 0 et 100, vous pouvez écrire '0 < a < 100'
 ```
 
-### Les opérateurs booléens
+### 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:
@@ -435,7 +435,7 @@ Les nombres (et plein d'autres types) peuvent être considérés comme `True` ou
 ```
 
 
-## Les boucles
+## 6 - Les boucles
 
 ```admonish travail
 Créez un nouveau script que vous appellerez `tp01-boucles.py`
@@ -495,13 +495,13 @@ Créez un nouveau script que vous appellerez `tp01-boucles.py`
     - Attention au `:` et à l'indentation
 ```
 
-## Mises en pratique
+## 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.
 
-### Les années bissextiles
+### 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. 
 
@@ -547,7 +547,7 @@ Quelques années, selon les critères :
 |2000|oui|oui|oui|oui|
 
 
-### Le jeu du plus ou moins
+### 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.
 

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

@@ -4,9 +4,9 @@ Dans le précédent TP vous avez vu les bases du langage Python. Vous les avez m
 
 Dans ce TP, nous allons commencer à utiliser Visual Studio Code, qui nous servira toute l'année d'éditeur de texte pour la plupart des TP. Ensuite, nous verrons une notion indispensable à tous les langages de programmation : les fonctions. Nous en profiterons pour réutiliser les notions du TP précédent pour continuer de les pratiquer et, petit à petit, mieux les maîtriser. Vous écrirez, pas à pas, un programme plus conséquent que ce que vous avez écrit jusqu'à maintenant. 
 
-## Utilisation de Visual Studio Code
+## 1 - Utilisation de Visual Studio Code
 
-### Mise en route
+### 1.1 - Mise en route
 
 Pour ce TP nous n'allons plus utiliser Thonny mais Visual Studio Code. Thonny est un excellent logiciel pour débuter en python, et il sera facile à utiliser pour vous entraîner à la maison, mais il n'est pas beaucoup utilisé par les professionnels car il manque de nombreuses fonctionnalités indispensables. Visual Studio Code est un éditeur de texte libre édité par Microsoft, compatible avec toutes les plateformes. Il permet de faire ce que fait Thonny, mais également plein d'autres choses. C'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 à l'utiliser, et vous vous habituerez à son fonctionnement au fil du temps.
 
@@ -48,9 +48,9 @@ Lancez Visual Studio Code depuis le menu démarrer de votre machine. Vous verrez
 Nous voilà prêts à travailler.
 ```
 
-## Les fonctions
+## 2 - Les fonctions
 
-### Utilisation d'une fonction
+### 2.1 - Utilisation d'une fonction
 
 Nous allons maintenant écrire un script que nous modifierons pour découvrir les fonctions. 
 
@@ -100,7 +100,7 @@ Vous connaissez déjà certaines fonctions, celles que vous avez utilisées lors
     - Si une fonction ne renvoie rien, alors elle renverra en réalité la valeur spéciale `None`.
 ```
 
-### Créer notre première fonction
+### 2.2 - Créer notre première fonction
 
 Maintenant que vous savez comment utiliser une fonction nous allons créer une fonction par nous-mêmes.
 
@@ -204,7 +204,7 @@ Si on reprend le code de la partie précédente, on voit qu'il permet d'afficher
     ~~~
 ```
 
-### L'instruction `return`
+### 2.3 - L'instruction `return`
 
 ```admonish travail
 1. Créez un nouveau fichier dans l'explorateur, nomme carre.py puis copiez la fonction ci-dessous :
@@ -240,7 +240,7 @@ Si on reprend le code de la partie précédente, on voit qu'il permet d'afficher
     - Chaque valeur peut être affectée à une variable différente avec la syntaxe `variable_1, variable_2 ... = nom_de_la_fonction(...)`.
 ```
 
-### Mise en pratique
+### 2.4 - Mise en pratique
 
 Nous allons mettre en pratique ce que nous avons vu jusqu'à maintenant dans un script un peu plus conséquent.
 

src/cours/CIEL1/02-reseau/cours/adressage-ip.md

@@ -1,10 +1,10 @@
 # L'adressage IP
 
-## Première approche de l'adressage IP
+## 1 - Première approche de l'adressage IP
 
 Commençons par une approche globale et simplifiée pour bien comprendre comment fonctionne l'adressage IP.
 
-### Adressage logique
+### 1.1 - Adressage logique
 
 Nous allons faire une analogie avec le courrier. Imaginons que nous souhaitons envoyer du courrier à des personnes précises. On pourrait attribuer à chaque personne un identifiant à la naissance (son nom par exemple), qui nous permettrait de l'identifier à coup sûr, et mettre cet identifiant sur l'enveloppe. Cet identifiant unique, en informatique, correspond à l'adresse MAC. Il permet d'identifier de manière unique une machine physique. 
 
@@ -28,7 +28,7 @@ Un **réseau logique** est formé par des **hôtes** (poste informatique, télé
 Dans les réseaux informatiques, nous utilisons le protocole IP (Internet Protocol) pour définir des adresses logiques.
 ```
 
-### Comment est formée une adresse IP ?
+### 1.2 - Comment est formée une adresse IP ?
 
 Nous allons parler ici d'adresse IPv4 (IP version 4), le protocole encore majoritairement utilisé dans le monde. Il existe également le protocole IPv6 (IP version 6) qui devrait remplacer IPv4, mais pour de nombreuses raisons techniques et politiques, cette transition tarde depuis des années.
 
@@ -41,7 +41,7 @@ Pour savoir où s'arrêtent les parties gauche et droite, et donc à quelle part
 
 Nous verrons plus loin le fonctionnement détaillé de l'adresse IP et du masque.
 
-### Routeur et interconnexion de réseaux logiques
+### 1.3 - Routeur et interconnexion de réseaux logiques
 
 Les réseaux logiques ont pour objectif de retrouver plus facilement l'emplacement d'un hôte sur le réseau. Mais comment ça se passe en réalité pour faciliter cette recherche ?
 
@@ -59,7 +59,7 @@ En pratique, un routeur est une machine qui possède plusieurs cartes réseau, e
 
 Les algorithmes impliqués dans le routage seront l'objet d'un autre cours. Pour le moment, contentons nous de savoir comment les réseaux logiques peuvent être interconnectés.
 
-## L'adresse MAC
+## 2 - L'adresse MAC
 
 ```admonish success title="À retenir"
 L'**adresse MAC** (*Media Access Control*) ou **adresse physique** est un identifiant physique **unique** stocké directement dans la carte réseau. Toutes les cartes réseau ont une adresse MAC.
@@ -69,9 +69,9 @@ Elle est constituée de 48 bits (6 octets) et représentée sous forme hexadéci
 
 **Exemple :** `5E:FF:56:A2:AF:15`
 
-## L'adresse IP
+## 3 - L'adresse IP
 
-### Structure d'une adresse IP
+### 3.1 - Structure d'une adresse IP
 
 ```admonish success title="À retenir"
 Une adresse IPv4 (Internet Protocol v4) est une suite de 32 bits (= 4 octets) exprimées sous la forme de 4 nombres décimaux (représentant les 4 octets) séparés par un point.
@@ -83,7 +83,7 @@ L'adresse IP d'un hôte permet de définir précisément
 
 ![Adresse IP](./adresse-ip.svg)
 
-### Le masque
+### 3.2 - Le masque
 
 ```admonish success title="À retenir"
 Le masque est une suite de 32 bits constituée d'une suite de 1 et d'une suite de 0.
@@ -109,7 +109,7 @@ La notation CIDR consiste à faire suivre l'adresse IP par le nombre de bits à
 Le masque n'est pas forcément un multiple de 8 : n'importe quel nombre de bits entre 1 et 32 peut être un masque valide, selon la taille du réseau.
 ```
 
-### L'adresse de réseau
+### 3.3 - L'adresse de réseau
 
 ```admonish success title="À retenir"
 Un réseau est un groupe d'hôtes dont la partie réseau de l'adresse est identique. Un ET logique entre l'adresse IP et son masque permettent de déterminer l'adresse de réseau.
@@ -121,7 +121,7 @@ Pour rappel, quand on applique le ET logique, seul 1 ET 1 = 1, tout le reste vau
 
 Si on fait l'opération ET logique, on voit que les bits de la partie hôte sont tous à zéro ( = ils sont masqués) alors que les bits de la partie réseau gardent leur valeur.
 
-### L'adresse de diffusion
+### 3.4 - L'adresse de diffusion
 
 ```admonish success title="À retenir"
 **L'adresse de diffusion** (ou *broadcast* en anglais) permet d'envoyer un message à l'ensemble des hôtes connectés au réseau.
@@ -131,7 +131,7 @@ L'adresse de diffusion est la dernière adresse du réseau. Elle est constituée
 
 ![Adresse de diffusion](./diffusion.svg)
 
-### Plage adressable et nombre d'hôtes possibles
+### 3.5 - Plage adressable et nombre d'hôtes possibles
 
 ```admonish success title="À retenir"
 La plage adressable est l'ensemble des adresses que peut prendre un hôte sur le réseau.
@@ -160,9 +160,9 @@ On utilise toute la plage des valeurs possibles sur ce nombre de bits, mais deux
 Dans le réseau 192.168.1.0/24, il y a 32-24 = 8 bits dédiés à la partie hôte, soit 256 valeurs possibles. Comme on enlève l'adresse de réseau et l'adresse de diffusion, il reste 254 valeurs, soit une plage disponible de 254 adresses sur ce réseau. 
 
 
-## Les catégories d'adresses
+## 4 - Les catégories d'adresses
 
-### Adresses publiques
+### 4.1 - Adresses publiques
 
 Les adresses IP sont censées être uniques sur chaque hôte. Dans un réseau privé local, c'est plutôt simple, il y a généralement peu de machines, et le réseau est isolé du reste du monde. Sur internet, il y a des milliards d'hôtes, ça devient donc beaucoup plus difficile. Il a fallu confier la gestion des adresses à un organisme chargé d'organiser et garantir l'unicité des adresses IP.
 
@@ -174,19 +174,19 @@ Chacun de ces RIR attribue ainsi des plages à des RIL (Registres Internet Locau
 
 Toutes ces adresses, distribuées par L'IANA, sont des adresses dites publiques.
 
-### Adresses privées
+### 4.2 - Adresses privées
 
 Les adresses privées sont celles utilisées dans les réseaux privés comme par exemple les réseaux internes des entreprises ou chez des particuliers. Ce sont des plages d'adresses bien définies qui ne seront jamais attribuées par l'IANA pour éviter tout risque d'interférence avec des adresses existant sur internet. 
 
 Vous pouvez les utiliser sans risque pour tout réseau interne (entreprise ou chez vous). Vous pouvez également définir des masques plus restrictifs que ceux proposés par défaut.
 
-### Adresses spéciales
+### 4.3 - Adresses spéciales
 
-#### L'adresse de réseau
+#### 4.3.1 - L'adresse de réseau
 
 Comme dit plus haut, l'adresse de réseau est l'adresse dont la totalité des bits de la partie hôte sont à 0. Cette adresse désigne le réseau en lui-même, pas un hôte en particulier.
 
-#### La boucle locale
+#### 4.3.2 - La boucle locale
 Les adresses 127.0.0.0/8 sont utilisées pour la boucle locale (c'est à dire atteindre la machine elle-même). On utilise plus généralement l'adresse de bouclage (loopback) 127.0.0.1
 
 - Elle désigne la machine locale
@@ -194,19 +194,19 @@ Les adresses 127.0.0.0/8 sont utilisées pour la boucle locale (c'est à dire at
 - Elle simule un accès via le réseau même sans réseau
 - On peut l'utiliser pour des communications en local ou des tests
 
-#### L'adresse de diffusion (broadcast)
+#### 4.3.3 - L'adresse de diffusion (broadcast)
 
 Nous en avons parlé plus haut : c'est la dernière adresse disponible du réseau, celle où tous les bits de la partie hôte sont à 1. Si on veut envoyer un message diffusé à toutes les adresses d'un réseau précis (qui peut être différent du réseau de l'hôte émetteur), c'est cette adresse qu'il faut utiliser.
 
-#### L'adresse de diffusion générale
+#### 4.3.4 - L'adresse de diffusion générale
 
 255.255.255.255 : pour diffuser sur le réseau actuel de l'hôte, sans avoir à connaître l'adresse du réseau.
 
-#### L'adresse d'initialisation
+#### 4.3.5 - L'adresse d'initialisation
 
 0.0.0.0 : C'est l'adresse utilisée par un hôte lors de la phase d'initialisation (au moment où une machine cherche à se connecter à un réseau IP). Elle ne peut donc pas être affectée à une machine particulière.
 
-### Classes d'adresses
+### 4.4 - Classes d'adresses
 
 Historiquement, les adresses IP étaient regroupées en cinq classes. C'était uns sytème rigide, et le masque était implicitement déduit de l'adresse IP (certaines plages d'adresse appartenaient à une classe donnée, et cela suffisait à déterminer le masque). Ce système est devenu obsolète depuis le milieu des années 1990. Nous le mentionnons ici pour que vous en ayez déjà entendu parler.
 
@@ -220,13 +220,15 @@ Les classes A, B ou C définissaient des réseaux d'une certaine taille, et une
 
 Les classes D et E étaient particulières. D servait aux machines diffusant les informations de routage, et E était une plage d'adresses réservées pour un éventuel usage futur.
 
-Des entreprises se voyant attribuer des plages de classe A avaient 16 millions d'adresses IP pour elles seulles. Imaginez le gaspillage d'adresses que ça représentait. 
+Des entreprises se voyant attribuer des plages de classe A avaient 16 millions d'adresses IP pour elles seules. Imaginez le gaspillage d'adresses que ça représentait. 
 
 Aujourd'hui ce système n'existe plus, et n'importe quelle adresse IP peut avoir n'importe quel masque. C'est le système sans classe ("classless" comme le C dans CIDR)
 
 Nous manquons déjà cruellement d'adresses IPv4 alors imaginez si on avait gardé ce système.
 
-## Le plan d'adressage
+## 5 - Le plan d'adressage
+
+### 5.1 - Le plan d'adressage
 
 Les organisations ont souvent besoin de segmenter leur réseau interne selon leur mode de fonctionnement. Pour cela, elles vont mettre en place un plan d'adressage précis, qui permettra de distribuer des adresses aux machines hôtes selon leur rôle dans l'organisation, mais également permettre ou empêcher la communication entre certaines machines. L'organisation pourra donc découper son réseaux en sous-réseaux de tailles (et de masques) différents.
 
@@ -241,7 +243,7 @@ Le plan d'adressage devra répondre à certaines contraintes pour être viable,
 - On pourra donc utiliser un masque de 29 bits. Nous pouvons fixer l'adresse de sous-réseau à 10.0.0.0/29 et donc avoir un réseau pour notre service comptabilité qui couvre la plage de 10.0.0.1 à 10.0.0.6
 
 
-### Obtenir une adresse IP
+### 5.2 - Obtenir une adresse IP
 
 Toutes les machines qui veulent être rattachées au réseau IP doivent donc avoir une adresse IP unique. Pour cela, il y a **deux stratégies** possibles :
 - L'adresse IP est configurée de façon **statique** sur la machine. 

src/cours/CIEL1/02-reseau/cours/operations.md

@@ -0,0 +1,103 @@
+# Opérations booléennes
+
+Les opérations que l'on peut effectuer sur des bits sont théorisées par le mathématicien George Boole, dans le cadre de l'agèbre de Boole, ou calcul booléen.
+
+En informatique, on peut avoir besoin de faire des opérations binaires dans deux cas :
+- En programmation, quand ion veut valider si une condition est vraie ou fausse. En Python, cela se traduira par l'utilisation du type `bool` qui peut prendre les valeurs `True` ou `False`. C'est comme si on travaille avec un seul bit.
+- Faire des calculs sur les bits d'un nombre pour le modifier. C'est une utilisation plus rare en python, mais que l'on retrouve dans le domaine de l'informatique embarquée (soit en Python, soit en C ou C++) ou du réseau. On travaille avec la représentation binaire sous-jacente aux nombres. Il faut alors réfléchir aux nombres comme à des suites de bits, et les opérations s'appliquent les bits 1 à 1.
+
+Nous allons voir dans la suite les opérateurs classiques pour le calcul booléen. Ces opérateurs existent en python, nous verrons donc la syntaxe python également.
+
+```admonish warning title="Attention"
+Les opérateurs bit à bit en Python sont différents des opérateurs logiques utilisés dans les conditions. 
+
+- Les opérateurs utilisés dans les conditions travaillent avec des types booléens `bool` (valeur `True` ou `False`) et renvoient un résultat booléen. Ils s'écrivent avec des lettres (`and or not`). Comme ils sont très courants, ça facilite la lecture du code.
+- Les opérateurs bit à bit travaillent avec la représentation binaire des nombres entiers, c'est à dire directement avec les bits sous jacents aux nombres, et permettent de faire des calculs sur plusieurs bits à la fois. On travaille alors non pas avec des booléens, mais avec des nombres entiers vus comme des séries de bits. Ils sont représentés sous forme de symboles (`& | ~`)
+```
+
+## Table de vérité
+
+Nous allons donner pour chaque opérateur une table de vérité. La table montre le résultat de toutes les opérations possibles avec cet opérateur.
+Elle comporte plusieurs colonnes pour les **entrées** et la dernière colonne montre la valeur en **sortie**.
+
+Nous utiliserons la valeur 1 pour dire Vrai ou `True` en python, et 0 pour dire Faux ou `False` en python.
+
+## Opérateur ET
+
+```admonish success title="A retenir"
+L'opérateur ET ne renvoie 1 que si les deux arguments sont à 1. Sinon il renvoie 0.
+
+**Si A ET B valent 1**
+
+|A|B|A ET B|
+|-|-|:-:|
+|0|0|0|
+|1|0|0|
+|0|1|0|
+|1|1|1|
+
+En python :
+- `and` lorsqu'on travaille avec des booléens 
+- `&` lorsqu'on veut travailler en bit à bit
+```
+
+![ET](ET.svg)
+
+## Opérateur OU
+
+```admonish success title="A retenir"
+L'opérateur OU renvoie 1 si au moins l'un des deux arguments est à 1. Sinon il renvoie 0.
+
+**Si A vaut 1 ou si B vaut 1 ou si les deux valent 1**
+
+|A|B|A OU B|
+|-|-|:-:|
+|0|0|0|
+|1|0|1|
+|0|1|1|
+|1|1|1|
+
+En python:
+- `or` lorsqu'on travaille avec des booléens  
+- `|` lorsqu'on veut travailler en bit à bit. 
+```
+
+![OU](OU.svg)
+
+## Opérateur NON
+
+```admonish success title="A retenir"
+L'opérateur NON inverse la valeur du bit auquel il est appliqué.
+
+|A|NON A|
+|-|:-:|
+|0|1|
+|1|0|
+
+En python: 
+- `not` lorsqu'on travaille avec des booléens 
+- `~` pour l'inversion bit à bit.
+```
+
+![NON](NOT.svg)
+
+## Opérateur OU EXCLUSIF
+
+```admonish success title="A retenir"
+OU EXCLUSIF renvoie 1 si seulement l'un des deux arguments est à 1. Sinon il renvoie 0.
+
+**Si A seulement vaut 1 ou si B seulement vaut 1**
+
+|A|B|A XOR B|
+|-|-|:-:|
+|0|0|0|
+|1|0|1|
+|0|1|1|
+|1|1|0|
+
+En python, 
+- il n'existe pas pour les `bool`
+- `^` pour les opérations bit à bit
+```
+
+![XOR](XOR.svg)

src/cours/CIEL1/02-reseau/cours/representation_nombres.md

@@ -1,6 +1,6 @@
 # Représentation des entiers naturels
 
-## Base 10 et généralisation
+## 1 - Base 10 et généralisation
 
 Les nombres peuvent avoir plein de représentations différentes, selon les contextes. En informatique, on va en utiliser 4 :
 - Décimal (base 10)
@@ -51,7 +51,7 @@ La plus petite puissance (celle des unités en base 10) est de 0 (10⁰ = 1) et
 
 Maintenant que nous avons vu comment fonctionnent les bases dans le cas général, nous allons parler des systèmes binaires et hexadécimal utilisés en informatique.
 
-## La base 2, système binaire
+## 2 - La base 2, système binaire
 
 Le système binaire est très utilisé en informatique. Il sert notamment en réseaux, et c'est là que nous l'utiliserons, mais également dans l'informatique dite bas niveau, c'est à dire proche de l'électronique.
 
@@ -66,7 +66,7 @@ Chaque symbole est appelé un **bit** (**Bi**nary dig**it**) pour les distinguer
 
 On regroupe souvent les bits en paquets de 8 que l'on va appeler **octets** (bytes en anglais). Un octet permet de représenter 256 nombres (de 0 à 255)
 
-### MSB et LSB
+### 2.1 - MSB et LSB
 
 Dans un nombre binaire on se réfère souvent aux bits situés aux extrémités:
 - On parlera de **MSB** (*Most Significant Bit*) ou **bits de poids fort** pour les bits les plus à gauche (dont le **poids/rang** est plus élevé)
@@ -79,7 +79,7 @@ Pour le nombre $1001_{|2}$ :
 |MSB|||LSB|
 ```
 
-### Multiples d'octets
+### 2.2 - Multiples d'octets
 
 Pour parler des capacités de supports de stockage ou de la mémoire vive on parle en multiples d'octets. Il existe deux systèmes.
 
@@ -96,11 +96,11 @@ Pour parler des capacités de supports de stockage ou de la mémoire vive on par
     - le gibioctet (Gio) = 2³⁰ octets = 1024 Mio
     - le tébioctet (Tio) = 2⁴⁰ octets = 1024 Gio
 
-### Conversions
+### 2.3 - Conversions
 
 Dans de nombreux cas il sera nécessaire de pouvoir convertir les nombres d'une base à l'autre. Nous l'utiliserons souvent en réseau, mais également en informatique bas niveau (embarquée).
 
-#### Décimal vers binaire
+#### 2.3.1 - Décimal vers binaire
 ##### Méthode des soustractions successives
 
 La première méthode nécessite de connaître les puissances de 2 par coeur. Elle est simple et rapide pour les petits nombres (en fait pour les nombres plus petits que les puissances de deux que vous connaissez par coeur). Vous trouverez en annexe une table avec les puissances de 2 les plus courantes. 
@@ -155,7 +155,7 @@ Le nombre $53_{|10}$ qui s'écrit $110101_{|2}$ en binaire :
 ![divisions successives](./divisions_successives.svg)
 ```
 
-#### Binaire vers décimal
+#### 2.3.2 - Binaire vers décimal
 
 Pour calculer le nombre décimal à partir du nombre binaire, il suffit de prendre la formule de la première partie appliquée à une base 2 : prenez chaque bit à 1 et multipliez-le par son poids. 
 
@@ -176,7 +176,7 @@ Et donc :
 $$1\times2^5 + 1\times2^4 + 0\times2^3 + 1\times2^2 + 0\times2^1 + 1\times2^0 = 32 + 16 + 4 + 1 = 53$$
 ```
 
-## La base 16, système hexadécimal
+## 3 - La base 16, système hexadécimal
 
 Le système hexadécimal est également très utilisé :
 - Les adresses MAC en réseau, ou les adresses IPv6
@@ -193,9 +193,9 @@ Sur le même modèle que précédemment, les valeurs des symboles utilisés sont
 La convention pour écrire des nombres hexadécimaux est de les précéder par `0x` : `0x1CF`. 
 Cette écriture fonctionne en Python, qui interprètera votre valeur comme codée en hexadécimal si vous l'écrivez avec `0x`.
 
-### Conversions
+### 3.1 - Conversions
 
-#### Binaire vers Hexadécimal
+#### 3.1.1 - Binaire vers Hexadécimal
 
 Pour convertir un nombre binaire en hexadécimal, c'est plus simple. Un nombre hexadécimal est facile à représenter avec 4 bits ($1111_{|2} = 15_{|10} = \mathrm{F}_{|16}$).
 
@@ -233,7 +233,7 @@ $$\overbrace{0011}^{3_{|16}}\overbrace{0101}^{5_{|16}}$$
 3. Cela nous donne alors $110101_{|2} = 35_{|16}$
 ```
 
-#### Hexadécimal vers binaire
+#### 3.1.2 - Hexadécimal vers binaire
 
 Pour convertir un nombre hexadécimal vers binaire, il faut faire exactement pareil, en remplaçant la représentation hexadécimale du nombre par sa représentation binaire.
 
@@ -241,7 +241,7 @@ Pour convertir un nombre hexadécimal vers binaire, il faut faire exactement par
 $$\mathrm{6B}_{|16} = {\overbrace{0110}^{6_{|16}}\overbrace{1011}^{\mathrm{B}_{|16}}}_{|2}$$
 ```
 
-#### Hexadécimal vers décimal
+#### 3.1.3 - Hexadécimal vers décimal
 
 Pour calculer le nombre décimal à partir du nombre hexadécimal, il suffit de prendre la formule de la première partie appliquée à une base 16 : prenez chaque chiffre et multipliez-le par son poids.
 
@@ -263,7 +263,7 @@ Et donc :
 $$6\times16^1 + 10\times16^0 = 96 + 10 = 106$$
 ```
 
-#### Décimal vers hexadécimal
+#### 3.1.4 - Décimal vers hexadécimal
 ##### Base intermédiaire
 
 Cette méthode consiste à d'abord convertir un nombre en binaire, puis à convertir le nombre binaire en nombre hexadécimal.
@@ -294,10 +294,6 @@ Toujours avec le nombre $47_{|10}$
 On obtient donc $47_{|10} = \mathrm{2F}_{|16}$
 ```
 
-# Opérations logiques
-
-TODO
-
 # Annexes
 ### Tableau des puissances de 2
 

src/cours/CIEL1/02-reseau/td/td01-numeration.md

@@ -64,3 +64,17 @@
     - $10011010_{|2}$
     - $100110101_{|2}$
     - $111 1001 1100 1011 1101 0001_{|2}$
+
+12. Donnez le résultat des opérations booléennes suivantes, avec `a = True`, `b = False`
+    - `a and b`
+    - `a or b`
+    - `not (a and b)`
+    - `a and not b`
+    - `b or not b`
+
+13. Donnez le résultat des opérations bit à bit suivantes, avec $a = 58_{|10}$ et $b = 77_{|10}$ en considérant que $a$ et $b$ sont des octets.
+    - `a | b`
+    - `b & a`
+    - `b ^ a`
+    - `~b | a`
+    - `~(b | a)`

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

@@ -8,7 +8,7 @@ Dans ce TP nous allons revoir les bases de la programmation en python. Nous comm
 
 Nous en profiterons pour ajouter quelques remarques sur les bonnes pratiques de code au fil de l'eau.
 
-## Travailler avec Visual Studio Code
+## 1 - 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.
 
@@ -57,7 +57,7 @@ Nous voilà prêts à travailler.
 ```
 
 
-## Variables, opérations, entrées-sorties et chaînes de caractères
+## 2 - 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.
 
@@ -71,7 +71,7 @@ Le mode interactif fonctionne de la manière suivante :
 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
+### 2.1 - 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.
@@ -125,7 +125,7 @@ En utilisant la [documentation du module `math`](https://docs.python.org/3/libra
 2. Expliquez la différence entre les fonctions `math.floor()` et `math.ceil()`
 ```
 
-### Variables
+### 2.2 - 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.
 
@@ -168,7 +168,7 @@ Pour la suite de ce TP, mais également dans vos TD, projets ou évaluations, vo
 1. Donnez l'expression qui permet d'augmenter la TVA de 1%, quel que soit sont taux actuel.
 ```
 
-### Types
+### 2.3 - 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. 
 
@@ -204,7 +204,7 @@ Vous pourrez utiliser des `"` lorsque que votre chaîne contiendra des `'` et in
 - `'Elle a dit "Hello"'`
 ```
 
-### Print et input
+### 2.4 - 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.
 
@@ -230,9 +230,9 @@ Un fichier contenant du code Python s'appelle un **script**. Les scripts python
 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
+## 3 - Structures conditionnelles
 
-### Opérateurs de comparaison et booléens
+### 3.1 - 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
@@ -280,7 +280,7 @@ Les nombres (et plein d'autres types) peuvent être considérés comme `True` ou
 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
+### 3.2 - Les conditions
 
 ```admonish success title='À retenir'
 Les **structures conditionnelles** ressemblent à ceci : 
@@ -359,7 +359,7 @@ Quelques années, selon les critères :
 |1900|oui|oui|non|non|
 |2000|oui|oui|oui|oui|
 
-## Structures répétitives : `for` et `while`
+## 4 - 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`.
@@ -396,7 +396,7 @@ Vous pouvez utiliser la fonction `range`, qui permet de renvoyer un **générate
     - Attention au `:` et à l'indentation
 ```
 
-## Fonctions
+## 5 - 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`).
 

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

@@ -0,0 +1,109 @@
+# Python - Mise en pratique
+
+Nous allons mettre en pratique ce que nous avons vu jusqu'à maintenant dans un programme un peu plus conséquent.
+
+L'objectif est de créer un mini jeu dans lequel vous pourrez jouer à la roulette. Les règles seront évidemment simplifiées.
+
+- Le joueur mise sur un nombre (entier) entre 0 et 49, et annonce une mise en jetons (par exemple : 20 jetons).
+- La croupière lance la roulette, et celle-ci déterminera le numéro gagnant. Les numéros impairs ont une couleur rouge, les numéros pairs sont noirs.
+    - Si le joueur a misé sur le numéro gagnant, il remporte 3 fois sa mise
+    - Si le joueur a misé sur un nombre de même couleur (donc de même parité que le numéro gagnant), il remporte 0,5 fois sa mise (arrondi à l'entier supérieur, car les jetons sont toujours entiers)
+    - Sinon, le joueur perd sa mise. Notons qu'il la garde dans les deux autres cas, en plus de ses gains.
+- Le joueur aura 100 jetons disponibles au début de la partie. Il ne peut miser qu'un nombre entier de jeton, et seulement des jetons qu'il possède.
+- Si le joueur tombe à zéro jetons, la partie est finie.
+- Sinon, il peut rejouer (mais n'est pas obligé).
+
+Imprégnez-vous bien des règles du jeu.
+
+1. Créez un nouveau fichier appelé `roulette.py`.
+2. Copiez le contenu suivant dedans. Ce sera la structure du script, que vous complèterez à l'aide des questions suivantes. 
+
+    Il y a de nombreux `#TODO` (parfois `"#TODO"`) qu'il faudra remplacer par le code adéquat.
+
+    L'instruction `pass` sert à ne rien faire tout en ayant un script valide qui pourra donc s'exécuter sans erreur pour que vous puissiez avancer et tester votre code. Vérifiez que le code ci-dessous fonctionne sans erreur (il ne fera évidemment pas ce qui est demandé, ça c'est votre job !)
+
+    ~~~python
+    from random import randint
+    #TODO
+
+    def miser(jetons_restants):
+        #TODO
+        return 7, 12
+
+    def choisir_nombre():
+        nombre = -1
+        while "#TODO condition" :
+            nombre = "#TODO demander un nombre à l'utilisatrice"
+            if "#TODO condition":
+                print("Erreur : le nombre doit être compris entre 0 et 49")
+        return nombre
+
+    #TODO fonction miser_jetons
+
+    def tourner_la_roulette():
+        numero = 8 #TODO
+        print(f"Le croupier tourne la roulette. Le numéro {numero} est le numéro gagnant !")
+        return numero
+
+    def calculer_gains_couleur(mise):
+        pass #TODO
+
+    def calculer_gains_numero(mise):
+        pass #TODO
+
+    def continuer_de_jouer(jetons_restants):
+        return #TODO Effacer cette ligne quand ce sera demandé
+        if "#TODO condition":
+            print("Vous êtes ruiné.e. C'est la fin de la partie.")
+            #TODO Retourner une valeur
+        else:
+            #TODO Afficher les jetons restants (avec une phrase)
+            rejouer = input("Souhaitez-vous continuer ? (o/n)")
+            if rejouer == "o" or rejouer == "O":
+                pass #TODO Retourner une valeur
+            else:
+                #TODO Annoncer qu'on quitte le jeu avec le nombre de jetons restants
+                pass #TODO Retourner une valeur
+
+    jetons = 100
+    continuer = True
+
+    while continuer:
+        gains = 0
+        numero_misé, mise = miser(jetons)
+
+        numero_gagnant = tourner_la_roulette()
+        #TODO Écrire ici la condition principale, pour déterminer les gains
+
+        jetons += gains
+        continuer = continuer_de_jouer(jetons)
+    ~~~
+
+3. Expliquez les étapes du programme qui se déroulent dans la boucle à la fin du script, et quand est-ce qu'elle s'arrête.
+1. Complétez les fonctions suivantes à l'aide des règles du jeu :
+    1. `calculer_gains_numero`
+    1. `calculer_gains_couleur`. Comme nous voulons arrondir à l'entier supérieur, il faudra importer et utiliser la fonction `ceil` du module `math`. 
+    
+    Pour vérifier vos résultats, vous pouvez soit utiliser l'interpréteur en console, soit appeler les fonctions dans votre script et utiliser `print` pour afficher le résultat
+
+2. Allez à la ligne `#TODO Écrire ici la condition principale, pour déterminer les gains`. Cette condition est celle qui permet de savoir si un joueur a gagné ou non.
+    1. Écrivez la condition en utilisant les fonctions `calculer_gains_couleur` et `calculer_gains_numero`. N'oubliez pas le cas où le joueur perd.
+    2. Ajoutez des `print` dans chaque branche pour annoncer les gains ou pertes.
+    3. Testez les différents cas possibles en modifiant les valeurs retournées par la fonction `tourner_la_roulette`
+1. Maintenant que nous sommes sûrs que nos trois cas fonctionnent, nous allons pouvoir réellement tirer un nombre au hasard. Pour cela, nous avons déjà importé la fonction `randint` du module `random` dont voici la [documentation](https://docs.python.org/3.13/library/random.html#random.randint) :
+    > random.**randint**(a, b)
+    >
+    > Return a random integer N such that a <= N <= b. Alias for randrange(a, b+1).
+    
+    1. Expliquez brièvement ce que fait `randint`
+    2. Modifiez la fonction `tourner_la_roulette` de façon à ce qu'elle retourne un nombre entre 0 et 49 tiré aléatoirement.
+
+1. Le coeur du jeu semble maintenant fonctionner. Il ne reste plus qu'à permettre à la joueuse d'interagir avec le programme. Commençons par la mise.
+    1. Complétez la fonction `choisir_nombre` de façon à ce que l'on demande à la joueuse un nombre tant que celui-ci n'est pas valide. Pour simplifier, considérons que personne ne s'amusera à entrer autre chose que des nombres (nous verrons plus tard dans l'année un moyen bien plus efficace de gérer les erreurs).
+    2. Complétez la fonction `miser` pour qu'elle utilise notre fonction nouvellement complétée. Vérifiez que tout fonctionne comme prévu.
+    3. Sur le même modèle que `choisir_nombre`, écrivez une fonction `miser_jetons` qui permettra à la joueuse de choisir un nombre de jetons à miser. Attention : il faudra vérifier qu'elle ne mise pas plus de jetons que ce qu'elle a. Vous aurez donc besoin d'un paramètre pour passer le nombre de jetons restants à votre fonction.
+    4. Complétez la fonction `miser` pour qu'elle utilise notre nouvelle fonction. Vérifiez que tout fonctionne comme prévu.
+
+1. Maintenant, il ne reste plus qu'à demander au joueur s'il souhaite continuer de jouer, et mettre fin à la partie s'il n'a plus de jetons. Dans la fonction `continuer_de_jouer`, retirez la première ligne, celle qui contient un `return`. Complétez le reste de la fonction en remplaçant les lignes contenant la mention `#TODO`. Testez votre programme de bout en bout.
+
+1. Mettez le programme final dans votre compte rendu. 

src/cours/SUMMARY.md

@@ -1,13 +1,14 @@
 # Summary
-- [CIEL 1e année](./CIEL1/ciel1.md)
-    - [Représentation des nombres](./CIEL1/02-reseau/cours/numeration.md)
+- [BTS CIEL - 1ère année](./CIEL1/ciel1.md)
+    - [Numération](./CIEL1/02-reseau/cours/representation_nombres.md)
+        - [Opérations logiques](./CIEL1/02-reseau/cours/operations.md)
         - [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)
         - [TP2 - Fonctions](./CIEL1/01-bases-python/tp/02_fonctions.md)
-        - [TD1 - Bases de Python](./CIEL1/01-bases-python/td/td01-python.md)
-        - [TD2 - Python](./CIEL1/01-bases-python/td/td02.md)
+        - [TD1 - Bases](./CIEL1/01-bases-python/td/td01-python.md)
+        - [TD2 - Fonctions ](./CIEL1/01-bases-python/td/td02-fonctions.md)
     - [L'adressage IP](./CIEL1/02-reseau/cours/adressage-ip.md)
     - [L'environnement de développement](./CIEL1/03-dev-env/dev-env.md)
         - [Les conteneurs](./CIEL1/03-dev-env/conteneurs.md)
@@ -17,8 +18,11 @@
     - [JavaScript](./CIEL1/05-web-js/web-js.md)
     - [Bases de données](./CIEL1/06-bases-de-donnees/bases-de-donnees.md)
     - [Une application web complète avec Python](./CIEL1/07-appli-web/appli-web.md)
-- [CIEL 2e année](./CIEL2/ciel2.md)
+- [BTS 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)
+        - [TP1b - Mise en pratique](./CIEL2/01-revisions-python/tp/tp1bis_mise_en_pratique.md)
     - [Python objet](./CIEL2/02-python-objet/python-objet.md)
-    - [Bases de données](./CIEL2/03-base-de-donnees/bases-de-donnees.md)
+    - [Bases de données](./CIEL2/03-base-de-donnees/bases-de-donnees.md)
+- [Annexes](./annexes/annexes.md)
+  - [Compte rendus de TP](./annexes/compte-rendu/compte-rendu.md)

src/cours/annexes/annexes.md

@@ -0,0 +1 @@
+# Annexes

src/cours/annexes/compte-rendu/annexes.md

@@ -0,0 +1 @@
+# Annexes

src/cours/annexes/compte-rendu/compte-rendu.md

@@ -0,0 +1,148 @@
+# Le compte rendu de TP
+
+A chaque TP, vous devrez rendre un compte-rendu. Ce compte-rendu permettra d'évaluer ce que vous avez compris et retenu du TP, quelles questions vous ont posé le plus de difficultés.
+
+Il vous servira également lorsque vous reverrez vos cours à revoir vos réponses et résultats, à vous souvenir de ce que vous avez fait.
+
+Enfin, la plupart seront notés et compteront pour votre moyenne.
+
+## Le fond
+
+- Chaque question fera l'objet d'une ligne (au moins) dans le rapport.
+- N'oubliez pas de numéroter les questions, et n'en oubliez-pas. 
+- De nombreuses questions vous demanderont une réflexion ou interprétation personnelle. 
+    - Ne les laissez pas de côté : ce sont celles qui vous rapportent le plus de points.
+    - Rédigez une réponse avec des phrases complètes.
+
+- Vous écrirez à la fin du rapport un petit paragraphe de synthèse pour résumer ce que vous avez fait et appris dans le TP, et si vous le souhaitez vous pourrez rajouter une réflexion personnelle montrant que vous prenez du recul sur ce que vous avez fait. Tout cela est évidemment valorisé en plus de vous habituer à réfléchir à votre travail.
+
+## La forme
+
+### Généralités
+- Le compte rendu sera au format Markdown, que vous exporterez en PDF. Plus bas vous trouverez un point sur le Markdown.
+- Vous devrez le faire pendant la séance de TP, noter vos résultats et observations au fur et à mesure. 
+- Je le récupère à la fin de la séance, dans un répertoire partagé que je vous communiquerai à environ 15-20 minutes de la fin. N'hésitez pas à me le rappeler. 
+- Si votre rapport n'est pas rendu, vous aurez zéro.
+- Pour nommer votre rapport, utilisez la nomenclature suivante : `yyyy-mm-dd_TPX_NOMTP_NOM_Prénom.pdf` en remplaçant `TPX_NOMTP` par le nom du sujet de TP et `yyyymmdd` par la date de la séance en mettant l'année en premier. 
+    
+    Par exemple, si votre premier TP de Python s'appelle `TP1_Python_Bases.pdf`, votre rapport s'appellera `2025-09-01_TP1_Python_Bases_DUPONT_Jean.pdf`
+
+### Markdown
+
+Le markdown est un format de fichier simple, au format texte. Les fichiers markdown ont un nom finissant par l'extension `.md`. Il respecte une syntaxe simple et lisible. 
+Le but est de ne pas avoir à s'encombrer de la mise en forme tout en gardant un rapport lisible et propre.
+
+Pour écrire votre rapport en markdown, utilisez un simple éditeur de texte (et non pas un logiciel de traitement de texte), idéalement VSCode qui possède des extensions pour vous aider. Ça tombe bien, c'est également l'éditeur que l'on utilisera pour la plupart des TP.
+
+Utilisez l'extension **Markdown Preview Enhanced** (id `shd101wyy.markdown-preview-enhanced`) :
+
+![alt text](extension-md.png)
+
+Elle vous permet d'avoir un aperçu en direct de votre rapport et de l'exporter en PDF.
+
+#### Aperçu en direct
+
+Pour avoir un aperçu cliquer dans le coin en haut à droite sur l'icone représentant deux rectangles avec une loupe
+
+![cliquer ici pour aperçu](apercu-md.png)
+
+Cela ouvrira un deuxième volet avec l'aperçu en temps réel de votre rapport.
+
+#### Exporter le rapport en PDF
+
+Pour exporter le rapport en fin de séance : dans l'aperçu, en bas à droite, cliquer sur le menu à trois barres et allez dans 
+`Export > Chrome(Pupeeter) > PDF`
+
+![alt text](image.png)
+
+![alt text](image-1.png)
+
+Et vous verrez le fichier PDF apparaître à côté de votre rapport markdown, avec le même nom.
+
+#### Les bases de la syntaxe markdown
+
+##### Le texte
+En markdown vous pouvez écrire du texte simplement. 
+- Pour passer à la ligne, sautez une ligne. 
+- Pour écrire en **gras** ou *italique* écrivez `**gras** ou *italique*`
+- Pour un titre vous pouvez utiliser des `#` suivis d'un espace devant votre titre.
+
+    ```
+    # Titre principal (H1)
+    ## Titre secondaire (H2)
+    ### Titre tertiaire (H3)
+    #### Et (H4)
+    ##### Ainsi (H5)
+    ###### De suite (H6)
+    ```
+
+- Pour les listes numérotées (ordonnées), mettez `1.` et markdown se chargera de mettre les bons numéros:
+    ```
+    1. Premier item
+    1. Deuxième item
+    1. Troisième item
+    ```
+
+    1. Premier item
+    1. Deuxième item
+    1. Troisième item
+
+- Pour les listes non ordonnées, de simples tirets font l'affaire :
+    ```
+    - Premier item
+    - Deuxième item
+    - Troisième item
+    ```
+    - Premier item
+    - Deuxième item
+    - Troisième item
+
+
+##### Le code
+
+Pour mettre du code sur une ligne : ``` `code` ``` (guillemets de la touche 7)
+
+Pour mettre un bloc de code, utilisez les guillemets de la touche 7 suivis (optionnellement) du nom du langage (en minuscules)
+````
+```python 
+def fonction(arg1, arg2):
+    return arg1 + arg2
+```
+````
+
+Cela rendra un joli bloc de code comme celui-ci, avec la coloration syntaxique :
+```python 
+def fonction(arg1, arg2):
+    return arg1 + arg2
+```
+
+De ce fait il n'est **pas utile de faire de screenshots**. Vous pouvez (et c'est préférable) copier votre code directement dans le rapport. Il en va de même pour la sortie du terminal : un simple bloc de code (sans langage précisé) suffit.
+
+Si je souhaite un screenshot dans le rapport, je le préciserai.
+
+##### Les images
+Pour inclure des images, coller une image précédemment collée directement dans le fichier markdown peut suffire. Sinon, enregistrez une image dans le même répertoire que votre rapport puis utilisez la syntaxe suivante : `![texte si l'image ne s'affiche pas](mon-image.png)`
+
+##### Les tableaux
+
+Pour les rares cas où vous avez besoin d'un tableau, voici la syntaxe :
+
+```
+|Colonne 1|Colonne 2|Colonne 3|
+|---------|---------|---------|
+|Texte|Exemple|Etc|
+|Encore|une|ligne
+|Pour|le|plaisir|
+```
+
+Cela rendra un tableau :
+|Colonne 1|Colonne 2|Colonne 3|
+|---------|---------|---------|
+|Texte|Exemple|Etc|
+|Encore|une|ligne
+|Pour|le|plaisir|
+
+
+##### Toujours plus de syntaxe
+
+Vous pouvez avoir plus d'informations sur la syntaxe markdwon ici : https://www.markdownguide.org/cheat-sheet/

src/slides/B1/representation_nombres.md

@@ -7,6 +7,14 @@ transition: coverflow
 footer: ''
 math: katex
 ---
+
+<style>
+section {
+  font-size: 32px;
+}
+</style>
+
+
 # Représentation des entiers naturels
 ---
 
@@ -220,7 +228,7 @@ Exercice: Convertir en binaire
 
 Exemple avec le nombre $53_{|10}$ qui s'écrit $110101_{|2}$ en binaire :
 
-![divisions successives](../cours/CIEL1/02-reseau/cours/divisions_successives.jpg)
+![divisions successives width:500px](../cours/CIEL1/02-reseau/cours/divisions_successives.svg)
 
 ---
 <style scoped>
@@ -309,3 +317,165 @@ Exercice : Convertir en binaire
 - 0110 1110
 - 0011 1100 1111
 -->
+
+---
+
+### Conversion décimal vers hexadécimal
+
+Deux méthodes possibles:
+- On convertit en binaire puis en hexadécimal
+- On utilise la méthode des divisions successives, mais en divisant par 16
+
+---
+
+Exemple avec $47_{|10}$.
+
+|32|16|8|4|2|1|
+|--|--|-|-|-|-|
+| 1| 0|1|1|1|1|
+
+$${\overbrace{0010}^{2_{|16}}\overbrace{1111}^{\mathrm{F}_{|16}}}_{|2} = \mathrm{2F}_{|16}$$
+
+---
+
+Exemple avec $47_{|10}$.
+
+![divisions hexa width:500px](../cours/CIEL1/02-reseau/cours/divisions_hexa.svg)
+
+On obtient donc $47_{|10} = \mathrm{2F}_{|16}$
+
+---
+
+# Opérateurs booléens
+
+---
+<style scoped>
+section {
+  font-size: 28px;
+}
+</style>
+- Algèbre de Boole ou calcul booléen : 
+    - opérations logiques sur des bits
+- Utile pour :
+    - En programmation pour valider des conditions
+    - En embarqué ou en réseau pour faire des calculs sur des nombres binaires
+
+---
+
+## Opérateur ET
+
+---
+<style scoped>
+section {
+  font-size: 28px;
+}
+</style>
+
+!!! success À retenir
+L'opérateur ET ne renvoie 1 que si les deux arguments sont à 1. Sinon il renvoie 0.
+
+**Si A ET B valent 1**
+
+|A|B|A ET B|
+|-|-|:-:|
+|0|0|0|
+|1|0|0|
+|0|1|0|
+|1|1|1|
+
+En python :
+- `and` lorsqu'on travaille avec des booléens 
+- `&` lorsqu'on veut travailler en bit à bit
+!!!
+
+---
+
+![ET width:500px](../cours/CIEL1/02-reseau/cours/ET.svg)
+
+---
+
+## Opérateur OU
+
+---
+<style scoped>
+    section {
+        font-size: 28px;
+}
+</style>
+!!! success À retenir
+L'opérateur OU renvoie 1 si au moins l'un des deux arguments est à 1. Sinon il renvoie 0.
+
+**Si A vaut 1 ou si B vaut 1 ou si les deux valent 1**
+
+|A|B|A OU B|
+|-|-|:-:|
+|0|0|0|
+|1|0|1|
+|0|1|1|
+|1|1|1|
+
+En python:
+- `or` lorsqu'on travaille avec des booléens  
+- `|` lorsqu'on veut travailler en bit à bit. 
+!!!
+
+---
+
+![OU width:500px](../cours/CIEL1/02-reseau/cours/OU.svg)
+
+---
+
+## Opérateur NON
+
+---
+
+<style scoped>
+    section {
+        font-size: 28px;
+}
+</style>
+!!! success À retenir
+L'opérateur NON inverse la valeur du bit auquel il est appliqué.
+
+|A|NON A|
+|-|:-:|
+|0|1|
+|1|0|
+
+En python: 
+- `not` lorsqu'on travaille avec des booléens 
+- `~` pour l'inversion bit à bit.
+!!!
+
+---
+
+![NON](../cours/CIEL1/02-reseau/cours/NOT.svg)
+
+---
+
+## Opérateur OU EXCLUSIF
+
+---
+<style scoped>
+    section {
+        font-size: 28px;
+}
+</style>
+!!! success À retenir
+OU EXCLUSIF renvoie 1 si seulement l'un des deux arguments est à 1. Sinon il renvoie 0.
+
+**Si A seulement vaut 1 ou si B seulement vaut 1**
+
+|A|B|A XOR B|
+|-|-|:-:|
+|0|0|0|
+|1|0|1|
+|0|1|1|
+|1|1|0|
+
+En python, il n'existe pas. Il est en pratique rarement utilisé.
+!!!
+
+---
+
+![XOR](../cours/CIEL1/02-reseau/cours/XOR.svg)

src/slides/td01-nombres-python.md

@@ -1,302 +0,0 @@
----
-marp: true
-theme: catppuccin
-paginate: true
-size: 4:3
-transition: coverflow
-footer: ''
-math: katex
----
-<style>
-section {
-  font-size: 28px;
-}
-</style>
-
-# TD - Représentation des nombres et Python
----
-## Représentation des nombres
----
-
-1. Convertissez les nombres suivants en décimal
-    - $\mathrm{5B0F}_{|16}$
-        * $23 311_{|10}$
-    - `0x1001`
-        * $4097_{|10}$
-    - $10011010_{|2}$
-        * $154_{|10}$
-    - `1001b`
-        * $9_{|10}$
-
----
-
-2. Convertissez les nombres suivants en binaire
-    - $251_{|10}$ (utilisez les deux méthodes)
-        * 1111 1011b
-    - $3887_{|10}$ (utilisez les deux méthodes)
-        * 1111 0010 1111b
-    - $\mathrm{532}_{|16}$
-        * 0101 0011 0010b
-    - $\mathrm{5B0F}_{|16}$
-        * 0101 1011 0000 1111b
-
----
-
-3. Convertissez les nombres suivants en hexadécimal
-    - $10011010_{|2}$
-        * 0x9A
-    - $100110101_{|2}$
-        * 0x135
-    - $111 1001 1100 1011 1101 0001_{|2}$
-        * 0x79CBD1
-
----
-
-4. Combien de nombres un octet permet-il de représenter ? Justifier.
-    * 2⁸ = 256 -> 256 nombres
-
----
-5. 
-    1. En admettant qu'un nombre entier naturel soit codé sur 32 bits, quelle est la valeur maximale que peut avoir un entier naturel ? 
-        * 2³² = 4 294 967 296 
-        * Donc valeur max = 4 294 967 295 (Il ne faut pas oublier le zéro)
-    2. À votre avis, dans un système informatique, que se passe-t-il si on augmente de 1 la valeur maximale d'un entier ?
-        * Il repasse à zéro : on appelle ça un débordement (overflow en anglais). C'est une source de bugs courante. C'est pour cela qu'il faut être attentif à la valeur maximale qu'un nombre peut avoir dans vos programmes.
-
----
-
-6. Mon ordinateur m'indique qu'un fichier fait 13 560 788 octets. Combien cela représente-t-il environ (1 chiffre après la virgule)
-    - en kio
-        * 13 560 788 / 2¹⁰ = 13243,0 kio
-    - en Mio
-        * 13 560 788 / 2²⁰ = 12,9 Mio
-    - en ko
-        * 13 560,8 ko
-    - en Mo
-        * 13,6 Mo
-
----
-
-7. Quelle est la capacité d'un disque dur de 1To 
-    - en Go
-        * 1000 Go
-    - en Mo
-        * 1 000 000 Mo
-    - en Gio
-        * 10¹² / 2³⁰ = 932,3 Gio
-    - en Mio
-        * 953 674,3 Mio
-
----
-## Python
----
-
-1. Écrire un programme qui demande à l’utilisateurice d’entrer le nom et l’âge. 
-Il affichera ensuite la phrase :
-    `"Bonjour <nom>, vous aurez 30 ans en <année>"`
-
----
-
-```python
-nom = input("Entrer votre nom : ")
-age = int(input("Entrer votre age : "))
-
-print(f"Bonjour {nom}, vous aurez 30 ans en {30 - age + 2025}")
-```
-
----
-
-2. Écrire un programme qui demande à l’utilisatrice d’entrer la largeur et la longueur d’un rectangle. Le programme calcule et affiche la surface et le périmètre. 
-*Utilisez des variables de type `float`*
-
----
-
-```python
-largeur = float(input("Largeur (m) : "))
-longueur = float(input("Longueur (m) : "))
-
-surface = largeur * longueur
-perimetre = 2*(largeur + longueur)
-
-print(f"Surface : {surface} m²")
-print(f"Périmètre : {perimetre} m")
-```
-
----
-
-3. Écrire un programme qui demande à l'utilisatrice d'entrer un rayon et une hauteur de cône. Le programme calculera le volume du cône. Pour rappel, la formule de calcul du volume d'un cône est : $V = \frac{1}{3}.\pi.r^2.h$
-
----
-
-```python
-from math import pi 
-
-rayon = float(input("Rayon du cône (m) :")) 
-hauteur = float(input("Hauteur du cône (m) :")) 
-  
-volume = (pi * hauteur * rayon ** 2) / 3.0 
-print("Volume du cône =", volume, "m3")
-```
-
----
-
-4. Écrire un programme qui demande à l'utilisateur de saisir 3 notes et d'en faire la moyenne. *Utilisez des variables de type `float`*
-
----
-
-```python
-note_1 = float(input("1ere note : "))
-note_2 = float(input("2e note : "))
-note_3 = float(input("3e note : "))
-
-moyenne = (note_1 + note_2 + note_3)/3
-
-print(f"Moyenne : {moyenne}")
-```
-
----
-
-5. Écrire un programme qui demande à l'utilisatrice de saisir deux nombres. Le programme comparera les deux nombres de façon à afficher une comparaison avec les symboles `<, > ou =`, comme dans l'exemple :
-
-```
-1er nombre : 14
-2nd nombre : 12
-14 > 12
-```
-
----
-
-```python
-nombre_1 = float(input("1er nombre : "))
-nombre_2 = float(input("2nd nombre : "))
-
-if nombre_1 > nombre_2 :
-    print(f"{nombre_1} > {nombre_2}")
-elif nombre_1 < nombre_2 :
-    print(f"{nombre_1} < {nombre_2}")
-else:
-    print(f"{nombre_1} = {nombre_2}")
-```
-
----
-
-6. Écrire un programme indiquant si un nombre saisi par l'utilisateur est pair ou impair
-
----
-
-```python
-nombre = int(input("Nombre : "))
-
-if nombre % 2:
-    print(f"{nombre} est impair")
-else:
-    print(f"{nombre} est pair")
-```
-
----
-
-7. Écrire un programme qui demande à l'utilisatrice d'entrer un nombre. Le programme affichera les 10 nombres suivants **sur une seule ligne**. *Utilisez une boucle `for`*
-
----
-
-```python
-nombre = int(input("Entrez un nombre : "))
-
-for i in range (1, 11):
-    print(nombre + i, end=" ")
-```
-
----
-
-8. Faire le même exercice mais avec une boucle `while` cette fois.
-
----
-
-```python
-nombre = int(input("Entrez un nombre : "))
-
-nombre_affiche = nombre
-while nombre_affiche != nombre + 10:
-    nombre_affiche += 1
-    print(nombre_affiche, end=" ")
-```
-
----
-
-9. Écrire un script python permettant de convertir en base 10 (décimal) un nombre écrit en binaire sous forme d'une chaîne de caractères. Vous demanderez à l'utilisateur ou l'utilisatrice le nombre à convertir, et vous afficherez le résultat.
-
----
-
-```python
-base = 2
-
-nombre_binaire = input("Saisissez le nombre à convertir")
-nombre_decimal = 0
-
-puissance = len(nombre_binaire) - 1
-for a in nombre_binaire:
-    nombre_decimal += int(a) * base ** puissance
-    puissance -= 1
-
-print(f"{nombre_binaire}b = {nombre_decimal}")
-```
-
----
-
-10. Écrire un programme permettant d'afficher les 15 premiers termes de la suite de Fibonacci. Pour rappel, la suite de Fibonacci est une suite de nombres dont chaque nombre est la somme des deux précédents. Elle commence par 0 et 1.
-
----
-
-```python
-n0 = 0
-n1 = 1
-
-print(n0, n1, end=" ")
-
-for i in range(0, 13):
-    n2 = n0 + n1
-    n0 = n1
-    n1 = n2
-    
-    print(n2, end=" ")
-```
-
----
-
-11. Écrire un programme qui permet d'afficher le résultat de l'opération factorielle d'un nombre. Pour rappel, factorielle de $n$ s'écrit $n!$ et vaut le produit de tous les nombres entiers de 1 à n. 
-
-    Par exemple : $5! = 1\times2\times3\times4\times5 = 120$
-
----
-
-```python
-nombre = int(input("Nombre : "))
-
-resultat = 1
-for i in range(1, nombre + 1):
-    resultat = resultat * i
-    
-print(f"{nombre}! = {resultat}")
-```
-
----
-
-12. Écrire un script python permettant de convertir en binaire un nombre entier écrit en base 10. Vous demanderez à l'utilisateur ou l'utilisatrice le nombre à convertir, et vous afficherez le résultat.
-
----
-
-```python
-nombre_decimal = input("Saisissez le nombre à convertir : ")
-nombre_binaire = ""
-
-quotient = int(nombre_decimal)
-resultat = ""
-
-while quotient != 0:
-    reste = quotient % 2
-    quotient = quotient // 2
-    
-    resultat = str(reste) + resultat
-
-print(resultat)
-```

src/slides/td02-python-fonctions.md

@@ -1,168 +0,0 @@
----
-marp: true
-theme: catppuccin
-paginate: true
-size: 4:3
-transition: coverflow
-footer: ''
-math: katex
----
-<style>
-section {
-  font-size: 28px;
-}
-</style>
-
----
-
-# TD2 - Fonctions
-
----
-
-1. Donner une fonction qui renvoie `True` si un nombre est pair et `False` sinon.
-
----
-
-```python
-# Solution naïve :
-def est_pair(nb):
-    if nb % 2 == 0:
-        return True
-    else:
-        return False
-```
-
----
-
-```python
-# Meilleure façon de faire
-def est_pair(nb):
-    return nb % 2 == 0
-```
-
----
-
-1. Donner une fonction qui compte et affiche le nombre de voyelles d'une chaîne de caractères. Les voyelles sont `a e i o u y`. Attention aux majuscules. La méthode `lower` permet de mettre une chaîne de caractères en minuscules (lowercase). On l'appelle comme suit : `chaine.lower()`
-
----
-
-```python
-def nombre_voyelles(chaine):
-    nb_voyelles = 0
-    for lettre in chaine.lower():
-        if lettre in "aeiouy":
-            nb_voyelles += 1
-    print(f"Il y a {nb_voyelles} voyelles dans {chaine}")
-```
-
----
-
-1. Donner une fonction qui renvoie l'aire d'un cercle à partir de son rayon. Pour rappel, l'aire d'un cercle est définie par la formule suivante : $\pi*R^2$ où $R$ est le rayon du cercle
-
----
-
-```python
-import math
-
-def aire(rayon):
-    return math.pi * rayon ** 2
-```
-
----
-
-1. Donner une fonction qui renvoie le maximum parmi les trois nombres passés en paramètre
-
----
-
-```python
-def maximum(a, b, c):
-    if a >= b and a >= c:
-        return a
-    elif b >= a and b >= c:
-        return b
-    else:
-        return c
-```
-
----
-
-1. Donner une fonction qui prendra comme paramètre une chaîne de caractères. Il faudra renvoyer cette chaîne de caractères en remplaçant tous les espaces par des étoiles `*`
-
----
-
-```python
-def remplace(chaine):
-    nouvelle_chaine = ""
-    for caractere in chaine:
-        if caractere == " ":
-            nouvelle_chaine += "*"
-        else:
-            nouvelle_chaine += caractere
-    return nouvelle_chaine
-```
-
----
-
-1. Modifier la fonction précédente de façon à pouvoir passer en paramètre le caractère qu'on veut modifier et celui par lequel on veut le remplacer. Si on ne passe pas les paramètres, la fonction devra continuer de remplacer les espaces par des étoiles.
-
----
-
-```python
-def remplace(chaine, a_remplacer=" ", remplacement="*"):
-    nouvelle_chaine = ""
-    for caractere in chaine:
-        if caractere == a_remplacer:
-            nouvelle_chaine += remplacement
-        else:
-            nouvelle_chaine += caractere
-    return nouvelle_chaine
-```
-
----
-
-1. Un gardien de phare va aux toilettes cinq fois par jour. Or les WC sont au rez-de-chaussée. Écrire une procédure (fonction qui ne renvoie rien) qui reçoit deux paramètres : la hauteur d'une marche et le nombre de marches. Cette fonction devra afficher le nombre de mètres en hauteur parcourus chaque semaine par le gardien. La phrase affichée sera de la forme : `Pour x marches de y centimètres il parcourt z mètres par semaine`
-
-Attention : 
-- Une semaine comporte 7 jours (pas de repos pour les gardiens de phare...)
-- Une fois en bas le gardien doit remonter
-- Les hauteurs de marches sont en centimètres, mais le résultat est à exprimer en mètres
-
----
-
-```python
-def hauteur_totale(hauteur_marche, nb_marches):
-    hauteur = hauteur_marche * nb_marches * 2 * 7 * 5 / 100
-    print(f"Pour {nb_marches} marches de {hauteur_marche} centimètres, il parcourt {hauteur} mètres par semaine")
-```
-
----
-## Exercices avancés
-
----
-
-Donner une fonction permettant de calculer la factorielle d'un nombre (entier supérieur à 1) en utilisant une boucle. Pour rappel, factorielle de $n$ s'écrit $n!$ et vaut le produit de tous les nombres entiers de 1 à n. 
-    Par exemple : $5! = 1\times2\times3\times4\times5 = 120$
-
----
-
-```python
-def factorielle(n):
-    resultat = 1
-    for i in range (1, n+1):
-        resultat = resultat * i
-    return resultat
-
-```
-
----
-
-b. Donner une fonction permettant de calculer la factorielle d'un nombre en utilisant une fonction récursive. Une fonction récursive est une fonction qui s'appelle elle-même.
-
----
-
-```python
-def factorielle(n):
-    if n != 1:
-        return n * factorielle(n-1)
-    return 1
-```