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)`