Fix: opytex.org bucket is empty...

.drone.yml

@@ -6,27 +6,62 @@ type: docker
 clone:
   skip_verify: true
 
-workspace:
-    path: /drone/content/
-
 steps:
-- name: Push Raw
+  - name: Clean before push
     image: alpine
+    volumes:
+      - name: tosend
+        path: /tosend
     commands:
-  - apk add --no-cache openssh-client ca-certificates bash
-  - apk add rsync
-  - echo Début du Push
-  - eval `ssh-agent -s`
-  - echo "$SSH_KEY" | ssh-add -
-  - mkdir -p ~/.ssh
-  - echo -e "Host *\n\tStrictHostKeyChecking no\n\n" > ~/.ssh/config
-  - rsync -rv --delete -e "ssh -p 22" --exclude ".git" --exclude "config*" --exclude "*/Evaluations/DS*" --exclude "tools/" --exclude "*.rst" --exclude "*.tex" ./ sshcontent@91.121.90.228:~/raw.opytex.org/www/ --checksum
-  environment:
-    SSH_KEY:
-      from_secret: sshcontent-key
+      - apk add --no-cache rsync
+      - >
+        rsync -am --include="*/" 
+        --include="*.html"
+        --include="*.css"
+        --include="*.png"
+        --include="*.jpg"
+        --include="*.odt"
+        --include="*.pdf" 
+        --exclude="*" 
+        ./ /tosend
+
+  - name: Push bucket Raw
+    image: plugins/s3-sync:1
+    volumes:
+      - name: tosend
+        path: /drone/src/tosend
+    settings:
+      bucket: raw
+      endpoint: https://storage.opytex.org
+      access_key:
+        from_secret: minio_access_key
+      secret_key:
+        from_secret: minio_secret_key
+      source: /tosend
+      target: /
+      path_style: true
+      delete: true
+
+  # - name: Push Raw
+  #   image: alpine
+  #   commands:
+  #   - apk add --no-cache openssh-client ca-certificates bash
+  #   - apk add rsync
+  #   - echo Début du Push
+  #   - eval `ssh-agent -s`
+  #   - echo "$SSH_KEY" | ssh-add -
+  #   - mkdir -p ~/.ssh
+  #   - echo -e "Host *\n\tStrictHostKeyChecking no\n\n" > ~/.ssh/config
+  #   - rsync -rv --delete -e "ssh -p 22" --exclude ".git" --exclude "config*" --exclude "*/Evaluations/DS*" --exclude "tools/" --exclude "*.rst" --exclude "*.tex" ./ sshcontent@91.121.90.228:~/raw.opytex.org/www/ --checksum
+  #   environment:
+  #     SSH_KEY:
+  #       from_secret: sshcontent-key
 
   - name: Build Opytex 2022-2023
     image: python:3.8-alpine
+    volumes:
+      - name: pelican-output
+        path: /output
     commands:
       - apk add --no-cache git imagemagick-dev imagemagick
       - cd ..
@@ -38,15 +73,40 @@ steps:
       - git submodule update
       - pip install --no-cache-dir -r requirements.txt
       - export MAGICK_HOME=/usr
-  - pelican content/ -o output -s publishconf.py --relative-urls
+      - pelican ./src/ -o /output -s publishconf.py --relative-urls
+      - ls /output
 
-  - apk add --no-cache openssh-client ca-certificates bash rsync
-  - eval `ssh-agent -s`
-  - echo "$SSH_KEY" | ssh-add -
-  - mkdir -p ~/.ssh
-  - echo -e "Host *\n\tStrictHostKeyChecking no\n\n" > ~/.ssh/config
-  - ssh sshcontent@91.121.90.228 'mkdir -p ~/raw.opytex.org/www/enseignements/2022-2023/'
-  - rsync -rv --delete -e "ssh -p 22" ./output/ sshcontent@91.121.90.228:~/opytex.org/www/enseignements/2022-2023/ --checksum
-  environment:
-    SSH_KEY:
-      from_secret: sshcontent-key
+  - name: Push to bucket opytex.org
+    image: plugins/s3-sync:1
+    volumes:
+      - name: pelican-output
+        path: /drone/src/output
+    settings:
+      bucket: opytex.org
+      endpoint: https://storage.opytex.org
+      access_key:
+        from_secret: minio_access_key
+      secret_key:
+        from_secret: minio_secret_key
+      source: /output
+      target: /enseignements/2022-2023
+      path_style: true
+      delete: true
+
+    # - apk add --no-cache openssh-client ca-certificates bash rsync
+    # - eval `ssh-agent -s`
+    # - echo "$SSH_KEY" | ssh-add -
+    # - mkdir -p ~/.ssh
+    # - echo -e "Host *\n\tStrictHostKeyChecking no\n\n" > ~/.ssh/config
+    # - ssh sshcontent@91.121.90.228 'mkdir -p ~/raw.opytex.org/www/enseignements/2022-2023/'
+    # - rsync -rv --delete -e "ssh -p 22" ./output/ sshcontent@91.121.90.228:~/opytex.org/www/enseignements/2022-2023/ --checksum
+    # environment:
+    #   SSH_KEY:
+    #     from_secret: sshcontent-key
+    #
+
+volumes:
+  - name: tosend
+    temp: {}
+  - name: pelican-output
+    temp: {}

1NSI/00_Projets/cahier_bord.md

@@ -0,0 +1,37 @@
+# Cahier de bord pour le projet ...
+
+Élèves du groupe : ...
+
+Ce document est votre cahier de bord qui nous permettra de suivre votre projet et de le documenter. À chaque fin de séance, vous devrez créer une archive contenant le code. Cette archive sera placée sur le réseau dans l'espace commun.
+
+## Le projet
+
+### Description
+
+...
+
+### Technologies
+
+...
+
+
+## Taches
+
+Une tache doit avoir une description succincte et contenir la phrase "Cette tache est terminée quand...". Une tache est bien définie ne doit pas vous prendre plus de 20min à être réalisée.
+
+Quand elle est terminée, elle est placée dans la partie "Terminées" avec la date associée.
+
+### À faire
+
+- Préparer le cahier de bord. Cette tache est terminée quand le document est mis en ligne (sur FramaPad) et que l'URL est partagée entre les membres du groupe et l'enseignant.
+- Définir le projet. Cette tache est terminée quand la section "Le projet" est complété (une description succincte est suffisante)
+- Choisir les technologies adaptées. Cette tache est terminée quand le(s) langage(s) de programmation et les modules sont choisis et renseignés dans la partie appropriée.
+-
+
+### En cours (non terminé)
+
+### Terminées
+
+Pensez à indiquer la date où elle a été réalisée.
+
+## Documentation/liens

1NSI/00_Projets/index.rst

@@ -2,7 +2,7 @@ Projets
 #######
 
 :date: 2022-12-06
-:modified: 2023-01-10
+:modified: 2023-04-06
 :authors: Benjamin Bertrand
 :tags: Divers
 :category: 1NSI
@@ -111,6 +111,75 @@ Une "correction" et quelques éléments sur la géométrie de la fenêtre :
 
  - `Explication sur la géométrie de la fenêtre <./snake_expl.pdf>`_
 
+Introduction à Bottle
+~~~~~~~~~~~~~~~~~~~~~
+
+L'exercice 5 du `plan de travail sur l'interaction client/serveur <../05_Interaction_client-serveur/plan_de_travail.pdf>`_ est à faire par équipe de deux en mode pair programming (changement toutes les 10min). Le rendu est ensuite noté suivant les critères ci-dessous
+
+.. list-table:: Notation
+    :header-rows: 1
+
+    * - Description
+      - Points
+    * - Qualité du code (lisibilité, nom explicite des variables, organisation, documentation...)
+      - 2
+    * - Découpage en fonctions élémentaires
+      - 2
+    * - Validité des chemins et requêtes adaptées
+      - 2
+    * - Bissextile et nombre de jours fonctionnent correctement
+      - 2
+    * - Ajout du CSS
+      - 1
+    * - Validité du code HTML
+      - 1
 
 Trimestre 3: Version la plus aboutie possible du projet
 -------------------------------------------------------
+
+Cahier de bord
+~~~~~~~~~~~~~~
+
+Suivi du projet avec `un cahier de bord <./cahier_bord.md>`_ à compléter au fur et à mesure. Chaque séance sera conclue par un archivage sur le réseau de l'état du projet.
+
+README
+~~~~~~
+
+Pendant les vacances de Pâques, les élèves sont invités à avancer leur projet. Ils devront en particulier rédiger un fichier README qui détaillera les points suivants
+
+- Une courte description du projet avec un détail des librairies utilisées
+- Une explication sur comment lancer le projet
+- Une explication de trois points techniques résolus lors de la construction du projet.
+
+Notation
+~~~~~~~~
+
+.. list-table:: Notation
+    :header-rows: 1
+
+    * - Catégorie
+      - Détails
+    * - Qualité du code (lisibilité, nom explicite des variables, organisation, documentation...)
+      - Lisibilité globale
+    * -
+      - Utilisation de fonctions, noms des variables
+    * -
+      - Organisation
+    * -
+      - Documentation interne des fonctions et commentaires
+    * - Explication (le README)
+      - Description du projet
+    * -
+      - Comment faire marcher le programme
+    * -
+      - Explication des points techniques
+    * - Organisation du travail
+      - Autonomie du groupe
+    * -
+      - Suivi des taches et dépôt du code
+    * -
+      - Situations particulières de travail
+    * - Le projet en lui-même (par des non-experts)
+      - Avancement global
+    * -
+      - Plaisir d'utilisation

1NSI/06_Listes_et_tuples/3E_suites_enplus.tex

@@ -0,0 +1,23 @@
+\documentclass[a4paper,10pt,landscape,twocolumn]{article}
+\usepackage{myXsim}
+
+\author{Benjamin Bertrand}
+\title{}
+\date{Février 2023}
+
+\DeclareExerciseCollection[step=3]{banque}
+\xsimsetup{collect}
+
+\pagestyle{empty}
+
+
+\begin{document}
+\input{exercises.tex}
+
+\printcollection{banque}
+\vfill
+
+\printcollection{banque}
+\vfill
+
+\end{document}

1NSI/06_Listes_et_tuples/exercises.tex

@@ -172,3 +172,46 @@
 
     \end{enumerate}
 \end{exercise}
+
+\begin{exercise}[subtitle={Suite de Fibonacci}, step={3}, origin={Annales}, topics={Tuples et listes}, tags={tuple, liste}]
+    En mathématiques, la suite de Fibonacci est une suite d'entiers dans laquelle chaque terme est la somme des deux termes qui le précèdent.
+
+    Voici les premiers termes de la suite
+
+    \begin{center}
+        1, 2, 3, 5, 8, 13, 21 ...
+    \end{center}
+
+    Écrire une fonction \texttt{Fibonacci} qui prend en argument un nombre $n$ et qui retourne la liste des $n$ premiers nombres de la suite de Fibonacci.
+\end{exercise}
+
+\begin{exercise}[subtitle={Suite de Syracuse}, step={3}, origin={Annales}, topics={Tuples et listes}, tags={tuple, liste}]
+    Une suite de Syracuse est une suite d'entiers naturels définie de la manière suivante : on part d'un nombre entier strictement positif ; s’il est pair, on le divise par 2 ; s’il est impair, on le multiplie par 3 et l'on ajoute 1. En répétant l’opération, on obtient une suite d'entiers strictement positifs dont chacun ne dépend que de son prédécesseur.
+
+    Par exemple, à partir de 14, on construit la suite des nombres :
+    \begin{center}
+        14, 7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1, 4, 2...
+    \end{center}
+    C'est la suite de Syracuse du nombre 14.
+
+    Après que le nombre 1 a été atteint, la suite des valeurs 1, 4, 2, 1, 4, 2… se répète indéfiniment en un cycle de longueur 3, appelé cycle trivial. On s'arrêtera donc au premier 1 rencontré.
+
+    \begin{enumerate}
+        \item Écrire une fonction \texttt{syracuse} qui prend en argument le nombre de départ puis qui renvoie la liste des termes de la suite de Syracuse associée à ce nombre. On s'arrêtera au premier 1 rencontré.
+        \item
+            \begin{enumerate}
+                \item Écrire une fonction \texttt{temps\_de\_vol} qui prend en argument la liste des termes de la liste et qui renvoie le nombre de termes avant d'arriver à 1.
+                \item Lister les temps de vol de tous les nombres de 2 à 50.
+            \end{enumerate}
+        \item
+            \begin{enumerate}
+                \item Écrire une fonction \texttt{altitude\_de\_vol} qui prend en argument la liste des termes de la liste et qui renvoie la plus haute valeur.
+                \item Lister les altitudes de vol de tous les nombres de 2 à 50.
+            \end{enumerate}
+        \item
+            \begin{enumerate}
+                \item Écrire une fonction \texttt{temps\_en\_altitude} qui prend en argument la liste des termes de la liste et qui renvoie le nombre de terme plus haut que le premier terme de la liste.
+                \item Lister les temps en altitude de tous les nombres entre 2 et 50.
+            \end{enumerate}
+    \end{enumerate}
+\end{exercise}

1NSI/07_Representation_de_texte/02_unicode.ipynb

@@ -0,0 +1,135 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "651b99d9",
+   "metadata": {},
+   "source": [
+    "# Unicode et python\n",
+    "\n",
+    "La fonction `chr` permet de passer du point de code au caractère. Le point de code peut être exprimé en décimal ou en exadécimal.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "1b5a86a7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'🙏'"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chr(128591)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "128b0f7b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'😂'"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chr(0x01F602)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "442746cb",
+   "metadata": {},
+   "source": [
+    "La fonciton `print` quand à elle peut directement accépté le point de code. Pour cela, il faut ajouter \\U et les 0 nécéssaires pour avec un mot de 8 caractères"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "59bcd496",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "🔥\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"\\U0001F525\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "60dfa4c9",
+   "metadata": {},
+   "source": [
+    "1. Utilisez la fonction `chr` (en décimal) pour faire un tableau de 10 colonnes sur 5 lignes avec les caractères après 🔥"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a9f74419",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9bb194d8",
+   "metadata": {},
+   "source": [
+    "2.  Utiliser la fonction `chr` (en héxadécimal) pour faire un tableau de 15 colonnes sur 10 lignes avec les caractères après U+A000"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "eb44cde5",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

1NSI/07_Representation_de_texte/03_str.ipynb

@@ -0,0 +1,342 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bf0de95a",
+   "metadata": {},
+   "source": [
+    "# Les strings\n",
+    "\n",
+    "Dans ce TP, vous apprendrez les manipulations de bases des chaine de caractères en python (`str`)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e42ebfb4",
+   "metadata": {},
+   "source": [
+    "## Str\n",
+    "\n",
+    "Les `str` en python ont de nombreuses similarités avec les `list` et les `tuple`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "64156203",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mot = \"Salut tout le monde\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6a818ba8",
+   "metadata": {},
+   "source": [
+    "Reprendre le cours sur les listes et les tuples et trouver les similarités avec les `str`. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "640433ba",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f758b002",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "35bbe2e4",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ca07c701",
+   "metadata": {},
+   "source": [
+    "Les `str` ont des méthodes spécifiques"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "70da034e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Salut_tout_le_monde'"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "mot.replace(\" \", \"_\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "952f4936",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'SALUT TOUT LE MONDE'"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "mot.upper()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "45762d2b",
+   "metadata": {},
+   "source": [
+    "## Exercices techniques"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6c221743",
+   "metadata": {},
+   "source": [
+    "1. Ecrire une fonction `renverse` qui prend en argument une chaine de caractère et qui renverse cette dernière."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "24a281d3",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "TypeError",
+     "evalue": "renverse() takes 0 positional arguments but 1 was given",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
+      "Input \u001b[0;32mIn [11]\u001b[0m, in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m# tests\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[43mrenverse\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mazerty\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mytreza\u001b[39m\u001b[38;5;124m\"\u001b[39m\n",
+      "\u001b[0;31mTypeError\u001b[0m: renverse() takes 0 positional arguments but 1 was given"
+     ]
+    }
+   ],
+   "source": [
+    "# tests\n",
+    "assert renverse(\"azerty\") == \"ytreza\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "7cb00bce",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# votre fonction"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1691a5f7",
+   "metadata": {},
+   "source": [
+    "2. Un palindrome est une chaine de caractère qui est identique peu importe le sens dans lequel on la lit.\n",
+    "\n",
+    "Écrire une fonction `est_palindrome` qui prend en argument une chaine de caractère et qui renvoie vrai ou faux suivant si elle est un palindrome ou non (on ne tiendra pas compte des espaces)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "b16877c0",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'est_palindrom' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Input \u001b[0;32mIn [9]\u001b[0m, in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m# tests\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[43mest_palindrom\u001b[49m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcoucou\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;241m==\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m est_palidrome(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mazertreza\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;241m==\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m      4\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m est_palindrome(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcaser vite ce palindrome ne mord ni lape cet ivre sac\u001b[39m\u001b[38;5;124m'\u001b[39m) \u001b[38;5;241m==\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'est_palindrom' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "# tests\n",
+    "assert est_palindrome(\"coucou\") == False\n",
+    "assert est_palindrome(\"azertreza\") == True\n",
+    "assert est_palindrome('caser vite ce palindrome ne mord ni lape cet ivre sac') == True\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "4f8ca51b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Votre fonction"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a06bc2e4",
+   "metadata": {},
+   "source": [
+    "## Chiffrement\n",
+    "\n",
+    "Le chiffrement de Césars consiste à décaler l'alphabet dans un message pour le rendre non comprehensible. Le décalage est appelé `clé de chiffrement`.\n",
+    "\n",
+    "Ainsi si la clé de chiffrement est 2, on aura\n",
+    "\n",
+    "| message orginnal | message chiffré |\n",
+    "| --- | --- |\n",
+    "| les | ngu |\n",
+    "\n",
+    "On supposera que le message original ne contient que des caractères ASCII (entre 32 et 126). Le message chiffré sera lui aussi composé de caractères ASCII entre 32 et 126.\n",
+    "\n",
+    "1. Écrire une fonction `chiffre_lettre` qui prend en argument la clé de chiffrement et un caractère et qui renvoie le caractère chiffré. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "db6ab5b9",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'chiffre_lettre' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Input \u001b[0;32mIn [13]\u001b[0m, in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m# tests\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[43mchiffre_lettre\u001b[49m(\u001b[38;5;241m2\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124ml\u001b[39m\u001b[38;5;124m'\u001b[39m) \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mn\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m chiffre_lettre(\u001b[38;5;241m4\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m~\u001b[39m\u001b[38;5;124m'\u001b[39m) \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m#\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m      4\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m chiffre_lettre(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m10\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m?\u001b[39m\u001b[38;5;124m'\u001b[39m) \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m5\u001b[39m\u001b[38;5;124m'\u001b[39m\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'chiffre_lettre' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "# tests\n",
+    "assert chiffre_lettre(2, 'l') == 'n'\n",
+    "assert chiffre_lettre(4, '~') == '#'\n",
+    "assert chiffre_lettre(-10, '?') == '5'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "b5b0a910",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Fonction"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "765d8791",
+   "metadata": {},
+   "source": [
+    "2. Écrire une fonction `chiffre_message` qui prend en argument la clé de chiffrement et le message et qui renvoie tout le message chiffré."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "93ab941b",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ca7c256c",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "43e00026",
+   "metadata": {},
+   "source": [
+    "3. Écrire une fonction `dechiffre_message` qui prend en argument la clé de chiffrement et un message chiffré et qui renvoie le message déchiffré."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "395c7b40",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "534209fd",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "271a2087",
+   "metadata": {},
+   "source": [
+    "4. Statistiquement, le caractère le plus présent dans un message et l'espace. Servez vous de cette connaissance pour écrire une fonction qui sera capable de trouver "
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

1NSI/07_Representation_de_texte/1B_table_encodage.tex

@@ -0,0 +1,89 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+\usepackage{minted}
+
+\author{Benjamin Bertrand}
+\title{Representation de texte - Cours}
+\date{Février 2023}
+
+\pagestyle{empty}
+
+\begin{document}
+
+\maketitle
+
+Dans cette séquence, on traitera des différentes façons de faire correspondre un caractère (une lettre, un espace...) avec une représentation binaire.
+
+\section{Table et encodage}
+
+\begin{definition}[Table ASCII]
+
+    En 1960, la norme \textbf{ASCII} (American Standard Code for Information Interchange) a été crée pour uniformiser l'encodage des caractère par \textbf{l'ANSI} (American National Standards Institute).
+
+    Elle définit 128 codes, comprenant 95 caractères imprimables :
+    \begin{itemize}
+        \item les chiffres arabes de 0 à 9
+        \item les 26 lettres de l'alphabet latin en minuscules et en capitales
+        \item des symboles mathématiques et de ponctuation
+    \end{itemize}
+
+    Chaque caractère est codé sur 7 bits même si on le représente le plus souvent sur 8 bits (1 octet)
+\end{definition}
+
+\paragraph{Remarques:}
+\begin{itemize}
+    \item Avantages de la table ASCII: \dotfill
+    \item Limitations: \dotfill
+\end{itemize}
+
+\begin{definition}[ISO-8859-1 ou Latin-1]
+    Pour rendre l'utilisation de la table ASCII plus universelle d'autres tables ont été créées.
+
+    L'ISO (Organisation internationale de normalisation) a proposé la norme ISO-8859 qui utilise le 8e bit pour ajouter 128 caractères supplémentaires pour un total de $2^8 = 256$ caractères.
+
+    Parmi les tables issues de cette norme, la table ISO-8859-1 (ou Latin-1) est celle qui a été le plus utilisée en occident car elle ajoute les caractères accentués et des nouveaux signes de ponctuation.
+\end{definition}
+
+
+\paragraph{Remarques:}
+\begin{itemize}
+    \item Avantages de la table ISO-8859-1: \dotfill
+    \item Limitations: \dotfill
+\end{itemize}
+
+\begin{definition}[Unicode]
+    Pour assurer l'universalité de la représentation de caractères la norme \textbf{Unicode} découpe l'encodage en deux étape:
+    \begin{itemize}
+        \item Le point de code: association entre un caractère et un \textbf{point de code} codés sur 20 ou 21 bits
+        \item L'encodage du point de code (UTF-n où n est le nombre minimal de bit pour représenter un point de code).
+    \end{itemize}
+    Encodages les plus utilisés:
+    \begin{itemize}
+        \item UTF-8: le point de code est encodé sur 1 à 4 octets (ou 8 à 32 bits)
+        \item UTF-16: le point de code est encodé sur 2 à 4 octets (16 à 32bits)
+        \item UTF-32: le point de code est encodé sur 4octets (ou 32 bits)
+    \end{itemize}
+\end{definition}
+
+\paragraph{Encodage et décodage avec l'Unicode} (en vous aidant de \url{https://unicode-table.com/fr})
+\begin{center}
+    \begin{tabular}{p{3cm}|p{3cm}|p{3cm}|p{3cm}}
+        Caractère & Point de code & UTF-8 & UTF-32 \\
+        \hline
+        a       & & & \\
+        \euro   & & & \\
+        $\aleph$ & & & \\
+    \end{tabular}
+\end{center}
+
+
+
+\paragraph{Remarques:}
+\begin{itemize}
+    \item Avantages de l'Unicode: \dotfill
+    \item Limitations: \dotfill
+\end{itemize}
+
+
+
+\end{document}

1NSI/07_Representation_de_texte/1E_ascii.tex

@@ -0,0 +1,19 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+\usepackage{minted}
+
+\author{Benjamin Bertrand}
+\title{Représentation de caractères - Exercices}
+\date{Février 2023}
+
+\DeclareExerciseCollection[step=1]{banque}
+\xsimsetup{collect}
+
+\pagestyle{empty}
+
+\begin{document}
+\input{exercises.tex}
+
+\printcollection{banque}
+
+\end{document}

1NSI/07_Representation_de_texte/exercises.tex

@@ -0,0 +1,132 @@
+\begin{exercise}[subtitle={Table ASCII}, step={1}, origin={}, topics={ Representation de texte }, tags={ ASCII, Chiffrement }]
+    Vous trouverez la table ASCII à la fin de l'exercice.
+
+    \begin{enumerate}
+        \item Combien de caractères sont décrits par cette table?
+        \item Quels sont les caractères d'écriture absents de cette table?
+        \item Combien de bits sont nécessaires pour encoder un caractère avec la table ascii? Combien d'octets?
+        \item Encoder en binaire puis en héxadécimal grâce à la table ASCII le message \Ovalbox{\texttt{NSI <3}}.
+        \item Décoder grace à la table ASCII le message
+            \begin{center}
+                01001101 01100001 01110100 01101000 00100000 00101011 00100000 01010011 01010110 01010100 00100000 00101011 00100000 01010000 01000011 00100000 00111101 00100000 00111100 00110011
+            \end{center}
+        \item Décoder grace à la table ASCII le message
+            \begin{center}
+               4D 61 74 68 3A 29
+            \end{center}
+        \item Le programme de première NSI contient \np{25107} caractères. Quelle sera son poids s'il est numérisé en ASCII? Vous exprimerez le résultat en octet et en bit.
+    \end{enumerate}
+    \begin{center}
+        \includegraphics[scale=0.35]{./fig/ascii_table}
+    \end{center}
+\end{exercise}
+
+\begin{exercise}[subtitle={Table ASCII et Python}, step={1}, origin={}, topics={ Representation de texte }, tags={ ASCII, Chiffrement }]
+    En Python, il existe deux fonctions qui permettent de convertir un caractère en son point de code (lisez place dans la table ASCII pour le moment) en décimal et inversement.
+    \begin{itemize}
+        \item \mintinline{python}{ord}: caractère vers point de code
+        \item \mintinline{python}{chr}: point de code vers le caractère
+    \end{itemize}
+    \begin{enumerate}
+        \item Avec python afficher les 128 craactères de la table ascii (Bonus: faites les apparaitres sur 4 colonnes comme dans la table au dessus).
+        \item Comparer le résultat avec la table obtenu.
+    \end{enumerate}
+\end{exercise}
+
+\begin{exercise}[subtitle={Norme ISO-8859-1}, step={1}, origin={}, topics={ Representation de texte }, tags={ ASCII, Chiffrement }]
+    \begin{enumerate}
+        \item Chercher la table d'encodage ISO-8859-1 (ou latin-1).
+        \item Comparer cette table avec la table ASCII.
+        \item Encoder le mot \texttt{a«€éø}
+    \end{enumerate}
+\end{exercise}
+
+\begin{exercise}[subtitle={Unicode table}, step={2}, origin={}, topics={ Representation de texte }, tags={ ASCII, Chiffrement }]
+    La norme Unicode découpe le processus d'encodage en deux parties: le point de code et l'encodage.
+
+    Vous trouverez les points de code et les encodages correspondant sur le moteur de recherche \url{https://unicode-table.com/fr}.
+
+    \begin{enumerate}
+        \item Compléter le tableau ci-dessous avec les points de code et les encodage (représentée sous la forme qui vous semble la plus familière).
+            \begin{center}
+                \begin{tabular}{|p{3cm}|p{3cm}|p{3cm}|p{3cm}|p{3cm}|}
+                    \hline
+                    Caractère & Point de code & UTF-8 & UTF-16BE  & UTF-32BE \\
+                    \hline
+                    I       & & & &\\
+                    \hline
+                    \euro   & & & &\\
+                    \hline
+                    $\aleph$ & & & &\\
+                    \hline
+                     & U+20B3 & & &\\
+                    \hline
+                     & U+1F606 & & &\\
+                    \hline
+                     & U+FE9A & & &\\
+                    \hline
+                \end{tabular}
+            \end{center}
+        \item Quels sont les caractères qui sont inclus dans la norme Unicode?
+        \item Quels sont les encodages possibles et quelles sont leur caractéristiques?
+        \item Comment est placé la table ASCII dans cette norme?
+    \end{enumerate}
+\end{exercise}
+
+\begin{exercise}[subtitle={Exploration de l'Unicode}, step={2}, origin={}, topics={ Representation de texte }, tags={ ASCII, Chiffrement }]
+    Notebook \texttt{02\_unicode}
+\end{exercise}
+
+\begin{exercise}[subtitle={Les strings en Python et cryptographie}, step={2}, origin={}, topics={ Representation de texte }, tags={ ASCII, Chiffrement }]
+    Notebook \texttt{03\_str}
+\end{exercise}
+
+\begin{exercise}[subtitle={QCM}, step={4}, origin={}, topics={ Representation de texte }, tags={ ASCII, Chiffrement, QCM}]
+    \begin{enumerate}[label={\textbf{Question \arabic*:}}, leftmargin=*, wide=0pt]
+        \item Quel est un avantage du codage UTF8 par rapport au codage ASCII ?
+            \begin{tasks}(2)
+                \task il permet de coder un caractère sur un octet au lieu de deux
+                \task il permet de coder différentes polices de caractères
+                \task il permet de coder les majuscules
+                \task il permet de coder tous les caractères
+            \end{tasks}
+
+        \item On considère les codes ASCII en écriture hexadécimale (en base 16).
+
+            Le code ASCII de la lettre A est 0x41, celui de la lettre B est 0x42, celui de la lettre C est 0x43, etc.
+
+            Quelle est le code ASCII, en hexadécimale, de la lettre X (c'est la 24ième lettre de l'alphabet usuel)
+            \begin{tasks}(4)
+                \task 0x58
+                \task 0x64
+                \task 0x7A
+                \task 0x88
+            \end{tasks}
+
+        \item  Laquelle de ces affirmations concernant le codage UTF-8 des caractères est vraie ?
+            \begin{tasks}(2)
+                \task le codage UTF-8 est sur 7bits
+                \task le codage UTF-8 est sur 8bits
+                \task le codage UTF-8 est sur 1 à 4 octets
+                \task le codage UTF-8 est sur 8 octets
+            \end{tasks}
+        \item  Parmi les caractères ci-dessous, lequel ne fait pas partie du code ASCII ?
+            \begin{tasks}(4)
+                \task a
+                \task A
+                \task @
+                \task é
+            \end{tasks}
+        \item Dans le bloc <head> d'un fichier HTML, afin d'encoder les caractères avec le standard Unicode/UTF-8  on insère la ligne :
+            \begin{center}
+                <meta http-equiv="Content -Type" content="text/html; charset=UTF-8">
+            \end{center}
+            Pourquoi cela ?
+            \begin{tasks}(2)
+                \task UTF-8 est l'encodage Linux
+                \task ASCII est une vieille norme, il est temps d'en changer
+                \task UTF-8 est une norme conçue pour permettre un affichage correct des caractères spéciaux sur tout système
+                \task UTF-8 est un encodage qui protège mieux contre le piratage informatique.
+            \end{tasks}
+    \end{enumerate}
+\end{exercise}

1NSI/07_Representation_de_texte/index.rst

@@ -0,0 +1,33 @@
+Représentation du texte
+#######################
+
+:date: 2023-02-03
+:modified: 2023-02-14
+:authors: Benjamin Bertrand
+:tags: Str, Python
+:category: 1NSI
+:summary: Table de caractère, encodage et manipulation des str en Python.
+
+
+Éléments du programme
+=====================
+
+Plan de travail
+
+.. image:: ./plan_de_travail.pdf
+    :height: 200px
+    :alt: Plan de travail
+
+
+Étape 1: Manipulation ASCII et ISO-8859-1
+-----------------------------------------
+
+Explication cours sur la différence entre table de caractère et encodage. Présentation de la table ASCII puis ISO-8859-1.
+
+Étape 2: Unicode
+----------------
+
+Étape 3: String et python
+-------------------------
+
+`String et python - jupyter notebook <./03_str.ipynb>`_

1NSI/07_Representation_de_texte/plan_de_travail.tex

@@ -0,0 +1,42 @@
+\documentclass[a4paper,12pt]{article}
+\usepackage{myXsim}
+\usepackage{minted}
+
+\author{Benjamin Bertrand}
+\title{Representation de texte - Plan de travail}
+\tribe{1NSI}
+\date{janvier 2023}
+
+\pagestyle{empty}
+
+\DeclareExerciseCollection{banque}
+\xsimsetup{
+}
+
+
+\begin{document}
+\maketitle
+
+\section{Tables d'encodage}
+
+\listsectionexercises
+
+\section{Unicode}
+
+\listsectionexercises
+
+\section{Les strings en Python}
+
+\listsectionexercises
+
+\section{QCM}
+
+\listsectionexercises
+
+
+\bigskip
+
+\input{exercises.tex}
+\printcollection{banque}
+
+\end{document}

1NSI/07_Representation_de_texte/solutions.tex

@@ -0,0 +1,28 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+
+\usetikzlibrary{shapes.geometric}
+
+\author{Benjamin Bertrand}
+\title{Representation de texte - Solutions}
+\tribe{1NSI}
+\date{janvier 2023}
+
+\DeclareExerciseCollection{banque}
+\xsimsetup{
+    exercise/print=false,
+    solution/print=true,
+}
+
+\pagestyle{empty}
+
+
+\begin{document}
+
+\maketitle
+
+\input{exercises.tex}
+%\printcollection{banque}
+%\printsolutions{exercises}
+
+\end{document}

1NSI/08_Interaction_web/1B_javascript.tex

@@ -0,0 +1,75 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+\usepackage{minted}
+
+\author{Benjamin Bertrand}
+\title{Interaction Homme machine sur le WEB- Cours}
+\date{Février 2023}
+
+\pagestyle{empty}
+
+\begin{document}
+
+\maketitle
+
+\section{Language Javascript}
+
+\begin{definition}[Javascript]
+    \hfill
+    \begin{minipage}{0.2\linewidth}
+       \includegraphics[scale=0.3]{./fig/JavaScript_logo}
+    \end{minipage}
+    \hfill
+    \begin{minipage}{0.7\linewidth}
+    \textbf{JavaScript} est un langage de programmation de scripts principalement employé dans les pages web interactives et à ce titre est une partie essentielle des applications web.
+
+    Dans les navigateurs, il a pour principale fonction de réagir aux évènements déclenchés par l'utilisateur et de modifier le code HTML ou CSS de la page consultée à travers la manipulation du DOM (document Object Model). On peut utiliser directement du language Javascript dans la console du navigateur accessible en pressant \texttt{F12}.
+    \end{minipage}
+    \hfill
+\end{definition}
+
+\paragraph{Remarque:} Rendez vous sur le lien suivant pour comprendre le lien entre le code HTML, CSS et javascript et le DOM.
+
+\begin{center}
+    \url{https://gitlab.com/frederic-junier/parc-nsi/-/raw/master/docs/chapitre23/images/schema-dom.png}
+\end{center}
+
+\section{Corpus Python et Javascript}
+
+\subsection*{Variables}
+\begin{multicols}{2}
+    \inputminted[bgcolor=base3]{python}{./script/1B_var.py}
+
+    \inputminted[bgcolor=base3]{js}{./script/1B_var.js}
+\end{multicols}
+
+\subsection*{Types de base}
+\begin{multicols}{2}
+    \inputminted[bgcolor=base3]{python}{./script/1B_type.py}
+
+    \inputminted[bgcolor=base3]{js}{./script/1B_type.js}
+\end{multicols}
+
+\subsection*{Conditions}
+\begin{multicols}{2}
+    \inputminted[bgcolor=base3]{python}{./script/1B_conditions.py}
+
+    \inputminted[bgcolor=base3]{js}{./script/1B_conditions.js}
+\end{multicols}
+
+\subsection*{Boucles}
+\begin{multicols}{2}
+    \inputminted[bgcolor=base3]{python}{./script/1B_boucles.py}
+
+    \inputminted[bgcolor=base3]{js}{./script/1B_boucles.js}
+\end{multicols}
+
+\subsection*{Fonctions}
+\begin{multicols}{2}
+    \inputminted[bgcolor=base3]{python}{./script/1B_fonctions.py}
+
+    \inputminted[bgcolor=base3]{js}{./script/1B_fonctions.js}
+\end{multicols}
+
+
+\end{document}

1NSI/08_Interaction_web/2B_DOM.tex

@@ -0,0 +1,78 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+\usepackage{minted}
+
+\author{Benjamin Bertrand}
+\title{Interaction Homme machine sur le WEB- Cours}
+\date{Mars 2023}
+
+\pagestyle{empty}
+
+\begin{document}
+
+\maketitle
+
+\setcounter{section}{1}
+\section{Le DOM}
+
+\begin{definition}[Le DOM]
+    Le DOM (Document Objet Model) est une façon de représenter et d'interagir avec des documents HTML.
+
+    Le DOM est une représentation du document sous forme d'arbre où chaque nœud représente un partie du document.
+
+    Le navigateur télécharge la page HTML, le transforme en DOM, complète l'arbre avec les valeurs CSS. Puis le javascript manipule l'arbre pour faire les transformations.
+
+\end{definition}
+
+\paragraph{Exemple} ~
+
+\begin{minipage}{0.4\linewidth}
+ \begin{minted}[bgcolor=base3]{html}
+<html>
+	<body>
+        <h1> Titre </h1>
+        <p> Coucou </p>
+        <ul>
+        <li id="premier">un élément</li>
+        <li>un autre</li>
+        <li id="prefere">encore</li>
+        </ul>
+	</body>
+</html>
+\end{minted}
+\end{minipage}
+
+\afaire{transformer ce document html en DOM}
+
+\begin{propriete}[Javascript et manipulation du DOM]
+    Quelques commandes javascript pour manipuler et interagir avec le DOM.
+
+    Le mot \mintinline{js}{element} correspond dans la suite à un noeud du DOM.
+
+    \begin{itemize}
+        \item \mintinline{js}{document.getElementById(id)}: \dotfill
+        \item \mintinline{js}{document.createElement(type)}: \dotfill
+        \item \mintinline{js}{element.style}: \dotfill
+        \item \mintinline{js}{element.innerHTML}: \dotfill
+        \item \mintinline{js}{element.children}: \dotfill
+        \item \mintinline{js}{element.appendChild(...)}: \dotfill
+    \end{itemize}
+\end{propriete}
+
+\paragraph{Exemple}
+\begin{itemize}
+    \item Récupérer le contenu de la balise avec l'id "premier"
+        \vspace{1cm}
+
+    \item Changer la couleur du titre
+
+        \vspace{1cm}
+
+    \item Avoir la liste des balises li
+
+        \vspace{1cm}
+    \item Ajouter un élément dans ul
+        \vspace{1cm}
+\end{itemize}
+
+\end{document}

1NSI/08_Interaction_web/3B_interaction.tex

@@ -0,0 +1,54 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+\usepackage{minted}
+
+\author{Benjamin Bertrand}
+\title{Interaction Homme machine sur le WEB- Cours}
+\date{Mars 2023}
+
+\pagestyle{empty}
+
+\begin{document}
+
+\maketitle
+
+\setcounter{section}{2}
+\section{Interaction et évènements}
+
+\begin{definition}[Gestionnaire d'évènements]
+Javascript permet grâce à l'interface DOM d'attacher une fonction gestionnaire d'événement à un élément d'un document HTML.
+
+Ce gestionnaire est lié à un événement, qui est une action de l'utilisateur (déplacement de la souris, pression sur une touche du clavier) ou une modification d'un autre élément du document.
+
+Lorsque l'événement ciblé atteint l'élément surveillé par le gestionnaire, celui-ci le capture et déclenche une action.
+\end{definition}
+
+\begin{propriete}[Attacher des évènemnets]
+    Pour attacher un gestionnaire d'événement nommé gestionnaire, à un élément, nommé \mintinline{js}{element}, et le lier à un événement, par exemple click, on peut procéder de deux façons :
+    \begin{itemize}
+        \item Directement dans le code HTML
+
+                \begin{minipage}{0.9\linewidth}
+                    \begin{minted}[bgcolor=base3]{html}
+<element id="id_element" onclick="fonction_a_realiser()"> ... </element>
+                    \end{minted}
+                \end{minipage}
+            \item Dans le code javascript avec la méthode \mintinline{js}{addEventListener}
+
+                \begin{minipage}{0.9\linewidth}
+                    \begin{minted}[bgcolor=base3]{js}
+let v = document.getElementById("id_element");
+v.addEventListener("click", fonction_a_realiser);
+                    \end{minted}
+                \end{minipage}
+
+    \end{itemize}
+\end{propriete}
+
+\paragraph{Remarques: } Il existe de nombreuses type d'évènements que vous pouvez retrouver à l'adresse
+\begin{center}
+    \url{https://developer.mozilla.org/fr/docs/Web/Events#listing_des_%C3%A9v%C3%A9nements}
+\end{center}
+
+
+\end{document}

1NSI/08_Interaction_web/QCM.tex

@@ -0,0 +1,19 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+\usepackage{minted}
+
+\author{Benjamin Bertrand}
+\title{Interaction WEB - Exercices}
+\date{Mars 2023}
+
+\DeclareExerciseCollection[step=4]{banque}
+\xsimsetup{collect}
+
+\pagestyle{empty}
+
+\begin{document}
+\input{exercises.tex}
+
+\printcollection{banque}
+
+\end{document}

1NSI/08_Interaction_web/codes/2E_compteur.html

@@ -0,0 +1,40 @@
+<!DOCTYPE html>
+<html lang="fr">
+
+<head>
+  <title>Compteur de clics </title>
+  <meta charset="utf-8">
+  <script>
+
+      let compteur = 0;
+
+      function suivant(){
+          compteur = compteur + 1;
+          let v = document.getElementById("valeur");
+          if (compteur <= 1) {
+            v.innerHTML = compteur + " clic";
+          }
+          else {
+            v.innerHTML = compteur + " clics";
+          }
+      }
+
+      function reinitialiser(){
+          compteur = 0;
+          let v = document.getElementById("valeur");
+          v.innerHTML = compteur + " clic";
+      }
+
+  </script>
+</head>
+
+<body>
+  <h1>Compteur de clics en Javascript </h1>
+    <button onclick="suivant();">Clic !</button>
+    <br>
+    <span id="valeur">0</span>
+    <br>
+    <button onclick="reinitialiser();">Réinitialiser !</button>
+</body>
+
+</html>

1NSI/08_Interaction_web/codes/popup/2E_popup.css

@@ -0,0 +1,34 @@
+section {
+	background-color: #f1f1f1;
+	padding: 20px;
+	margin: 20px 0;
+	border: 1px solid black;
+}
+
+section h2 {
+	margin-top: 0;
+}
+
+section .close {
+    float: right;
+}
+
+section a {
+    text-decoration: none;
+    color: black;
+}
+
+#popup {
+    position: fixed;
+    top: 10%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    padding: 20px;
+    background-color: red;
+    border: 1px solid black;
+    z-index: 9999;
+}
+
+.hidden {
+    display: none;
+}

1NSI/08_Interaction_web/codes/popup/2E_popup.html

@@ -0,0 +1,37 @@
+<!DOCTYPE html>
+<html>
+<head>
+	<title>Exemple de liens avec popup</title>
+	<link rel="stylesheet" type="text/css" href="./2E_popup.css">
+</head>
+<body>
+	<h1>Venez voir mes super articles</h1>
+
+	<section id="section1">
+		<h2>Article 1
+                <a href="#" id="close-section1" class="close">X</a>
+            </h2>
+		<p>Lorem ipsum dolor sit amet, qui minim labore adipisicing minim sint cillum sint consectetur cupidatat.</p>
+	</section>
+
+	<section id="section2">
+		<h2>Article 2
+                <a href="#" id="close-section2" class="close">X</a>
+            </h2>
+		<p>Lorem ipsum dolor sit amet, qui minim labore adipisicing minim sint cillum sint consectetur cupidatat.</p>
+	</section>
+
+	<section id="section3">
+		<h2>Article 3
+                <a href="#" id="close-section3" class="close">X</a>
+        </h2>
+		<p>Lorem ipsum dolor sit amet, qui minim labore adipisicing minim sint cillum sint consectetur cupidatat.</p>
+	</section>
+
+	<div id="popup" class="hidden">
+		<p>Cette section est maintenant fermée.</p>
+		<a href="#" id="close-popup">OK</a>
+	</div>
+    <script src="./2E_popup.js"></script>
+</body>
+</html>

1NSI/08_Interaction_web/codes/popup/2E_popup.js

@@ -0,0 +1,46 @@
+const popup = document.getElementById('popup');
+
+
+function closeSection1 () {
+    let section = document.getElementById('section1');
+    section.style.display = "none";
+    popup.classList.remove('hidden');
+
+}
+document.getElementById("close-section1").addEventListener('click', closeSection1)
+
+function closeSection2 () {
+    let section = document.getElementById('section2');
+    popup.classList.remove('hidden');
+
+    let p = document.createElement('p')
+    p.innerHTML = "Je disparais pas!"
+    section.appendChild(p)
+}
+
+document.getElementById("close-section2").addEventListener('click', closeSection2)
+
+let compteur = 0
+function closeSection3 () {
+    let popup = document.getElementById('popup');
+    let section = document.getElementById('section3');
+    if (compteur > 2) {
+        section.style.display = "none";
+        popup.classList.remove('hidden');
+    } else {
+        compteur = compteur + 1;
+        popup.classList.remove('hidden');
+        let p = document.createElement('p')
+        p.innerHTML = "Restez! Je vous fait une promo de 10%!"
+        section.appendChild(p)
+    }
+
+}
+document.getElementById("close-section3").addEventListener('click', closeSection3)
+
+
+const closePopupLink = document.getElementById('close-popup');
+closePopupLink.addEventListener('click', (event) => {
+    event.preventDefault();
+    popup.classList.add('hidden');
+});

1NSI/08_Interaction_web/codes/projets/age.html

@@ -0,0 +1,49 @@
+<!DOCTYPE html>
+
+<html lang="fr">
+
+<!-- Début en-tête -->
+<head>
+
+  <title>Âge avec JS </title>
+
+  <meta charset="utf-8">
+
+   <script type="text/Javascript" src="code-age.js" defer="defer"></script>
+
+</head>
+<!-- Fin en-tête -->
+
+<!-- Début corps -->
+<body class="bg-light">
+
+
+
+<!-- Début de la balise container bootstrap -->
+<div>
+
+  <h1>Calcul d'âge avec Javascript. </h1>
+
+
+
+      <label>Saisissez votre date de naissance </label>
+       <br>
+      <input type="number" id="naissance" value="1975" required />
+      <br>
+      <button id="bouton" onclick="calcul_age()">Calculer</button>
+      <br>
+      <p> Nous sommes en <span id="courant"></span>,
+        donc vous  avez  <span id="age"></span> ans. </p>
+
+
+
+
+<!-- Fin de la balise container bootstrap -->
+</div>
+
+ <p>
+<a href="index.html">Retour à l'accueil</a>
+</p>
+
+</body>
+</html>

1NSI/08_Interaction_web/codes/projets/code-age.js

@@ -0,0 +1,13 @@
+//gestionnaire d'événement clic pour l'élément bouton
+function calcul_age(){
+    let n = document.getElementById("naissance");
+    let naissance = parseInt(n.value);
+    let date = new Date();
+    let courant = date.getFullYear();
+    let c = document.getElementById("courant");
+    c.innerHTML = courant;
+    //àcompléter
+}
+
+//age par défaut :
+calcul_age();

1NSI/08_Interaction_web/codes/projets/code-temperature.js

@@ -0,0 +1,21 @@
+//gestionnaire d'événement clic pour l'élément bouton
+function conversion_unite(){
+    let u = document.getElementById("unite_source");
+    let m = document.getElementById("mesure_source");
+    let c = document.getElementById("unite_cible");
+    let v = document.getElementById("valeur");
+    if (u.value === 'celsius'){
+        v.innerHTML = 9/5 * parseInt(m.value) + 32;
+        c.innerHTML = 'fahrenheit';
+    }
+    //à compléter avec un bloc else
+}
+
+/*
+Compléter en attachant le  gestionnaire d'événement conversion_unite
+ à l'élément #bouton pour l'événement click
+*/
+
+/* conversion par défaut au chargement de la page
+décommenter la ligne suivante*/
+//conversion_unite();

1NSI/08_Interaction_web/codes/projets/evenements.html

@@ -0,0 +1,44 @@
+<!DOCTYPE html>
+
+<html lang="fr">
+
+<!-- Début en-tête -->
+<head>
+
+  <title>Onmouseover avec JS </title>
+
+  <meta charset="utf-8">
+
+   <script type="text/Javascript" defer="defer">
+   function chatouille(){
+        let titre = document.getElementById("titre");
+        if (titre.style.color === "red"){
+            titre.style.color = "blue";
+        }
+        else {
+            titre.style.color = "red";
+        }
+   }
+
+   //à compléter avec une fonction griffe
+    </script>
+
+
+</head>
+<!-- Fin en-tête -->
+
+<!-- Début corps -->
+<body>
+
+
+
+  <!--  à compléter avec un gestionnaire d'événement click -->
+  <h1 onmouseover="chatouille()"  id="titre" style='color : red'>J'aime les souris </h1>
+
+<p>
+<a href="index.html">Retour à l'accueil</a>
+</p>
+
+
+</body>
+</html>

1NSI/08_Interaction_web/codes/projets/evenements2.html

@@ -0,0 +1,44 @@
+<!DOCTYPE html>
+
+<html lang="fr">
+
+<!-- Début en-tête -->
+<head>
+
+  <title>Evenements avec JS </title>
+
+  <meta charset="utf-8">
+
+   <script type="text/Javascript" defer="defer">
+   function chatouille(){
+        let chat = document.getElementById("chat");
+        chat.src = 'images/chat-touille.png';
+   }
+
+   //àcompléter avec une fonction chatpince
+
+   function chatbonjour(){
+        let chat = document.getElementById("chat");
+        chat.src = 'images/chat-bonjour.png';
+   }
+    </script>
+
+
+</head>
+<!-- Fin en-tête -->
+
+<!-- Début corps -->
+<body>
+
+
+
+  <!-- à compléter avec un  gestionnaire d'événement click -->
+  <img src="images/chat-bonjour.png"   alt="Bonjour" onmouseover="chatouille()"  onmouseout="chatbonjour()" id="chat">
+
+<p>
+<a href="index.html">Retour à l'accueil</a>
+</p>
+
+
+</body>
+</html>

1NSI/08_Interaction_web/codes/projets/index.html

@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+
+<html lang="fr">
+
+<head><!-- Début en-tête -->
+  <title>Accueil </title>
+  <meta charset="utf-8">
+</head><!-- Fin en-tête -->
+
+<body><!-- Début corps -->
+  <h1>Menu  </h1>
+
+   <ul>
+    <li> <a href="age.html"> Calcul d'âge </a> </li>
+    <li> <a href="evenements.html"> Jouer avec les événements I </a> </li>
+     <li> <a href="evenements2.html"> Jouer avec les événements II </a> </li>
+    <li> <a href="temperature.html"> Conversion d'unité de température </a> </li>
+   </ul>
+
+</body><!-- Fin corps -->
+
+</html>

1NSI/08_Interaction_web/codes/projets/script.js

@@ -0,0 +1,24 @@
+let compteur = 0;
+
+function suivant(){
+    compteur = compteur + 1;
+    let v = document.getElementById("valeur");
+    if (compteur <= 1) {
+      v.innerHTML = compteur + " clic";
+    }
+    else {
+      v.innerHTML = compteur + " clics";
+    }
+}
+
+function reinitialiser(){
+    compteur = 0;
+    let v = document.getElementById("valeur");
+    v.innerHTML = compteur + " clic";
+}
+
+
+let bouton_clic = document.getElementById("bouton_clic");
+bouton_clic.addEventListener("click", suivant);
+let bouton_reset = document.getElementById("bouton_reset");
+bouton_reset.addEventListener("click", reinitialiser);

1NSI/08_Interaction_web/codes/projets/temperature.html

@@ -0,0 +1,45 @@
+<!DOCTYPE html>
+
+<html lang="fr">
+
+<!-- Début en-tête -->
+<head>
+
+  <title>Conversion d'unité en JS </title>
+
+  <meta charset="utf-8">
+
+  <script type="text/Javascript" src="code-temperature.js" defer="defer">
+</script>
+
+</head>
+<!-- Fin en-tête -->
+
+<!-- Début corps -->
+<body>
+
+
+
+    <h1> Conversion d'unité d'une mesure de température.  </h1>
+
+
+
+        <label for="unite_source">Choisir l'unité de la mesure source :</label>
+        <select name="unite_source" id="unite_source">
+            <option value="celsius"selected >Celsius</option>
+            <option value="fahrenheit">Fahrenheit</option>
+        </select>
+        <br>
+        <label for="mesure_source">Saisir la mesure de température dans l'unité source : </label>
+        <input type="number" id="mesure_source" value="0">
+        <br>
+        <button id="bouton">Convertir</button>
+        <br>
+        <label>Conversion en <span id="unite_cible"></span> : <span id="valeur"></span>. </label>
+
+<p>
+<a href="index.html">Retour à l'accueil</a>
+</p>
+
+</body>
+</html>

1NSI/08_Interaction_web/exercises.tex

@@ -0,0 +1,224 @@
+\begin{exercise}[subtitle={JS pour modifier page web}, step={1}, origin={<++>}, topics={ Interaction web }, tags={ Javascript, Web }]
+    Le but de cet exercice est d'utiliser le language Javascript pour modifier une page web.
+    \begin{enumerate}
+        \item Créer une fichier \texttt{index.html} avec le code suivant
+            \begin{center}
+                \begin{minipage}{0.8\linewidth}
+                    \inputminted[bgcolor=base3]{html}{./script/1E_index.html}
+                \end{minipage}
+            \end{center}
+
+        \item Dans les outils du développeur (\texttt{F12}) allez dans l'onglet console et taper successivement les commandes suivantes. Expliquer l'action de chaque commande et commencer à ce faire un mémo des commandes javascript.
+            \begin{center}
+                \begin{minipage}{0.8\linewidth}
+                    \inputminted[bgcolor=base3]{js}{./script/1E_index.js}
+                \end{minipage}
+            \end{center}
+
+        \item Passez la console en mode multiligne en pressant \texttt{CTRL+B}, saisir puis exécuter le code suivant.
+            \begin{center}
+                \begin{minipage}{0.8\linewidth}
+                    \inputminted[bgcolor=base3]{js}{./script/1E_interaction.js}
+                \end{minipage}
+            \end{center}
+
+            Interagir avec la page. Quelles sont les interactions possibles ? Comment ont-elles été programmées ?
+
+        \item Recharger la page. Qu'en est-il des interactions ?
+    \end{enumerate}
+\end{exercise}
+
+\begin{exercise}[subtitle={Corpus du Javascript}, step={1}, origin={<++>}, topics={ Interaction web }, tags={ Javascript, Web }]
+    Pour réaliser l'exercice suivant vous devez ouvrir la console de votre navigateur (F12 le plus souvent).
+
+    Cet exercice propose des commandes javascript à vous d'extraire les spécificités du language et de le comparer au language Python.
+
+    \begin{multicols}{2}
+        \begin{enumerate}
+            \item \textbf{Opérations et variables}: exécuter les commandes suivantes les unes après les autres puis compléter les pointillées
+                \begin{center}
+                    \begin{minipage}{\linewidth}
+                        \inputminted[bgcolor=base3]{js}{./script/1E_ope_varia.js}
+                    \end{minipage}
+                \end{center}
+                Pour la suite passer l'éditeur en mode multiligne (\texttt{CTRL-B})
+            \item \textbf{Conditionnement}
+                \begin{center}
+                    \begin{minipage}{\linewidth}
+                        \inputminted[bgcolor=base3]{js}{./script/1E_condi.js}
+                    \end{minipage}
+                \end{center}
+            \item \textbf{Boucles}
+                \begin{center}
+                    \begin{minipage}{\linewidth}
+                        \inputminted[bgcolor=base3]{js}{./script/1E_boucles.js}
+                    \end{minipage}
+                \end{center}
+            \item \textbf{Fonctions}
+                \begin{center}
+                    \begin{minipage}{\linewidth}
+                        \inputminted[bgcolor=base3]{js}{./script/1E_fonction.js}
+                    \end{minipage}
+                \end{center}
+            \item Traduire les programmes précédents en Python.
+        \end{enumerate}
+    \end{multicols}
+\end{exercise}
+
+\begin{exercise}[subtitle={Compteur de clics}, step={2}, origin={frederic-junier}, topics={ Interaction web }, tags={ Javascript, Web }]
+    Dans cet exercice, on étudie un compteur de clics.
+
+    \begin{enumerate}
+        \item Ouvrir le fichier \texttt{2E\_compteur.html} avec un navigateur et lister les interactions possibles ainsi que les éléments auxquels ils sont liés.
+        \item Dans l'outil Inspecteur du navigateur, vérifier que les interactions apparaissent bien à travers les boites \texttt{event}. Quels sont évènements qui déclenchent l'évènement?
+        \item Ouvrir le code source de la page. Identifier la partie code javascript et comment les évènements sont attachés aux éléments HTML.
+        \item Expliquer comment le compteur arrive à être augmenté.
+        \item Expliquer comment le compteur est réinitialisé.
+    \end{enumerate}
+\end{exercise}
+
+\begin{exercise}[subtitle={Le pire du web!}, step={2}, origin={}, topics={ Interaction web }, tags={ Javascript, Web }]
+    Dans cet exercice, on étudie la pire création du web!
+
+    \begin{enumerate}
+        \item Ouvrir le fichier \texttt{2E\_pire\_web.html}. Lister les interactions que vous remarquez et les éléments auxquels elles sont liées.
+        \item Ouvrir le fichier \texttt{2E\_pire\_web.html} avec un éditeur de texte. Comment est importé le code javascript?
+        \item Comment sont associés les évènements aux liens?
+        \item (*) Ajouter un 4e article identique aux premiers. Arriverez-vous à faire disparaitre la croix pour fermer l'article quand on passe la souris dessus puis la faire réapparaitre ?
+    \end{enumerate}
+\end{exercise}
+
+\begin{exercise}[subtitle={Projets multiples}, step={3}, origin={frederic-junier.org/NSI/premiere/chapitre23/javascript-git2/}, topics={ Interaction web }, tags={ Javascript, Web }]
+    Copier et coller le dossier \texttt{codes} dans votre répertoire personnel.
+
+    La page d'accueil (\texttt{index.html}) contient une liste de liens vers des pages dynamiques qui contiennent ou sont liés à des codes Javascript à compléter
+
+    \begin{enumerate}
+        \item Depuis la page d'accueil, suivre le lien vers l'activité Calcul d'âge de la page age.html.
+
+            \begin{enumerate}
+                \item Quel élément HTML a reçu un gestionnaire d'événement ? Quel événement est surveillé ?
+                \item Compléter le code Javascript dans le fichier code-age.js afin que la page puisse calculer l'âge de l'utilisateur à partir de sa date de naissance?
+            \end{enumerate}
+
+        \item Revenir sur la page d'accueil et suivre le lien vers l'activité Jouer avec les événements I. Compléter le code Javascript qui se trouve dans l'en-tête du fichier evenements.html pour :
+
+            \begin{enumerate}
+                \item attacher un gestionnaire d'événement click à l'élément d'identifiant titre
+                \item un clic sur cet élément doit déclencher l'apparition d'une fenêtre pop-up avec le message "Attention, je peux griffer !"
+            \end{enumerate}
+
+        \item Revenir sur la page d'accueil et suivre le lien vers l'activité Jouer avec les événements II. Compléter le code Javascript qui se trouve dans l'en-tête du fichier evenements2html pour :
+
+            \begin{enumerate}
+                \item attacher un gestionnaire d'événement click à l'élément img d'identifiant chat
+                \item un clic sur cet élément doit déclencher le changement de sa propriété src, qui doit prendre pour valeur le chemin "images/chat-bonjour.png", ainsi un clic sur l'image devra provoquer son changement.
+            \end{enumerate}
+
+        \item Revenir sur la page d'accueil et suivre le lien vers l'activité Conversion d'unité de température. La page temperature.html propose de convertir une mesure de température de Celsius en Fahrenheit ou réciproquement. Le code Javascript se trouve dans le fichier code-temperature.js.
+
+            \begin{enumerate}
+                \item Quel élément HTML a reçu un gestionnaire d'événement ? Quel événement est surveillé ?
+                \item Compléter le code Javascript qui se trouve dans le fichier code-temperature.js pour rendre la page temperature.html fonctionnelle.
+            \end{enumerate}
+    \end{enumerate}
+\end{exercise}
+
+\begin{exercise}[subtitle={IMC version WEB}, step={3}, origin={}, topics={ Interaction web }, tags={ Javascript, Web }]
+    Dans cet exercice, vous allez programmer un calculateur d'IMC interactif.
+
+    Pour rappelle, l'indice d'IMC, ce calcule à partir de la masse et de la taille d'une personne par la formule
+    \[
+        IMC = \frac{\mbox{mass}}{\mbox{taille}^2}
+    \]
+
+    \begin{enumerate}
+        \item Créer une page HTML avec un formulaire où l'on a deux inputs masse et taille et un bouton soumettre ainsi qu'un endroit où mettre le résultat de l'IMC.
+        \item Ajouter un évènement sur le bouton soumettre pour qu'il calcule l'indice IMC et l'affiche au bon endroit.
+        \item Modifier l'évènement pour que l'interprétation  soit affichée sous l'indice et que le fond de la page s'accorde avec la couleur de l'image:
+            \begin{center}
+                \includegraphics[scale=0.5]{./fig/IMC}
+            \end{center}
+    \end{enumerate}
+
+\end{exercise}
+
+
+\begin{exercise}[subtitle={QCM}, step={4}, origin={}, topics={ Interaction web }, tags={ Javascript, Web }]
+    \begin{enumerate}
+        \item Parmi les langages suivants, lequel est exécuté sur le serveur lors de la consultation d’une page Web ?
+            \begin{tasks}(4)
+                \task JavaScript
+                \task HTML
+                \task CSS
+                \task PHP
+            \end{tasks}
+
+        \item Dans une page HTML, lequel de ces codes permet la présence d'un bouton qui appelle la fonction javascript \mintinline{javascript}{afficher_reponse()} lorsque l'utilisateur clique dessus ?
+            \begin{tasks}(1)
+                \task \mintinline{html}{<a href="afficher_reponse()">Cliquez ici</a> }
+                \task \mintinline{html}{<button if_clicked="afficher_reponse()">Cliquez ici</button> }
+                \task \mintinline{html}{<button  value="Cliquez ici"><a> afficher_reponse()</a></button> }
+                \task \mintinline{html}{<button onclick="afficher_reponse()">Cliquez ici</button>}
+            \end{tasks}
+        \item On souhaite qu’un menu apparaisse à chaque fois que l’utilisateur passe sa souris sur l’image de bannière du site. L’attribut de la balise img dans lequel on doit mettre un code Javascript à cet effet est :
+            \begin{tasks}(4)
+                \task \mintinline{html}{onclick }
+                \task \mintinline{html}{src  }
+                \task \mintinline{html}{alt }
+                \task \mintinline{html}{onmouseover }
+            \end{tasks}
+        \item Une page HTML contient la ligne suivante dans laquelle un mot a été remplacé par des points de supsension :  \mintinline{html}{<p ...... ="alert('hello')"> Survolez-moi </p> }
+
+            Au survol de la souris, le message hello apparait dans une boite de dialogue.
+
+            Par quel mot faut-il remplacer les points de suspension ?
+            \begin{tasks}(4)
+                \task \mintinline{javascript}{onmouseout }
+                \task \mintinline{javascript}{onmouseover }
+                \task \mintinline{javascript}{onmouseleave }
+                \task \mintinline{javascript}{onclick}
+            \end{tasks}
+
+        \item \mintinline{javascript}{onmouseover} est une méthode qui permet de traiter un événement de quel type ?
+            \begin{tasks}(2)
+                \task l'appui d'une touche du clavier
+                \task un clic sur un bouton de souris
+                \task un mouvement de la souris
+                \task le survol par la souris d'un élément de la page
+            \end{tasks}
+
+        \item Parmi les propriétés suivantes d’une balise <button /> dans une page HTML, laquelle doit être rédigée en langage JavaScript ?
+
+            \begin{tasks}(4)
+                \task la propriété name
+                \task la propriété type
+                \task la propriété onclick
+                \task la propriété id
+            \end{tasks}
+
+        \item Un élève a écrit une fonction javascript qui détermine la moyenne des valeurs entrées par l'utilisateur dans un  formulaire de sa page HTML.
+
+            Il place sa fonction javascript :
+            \begin{tasks}(1)
+                \task entre la balise <js> et la balise </js>
+                \task entre la balise <code> et la balise </code>
+                \task entre la balise <script> et la balise </script>
+                \task entre la balise <javascript> et la balise </javascript>
+            \end{tasks}
+
+        \item Voici un extrait d'un document HTML.
+
+            \begin{minipage}{0.8\linewidth}
+                \inputminted[bgcolor=base3]{html}{./script/QCM_body.html}
+            \end{minipage}
+
+            Quelle doit être la ligne qui remplace les pointillés pour obtenir un bouton dont l'appui déclenche la fonction javascript \mintinline{javascript}{actionBouton()} ?
+            \begin{tasks}(2)
+                \task \mintinline{html}{<button click = "actionBouton();"> }
+                \task \mintinline{html}{<button onclick = "actionBouton();"> }
+                \task \mintinline{html}{<button onclick => "actionBouton();" }
+                \task \mintinline{html}{<button> onclick = "actionBouton();"}
+            \end{tasks}
+    \end{enumerate}
+\end{exercise}

1NSI/08_Interaction_web/index.rst

@@ -0,0 +1,55 @@
+Interaction web
+###############
+
+:date: 2023-02-21
+:modified: 2023-03-04
+:authors: Benjamin Bertrand
+:tags: Javascript, Web
+:category: 1NSI
+:summary: Programmation javascript et évènement sur une page web.
+
+
+Éléments du programme
+=====================
+
+.. list-table:: Interaction Homme machine sur le web
+    :header-rows: 1
+
+    * - Contenus
+      - Capacités attendues
+      - Commentaires
+
+    * - Modalités de l’interaction entre l’homme et la machine
+      - Identifier les différents composants graphiques permettant d’interagir avec une application Web.
+      - Il s’agit d’examiner le code HTML d’une page comprenant des composants graphiques et de distinguer ce qui relève de la description des composants graphiques en HTML de leur comportement (réaction aux événements) programmé par exemple en JavaScript.
+
+    * - Événements
+      - Identifier les événements que les fonctions associées aux différents composants graphiques sont capables de traiter.
+      -
+
+    * - Interaction avec l’utilisateur dans une page Web
+      - Analyser et modifier les méthodes exécutées lors d’un clic sur un bouton d’une page Web.
+      -
+
+
+Progression
+===========
+
+Étape 1: Découverte du language Javascript dans la console
+----------------------------------------------------------
+
+Toutes les activités de cette étape se dérouleront dans la console du navigateur. On commencera par un effet Wahou du javascript. Puis une étude un peu plus théorique du corpus de Javascript.
+
+Bilan: Description du language JS, comparaison du corpus de Python et de Javascript.
+
+Étape 2: Trouver les interactions possibles
+-------------------------------------------
+
+Des pages HTML avec du code javascript intégré ou importé. Les élèves doivent comprendre les interactions et décortiquer le code Javascript.
+
+Bilan: importer du code JS dans une page HTML et les fonctions de bases de manipulation du DOM.
+
+Étape 3: Page HTML avec CSS et Javascript
+-----------------------------------------
+
+Des pages HTML à reproduire et des interactions à ajouter.

1NSI/08_Interaction_web/plan_de_travail.tex

@@ -0,0 +1,41 @@
+\documentclass[a4paper,12pt]{article}
+\usepackage{myXsim}
+\usepackage{minted}
+
+\author{Benjamin Bertrand}
+\title{Interaction web - Plan de travail}
+\tribe{1NSI}
+\date{février 2023}
+
+\pagestyle{empty}
+
+\DeclareExerciseCollection{banque}
+\xsimsetup{
+}
+
+
+\begin{document}
+\maketitle
+
+% Résumé
+
+\bigskip
+
+
+\section{Découverte du javascript}
+
+\listsectionexercises
+
+\section{Interactions}
+
+\listsectionexercises
+
+\section{Page web complètes}
+
+\listsectionexercises
+
+\input{exercises.tex}
+\printcollection{banque}
+
+
+\end{document}

1NSI/08_Interaction_web/script/1B_boucles.js

@@ -0,0 +1,3 @@
+for (var i = 0; i < 3; i++){
+    console.log(i)
+}

1NSI/08_Interaction_web/script/1B_boucles.py

@@ -0,0 +1,2 @@
+for i in range(3):
+    print(i)

1NSI/08_Interaction_web/script/1B_conditions.js

@@ -0,0 +1,7 @@
+let age = 12;
+let permi = True;
+if (age > 18) && (permi === True) {
+    console.log("Tu peux conduire")
+} else {
+    console.log("Tu ne peux pas conduire")
+}

1NSI/08_Interaction_web/script/1B_conditions.py

@@ -0,0 +1,6 @@
+age = 12
+permi = True
+if age > 18 and permi == True:
+    print("Tu peux conduire")
+else:
+    print("Tu ne peux pas conduire")

1NSI/08_Interaction_web/script/1B_fonctions.js

@@ -0,0 +1,3 @@
+function carre(n) {
+    return n**2
+}

1NSI/08_Interaction_web/script/1B_fonctions.py

@@ -0,0 +1,2 @@
+def carre(n):
+    return n**2

1NSI/08_Interaction_web/script/1B_type.js

@@ -0,0 +1,5 @@
+let entier = 1;
+let string = "coucou";
+let virgule = 2.2;
+let bouleen = true;
+let liste = [1, 2, 3];

1NSI/08_Interaction_web/script/1B_type.py

@@ -0,0 +1,5 @@
+entier = 1
+string = "coucou"
+virgule = 2.2
+bouleen = True
+liste = [1, 2, 3]

1NSI/08_Interaction_web/script/1B_var.js

@@ -0,0 +1,3 @@
+let a = 2;
+let mot = "coucou";
+const constante = "coucou"

1NSI/08_Interaction_web/script/1B_var.py

@@ -0,0 +1,2 @@
+a = 2
+b = "coucou"

1NSI/08_Interaction_web/script/1E_boucles.js

@@ -0,0 +1,3 @@
+for (let i = 5; i<10; i++){
+    console.log("allez " + i);
+}

1NSI/08_Interaction_web/script/1E_condi.js

@@ -0,0 +1,8 @@
+let age = prompt("Quel age as tu?")
+if (age === 10) {
+    console.log("Tu as 10ans!")
+} else if (age > 18) {
+    alert("Va voter!")
+} else {
+    console.log("C'est pour bientot")
+}

1NSI/08_Interaction_web/script/1E_fonction.js

@@ -0,0 +1,5 @@
+function vousAlerte(texte) {
+    alert("Je vous alerte!")
+    alert(texte)
+}
+vousAlerte("Regarde derrière toi!")

1NSI/08_Interaction_web/script/1E_index.html

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+    <title> "Langages" </title>
+    <meta charset="utf-8">
+</head>
+<body>
+    <h1>Langages du web</h1>
+    <ul id="langages">
+        <li> HTML </li>
+        <li> CSS </li>
+    </ul>
+</body>
+</html>

1NSI/08_Interaction_web/script/1E_index.js

@@ -0,0 +1,8 @@
+>>> let langages = document.getElementById("langages")
+>>> langages.style.color = "red"
+>>> let item1 = langages.children[0]
+>>> item1
+>>> item1.innerHTML = 'HTML5'
+>>> let item3 = document.createElement("li")
+>>> langages.appendChild(item3)
+>>> item3.innerHTML = "Javascript"

1NSI/08_Interaction_web/script/1E_interaction.js

@@ -0,0 +1,9 @@
+function apparition(){
+  langages.style.backgroundColor = "white";
+}
+function disparition(){
+  langages.style.backgroundColor = "blue";
+}
+langages.onmouseover = disparition ;
+langages.onmouseleave = apparition ;
+langages.onclick = function() { alert("Clic !") ; } ;

1NSI/08_Interaction_web/script/1E_ope_varia.js

@@ -0,0 +1,17 @@
+>>> let a = 1
+...
+>>> (a * 3 + 1) ** 2 / 5 - 1
+...
+>>> let b = "Hello"
+...
+>>> b + " World"
+...
+>>> typeof(a)
+...
+>>> typeof(b)
+...
+>>> a = b + a;
+...
+>>> const c = 1;
+...
+>>> c = c + 1;

1NSI/08_Interaction_web/script/QCM_body.html

@@ -0,0 +1,8 @@
+<html>
+<body>
+    .........
+    Clic !
+    </button>
+    <h1><span id="valeur">2000</span></h1>
+</body>
+</html>

1NSI/09_Recherche_par_dichotomie_et_complexite/1B_complexite.tex

@@ -0,0 +1,89 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+\usepackage{minted}
+
+\author{Benjamin Bertrand}
+\title{Recheche par dicotomie et complexité - Cours}
+\date{Mars 2023}
+
+\pagestyle{empty}
+
+\begin{document}
+
+\maketitle
+
+\section{Complexité}
+
+\begin{definition}[Ordre de complexité]
+    On dit qu'un algorithme est d'une \textbf{compléxité de l'ordre de $f(n)$} si il existe une constante positive K telle que, quelle que soit la taille n de l'entrée, le nombre d'opérations élémentaires est plus petit que $K \times f(n)$.
+
+    On dit alors que l'algorithme est en $\mathcal{O}(f(n))$.
+\end{definition}
+
+\section{Etude de la complexité}
+
+\begin{enumerate}
+    \item Recherche du maximum d'une liste
+        \begin{multicols}{2}
+            \inputminted[bgcolor=base3]{python}{./algos/1B_max.py}
+
+            Calcul de la compléxité
+        \end{multicols}
+    \item Moyenne
+        \begin{multicols}{2}
+            \inputminted[bgcolor=base3]{python}{./algos/1B_max.py}
+
+            Calcul de la compléxité
+        \end{multicols}
+    \item Table de multiplication
+        \begin{multicols}{2}
+            \inputminted[bgcolor=base3]{python}{./algos/1B_table.py}
+
+            Calcul de la compléxité
+        \end{multicols}
+    \item Recherche par dichotomie
+        \begin{multicols}{2}
+            \inputminted[bgcolor=base3]{python}{./algos/1B_dicho.py}
+
+            Calcul de la compléxité
+        \end{multicols}
+\end{enumerate}
+
+
+\section{Les complexités courantes}
+
+Dans la pratique, on ne choisira que des fonctions $f(n)$ simples prise dans la liste suivante (classé par ordre croissant de rapidité):
+
+\begin{itemize}
+    \item $\mathcal{O}(1)$: complexité constante. Le temps d'exécution est indépendant de $n$ (la taille de l'entrée).
+
+        \textbf{Exemples}:
+
+    \item $\mathcal{O}(log(n))$: complexité logarithmique. Le temps d'exécution augmente d'une quantité constante quand la taille de l'entrée ($n$) est doublée.
+
+        \textbf{Exemple}:
+
+    \item $\mathcal{O}(nlog(n))$: complexité linéaire. Le temps d'exécution est proportionnel à la taille de l'entrée ($n$)
+
+        \textbf{Exemples}:
+
+    \item $\mathcal{O}(n^2)$: complexité quadratique. Le temps d'exécution est multiplié par 4 quand la taille de l'entrée est multipliée par 2.
+
+        \textbf{Exemples}:
+
+    \item $\mathcal{O}(n^k)$: complexité polynomiale. Le temps d'exécution est majoré par un polynôme de la taille d'entrée.
+
+        \textbf{Exemples}:
+
+    \item $\mathcal{O}(k^n)$: complexité exponentielle. Le temps d'exécution croit trop rapidement pour que la taille d'entrée puisse être grand.
+
+        \textbf{Exemples}:
+\end{itemize}
+
+\paragraph{Temps d'exécution en fonction de la taille d'entrée}~
+
+\begin{center}
+    \includegraphics[scale=0.9]{./fig/complexite}
+\end{center}
+
+\end{document}

1NSI/09_Recherche_par_dichotomie_et_complexite/algos/1B_dicho.py

@@ -0,0 +1,12 @@
+def dichotomie(liste, x):
+    g = 0
+    d = len(L)-1
+    while g <= l:
+        m = (g + d) // 2
+        if L[m] < x:
+            g = m
+        elif L[m] > x:
+            d = m
+        else:
+            return m
+    return None

1NSI/09_Recherche_par_dichotomie_et_complexite/algos/1B_max.py

@@ -0,0 +1,6 @@
+def maximum(liste):
+    candidat = liste[0]
+    for element in liste:
+        if element > candidat:
+            candidat = element
+    return candidat

1NSI/09_Recherche_par_dichotomie_et_complexite/algos/1B_moyenne.py

@@ -0,0 +1,5 @@
+def moyenne(liste):
+    moy = 0
+    for element in liste:
+        moy = moy + element
+    return moy / len(liste)

1NSI/09_Recherche_par_dichotomie_et_complexite/algos/1B_table.py

@@ -0,0 +1,6 @@
+def table(liste):
+    resultats = []
+    for element1 in liste:
+        for element2 in liste:
+            resultats.append(element1 * element2)
+    return resultats

1NSI/09_Recherche_par_dichotomie_et_complexite/cherche_dich/dichotomie.html

@@ -0,0 +1,96 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <title>Recherche par dichotomie</title>
+</head>
+<body>
+  <h1>Jeu de recherche</h1>
+        <section id="setup">
+
+            <p> Je crée une liste de
+            <input type="number" name="quantite" value="100", id="quantite">
+                nombres aléatoires compris entre 1 et
+            <input type="number" name="max" value="100", id="max">
+                triés en ordre croissant.
+        </p>
+        <p>Vous devez trouver la position d'un nombre de cette liste en le moins de coup possibles.</p>
+        <button id="start-game" type="button" onclick="startGame()"> Lancer la partie </button>
+    </section>
+
+    <section id="game">
+    </section>
+
+<script>
+// Génère un nombre aléatoire entre 1 et 100
+let randomNumber = 0;
+let numbers;
+let index;
+let tries;
+
+function generateNormalDistribution(mean, stdDev) {
+  let u = 0, v = 0;
+  while (u === 0) u = Math.random(); // En évitant 0
+  while (v === 0) v = Math.random();
+  const z1 = Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
+  return Math.floor(mean + z1 * stdDev);
+}
+
+function startGame() {
+    const maximum = parseInt(document.getElementById("max").value)
+    const length = parseInt(document.getElementById("quantite").value)
+    tries = 0;
+
+    const mean = Math.floor(Math.random() * maximum);
+    const stdDev = 10;
+    numbers = Array.from({length: length}, () => {
+        let x;
+        do {
+            x = generateNormalDistribution(mean, stdDev);
+        } while (x < 1 || x > maximum);
+        return x;
+    });
+    numbers.sort((a, b) => a - b);
+
+    index = Math.floor(Math.random() * length);
+    const aTrouver = numbers[index]
+
+    document.getElementById("game").innerHTML = `<h2> Trouve la position du nombre ${aTrouver} dans une liste de ${length} nombres entre 1 et ${maximum}</h2>`+
+        "<label for='guess'> Vous pensez qu'il est en quelle position? </label></br>" +
+        "<input type='text' id='guess'></br>" +
+        `<button id="subbutton" type='button' onclick='guessNumber()'>Je tente !</button>` +
+        "<div id='result'></div>"
+    document.getElementById("start-game").innerHTML = "Réinitialiser la partie"
+}
+
+function guessNumber() {
+    tries++
+    document.getElementById("subbutton").innerHTML = `Je tente (déja ${tries} essais)!`
+    // Récupère la valeur saisie par l'utilisateur
+    const guess = parseInt(document.getElementById("guess").value);
+    const length = parseInt(document.getElementById("quantite").value)
+
+    // Vérifie si la valeur est un nombre
+    if (isNaN(guess)) {
+        document.getElementById("result").innerHTML = "<p>Veuillez saisir un nombre valide.</p>";
+        return;
+    }
+
+    // Vérifie si la valeur est comprise entre 1 et 100
+    if (guess < 1 || guess > length) {
+        document.getElementById("result").innerHTML = "<p>Le nombre doit être compris entre 1 et " + length + "</p>";
+        return;
+    }
+
+    // Compare la valeur saisie avec le nombre aléatoire
+    if (guess < index) {
+        document.getElementById("result").innerHTML = "<p>Il est après!</p>";
+    } else if (guess > index) {
+        document.getElementById("result").innerHTML = "<p>Il est avant!</p>";
+    } else {
+        document.getElementById("result").innerHTML = `<p>Bravo, vous avez trouvé le nombre en ${tries}!</p>`;
+    }
+}
+  </script>
+</body>
+</html>

1NSI/09_Recherche_par_dichotomie_et_complexite/index.rst

@@ -0,0 +1,37 @@
+Recherche par dichotomie et complexité
+######################################
+
+:date: 2023-03-13
+:modified: 2023-03-17
+:authors: Benjamin Bertrand
+:tags: Python, Compexité
+:category: 1NSI
+:summary: Mesurer le temps d'execution, calculer une complexité et recherche par dichotomie.
+
+
+Éléments du programme
+=====================
+
+.. list-table:: Interaction Homme machine sur le web
+    :header-rows: 1
+
+    * - Contenus
+      - Capacités attendues
+      - Commentaires
+
+    * - Recherche dichotomique dans un tableau trié
+      - Montrer la terminaison de la recherche dichotomique à l’aide d’un variant de boucle.
+      - Des assertions peuvent être utilisées. La preuve de la correction peut être présentée par le professeur.
+
+Quelques algorithmes classiques sont étudiés. L’étude de leurs coûts respectifs prend tout son sens dans le cas de données nombreuses, qui peuvent être préférentiellement des données ouvertes.
+
+Progression
+===========
+
+`Plan de travail sous forme de notebook <./Temps d'exécution.ipynb>`_: analyse de la performance d'un programme puis découverte de la recherche par dichotomie.
+
+Cours sur la complexité
+
+.. image:: ./1B_complexite.pdf
+    :height: 200px
+    :alt: Bilan sur la complexité

1NSI/09_Recherche_par_dichotomie_et_complexite/plus_moins/plus_moins.html

@@ -0,0 +1,66 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="UTF-8">
+        <title>Jeu du plus ou moins</title>
+    </head>
+    <body>
+        <h1>Jeu du plus ou moins</h1>
+        <section id="setup">
+
+            <p>Devinez un nombre entre 0 et
+                <input type="number" name="max" value="100", id="max">
+            </p>
+            <button id="start-game" type="button" onclick="startGame()"> Lancer la partie </button>
+        </section>
+        <section id="game">
+        </section>
+
+        <script>
+        // Génère un nombre aléatoire entre 1 et 100
+        let randomNumber = 0;
+        let tries = 0;
+
+        function startGame() {
+            const maximum = parseInt(document.getElementById("max").value)
+            randomNumber = Math.floor(Math.random() * maximum) + 1;
+            tries = 0
+            document.getElementById("game").innerHTML = "<h2> J'ai choisi un nombre, il est entre 0 et " + maximum + ". Trouve le!</h2>"+
+                "<input type='text' id='guess'>" +
+                `<button id="subbutton" type='button' onclick='guessNumber()'>Je tente !</button>` +
+                "<p id='result'></p>"
+            document.getElementById("start-game").innerHTML = "Réinitialiser la partie"
+        }
+
+        function guessNumber() {
+            // Récupère la valeur saisie par l'utilisateur
+            const guess = parseInt(document.getElementById("guess").value);
+            const maximum = parseInt(document.getElementById("max").value)
+
+            tries++
+            document.getElementById("subbutton").innerHTML = `Je tente (déja ${tries} essais)!`
+
+            // Vérifie si la valeur est un nombre
+            if (isNaN(guess)) {
+                document.getElementById("result").innerHTML = "Veuillez saisir un nombre valide.";
+                return;
+            }
+
+            // Vérifie si la valeur est comprise entre 1 et 100
+            if (guess < 1 || guess > maximum) {
+                document.getElementById("result").innerHTML = "Le nombre doit être compris entre 1 et " + maximum;
+                return;
+            }
+
+            // Compare la valeur saisie avec le nombre aléatoire
+            if (guess < randomNumber) {
+                document.getElementById("result").innerHTML = "Plus grand.";
+            } else if (guess > randomNumber) {
+                document.getElementById("result").innerHTML = "Plus petit.";
+            } else {
+                document.getElementById("result").innerHTML = "Bravo, vous avez trouvé le nombre en "+ tries + " essais.";
+            }
+        }
+        </script>
+    </body>
+</html>

1NSI/10_Dictionnaire/1B.tex

@@ -0,0 +1,14 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+
+\author{Benjamin Bertrand}
+\title{Dictionnaire - Cours}
+\date{mars 2023}
+
+\pagestyle{empty}
+
+\begin{document}
+
+\maketitle
+
+\end{document}

1NSI/10_Dictionnaire/1E_dictionnaire.ipynb

@@ -0,0 +1,622 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "3a9c129c",
+   "metadata": {},
+   "source": [
+    "# Dictionnaire en Python\n",
+    "\n",
+    "## Construction d'un mémo sur les dictionnaires\n",
+    "\n",
+    "Cette partie à pour but de vous faire découvrir les dictionnaires. Vous devez vous constituer un mémo des commandes pour les manipuler.\n",
+    "\n",
+    "On a déjà vu que l'on pouvait stocker plusieurs informations dans une `list` ou un `tuple`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "d76bb1c8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "info_perso = (\"Bob\", \n",
+    "                \"Lacanaille\",\n",
+    "                2, \n",
+    "                \"0637382716\",\n",
+    "                \"1 rue de la boutifaille\",\n",
+    "                \"01000\",\n",
+    "               )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f801055d",
+   "metadata": {},
+   "source": [
+    "Pour accéder au nom de cette personne, on peut alors faire"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "8521c91b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Lacanaille'"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "info_perso[1]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "80409f49",
+   "metadata": {},
+   "source": [
+    "Ça marche mais ce n'est pas très explicite. Ce n'est pas très clair quelle élément est le nom, le prénom, si le 2 est l'age ou autre chose.\n",
+    "\n",
+    "Il existe une stucture de données appellée `tuple nommé` dans laquelle les clés ne sont pas des nombres (0 à 5 ici) mais des chaines de caractères ou d'autres types. En python, ces tuples nommés sont appellé `dictionnaires`.\n",
+    "\n",
+    "1. Compléter le dictionnaire ci-dessous pour ajouter les informations sur Bob Lacanaille."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "ab63d16c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "info_perso = {\n",
+    "    \"prenom\": \"Bob\", \n",
+    "    \"nom\": \"Lacanaille\",\n",
+    "    \"age\": 2,\n",
+    "    \n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "043de027",
+   "metadata": {},
+   "source": [
+    "`info_perso` est bien un dictionnaire"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "970c028a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "type(info_perso)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "de3f48c3",
+   "metadata": {},
+   "source": [
+    "Pour accéder aux valeurs, il faut maintenant indiqué la clé de l'information recherchée"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "00b292e8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Lacanaille'"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "info_perso[\"nom\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "88acf0ee",
+   "metadata": {},
+   "source": [
+    "2. Quelles sont les clés du dictionnaire `info_perso`?"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "id": "c29b2e1a",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d310f5ba",
+   "metadata": {},
+   "source": [
+    "3. Comment accéder à l'age? Au code postal."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f9799858",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6f975598",
+   "metadata": {},
+   "source": [
+    "Les dictionnaires sont dits `mutables` c'est à dire que l'on peut les modifier.\n",
+    "\n",
+    "On peut modifier les valeurs associées aux clés"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "a40058b0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'prenom': 'Bob', 'nom': 'Lessage', 'age': 10}\n"
+     ]
+    }
+   ],
+   "source": [
+    "info_perso[\"nom\"] = \"Lessage\"\n",
+    "info_perso[\"age\"] = 10\n",
+    "print(info_perso)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "037e117b",
+   "metadata": {},
+   "source": [
+    "Ou ajouter des nouvelles clés"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "694daacb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'prenom': 'Bob', 'nom': 'Lessage', 'age': 10, 'yeux': 'bleu', 'lieu de naissance': 'Ile perdue'}\n"
+     ]
+    }
+   ],
+   "source": [
+    "info_perso[\"yeux\"] = \"bleu\"\n",
+    "info_perso[\"lieu de naissance\"] = \"Ile perdue\"\n",
+    "print(info_perso)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ad8d985c",
+   "metadata": {},
+   "source": [
+    "4. Construire un dictionnaire sur le contenu d'un panier que l'on stockera dans la variable `panier`.\n",
+    "\n",
+    "| Contenu   | Quantité |\n",
+    "|-----------|----------|\n",
+    "| Poires    | 20       |\n",
+    "| Pommes    | 10       |\n",
+    "| Orange    | 12       |\n",
+    "| Mots doux | 2        |\n",
+    "| Gateaux   | 0        |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "efd7013c",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fe33e112",
+   "metadata": {},
+   "source": [
+    "5. Ajouter dans ce panier 5 champignons et 2 épis de maïs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "76f4d571",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4407a25c",
+   "metadata": {},
+   "source": [
+    "`len` permet d'avoir le nombre d'éléments dans un dictionnaire.\n",
+    "\n",
+    "6. Calculer la longueur des dictionnaires `info_perso` et `panier`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5148ffb2",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e7bf0d24",
+   "metadata": {},
+   "source": [
+    "Il y a plusieurs façon de faire des boucles sur les dictionnaires"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "47568544",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "----\n",
+      "prenom\n",
+      "Bob\n",
+      "----\n",
+      "nom\n",
+      "Lessage\n",
+      "----\n",
+      "age\n",
+      "10\n",
+      "----\n",
+      "yeux\n",
+      "bleu\n",
+      "----\n",
+      "lieu de naissance\n",
+      "Ile perdue\n"
+     ]
+    }
+   ],
+   "source": [
+    "for cle in info_perso:\n",
+    "    print(\"----\")\n",
+    "    print(cle)\n",
+    "    print(info_perso[cle])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "5df06b20",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "----\n",
+      "prenom\n",
+      "Bob\n",
+      "----\n",
+      "nom\n",
+      "Lessage\n",
+      "----\n",
+      "age\n",
+      "10\n",
+      "----\n",
+      "yeux\n",
+      "bleu\n",
+      "----\n",
+      "lieu de naissance\n",
+      "Ile perdue\n"
+     ]
+    }
+   ],
+   "source": [
+    "for cle, valeur in info_perso.items():\n",
+    "    print(\"----\")\n",
+    "    print(cle)\n",
+    "    print(valeur)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "7be1fbef",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Bob\n",
+      "Lessage\n",
+      "10\n",
+      "bleu\n",
+      "Ile perdue\n"
+     ]
+    }
+   ],
+   "source": [
+    "for valeur in info_perso.values():\n",
+    "    print(valeur)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2bf475ba",
+   "metadata": {},
+   "source": [
+    "7. Faire une boucle sur `panier` pour afficher un texte du type\n",
+    "\n",
+    "        Dans mon panier, il y 4 carrotes\n",
+    "    \n",
+    "pour tout ce qui se trouve dans le panier."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0895e2e9",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6cb53a9f",
+   "metadata": {},
+   "source": [
+    "Voici les prix à l'unité des aliments qui ont été mis dans le panier.\n",
+    "\n",
+    "| Contenu   | Prix |\n",
+    "|-----------|------|\n",
+    "| Poires    | 2    |\n",
+    "| Pommes    | 1    |\n",
+    "| Orange    | 5    |\n",
+    "| Mots doux | 0   |\n",
+    "| Gateaux   | 10   |\n",
+    "| Champignons | 1 |\n",
+    "| Mais | 15 |\n",
+    "\n",
+    "8. Mettre les prix dans un dictionnaire puis calculer le prix de mon panier."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5d2c3b52",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6f0a1e25",
+   "metadata": {},
+   "source": [
+    "## Temps d'accès à un élément\n",
+    "\n",
+    "Dans cette partie, on compare le temps d'accès à un élément entre une `liste` et un `dictionnaire`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2edee797",
+   "metadata": {},
+   "source": [
+    "1. On construit 5 dictionnaires avec 10, 100, 1000, 10000 et 100000 clés"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "5d889ef3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tailles = [10, 100, 1000, 10000, 100000]\n",
+    "dictionnaires = {}\n",
+    "for taille in tailles:\n",
+    "    dictionnaires[taille] = {i: i for i in range(taille)}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "755895e1",
+   "metadata": {},
+   "source": [
+    "2. On va calculer le temps pour accéder à un élément aléatoirement dans chaque liste."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "98870503",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from time import time\n",
+    "from random import randint"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "8cd70e84",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[9.059906005859375e-07, 7.62939453125e-07, 1.1920928955078125e-06, 1.3828277587890625e-06, 1.52587890625e-06]\n"
+     ]
+    }
+   ],
+   "source": [
+    "moyennes = []\n",
+    "nb_essais = 5\n",
+    "for taille in tailles:\n",
+    "    le_dictionnaire = dictionnaires[taille]\n",
+    "    temps = []\n",
+    "    for i in range(nb_essais):\n",
+    "        pos = randint(0, taille-1)\n",
+    "        start = time()\n",
+    "        le_dictionnaire[pos]\n",
+    "        end = time()\n",
+    "        temps.append(end-start)\n",
+    "    moyennes.append(sum(temps)/nb_essais)\n",
+    "print(moyennes)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "be8d6144",
+   "metadata": {},
+   "source": [
+    "3. Que peut-on dire sur le temps d'accès à un élément d'un dictionnaire?"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "id": "7c3b0bac",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "79d9d967",
+   "metadata": {},
+   "source": [
+    "4. Faire la même chose pour des listes de taille 10 à 10000 éléments"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "685baf07",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ba70d29f",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "748a5a0a",
+   "metadata": {},
+   "source": [
+    "5. Que peut-on dire sur le temps d'accès à un élément d'une liste"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "id": "4356fba7",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5c7b15dc",
+   "metadata": {},
+   "source": [
+    "## Jeu du scabble\n",
+    "\n",
+    "Dans cette partie, vous allez programmer des fonctions necessaires pour calculer les points au jeu du scrabble.\n",
+    "\n",
+    "Pour cela, vous devez compléter le fichier `scrabble.py`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "56b04766",
+   "metadata": {},
+   "source": [
+    "## Casser le chiffrement de César\n",
+    "\n",
+    "Dans un précédent exercice, vous avez programmer des fonctions qui permettait de chiffrer avec la méthode de César (décalage de l'alphabet).\n",
+    "\n",
+    "En partant du principe que dans un texte le caractère le plus courant est l'espace, vous aller pouvoir casser ce chiffrement.\n",
+    "\n",
+    "Pour cela, vous devez compléter le fichier `cesar.py`"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

1NSI/10_Dictionnaire/2E_exif_folium.ipynb

@@ -0,0 +1,534 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "437fa01c",
+   "metadata": {},
+   "source": [
+    "# Métadonnées d'une image\n",
+    "\n",
+    "Dans ce TP, vous allez manipuler les métadonnées d'images pour ensuite les placer sur une carte.\n",
+    "\n",
+    "## Extraction des métadonnées\n",
+    "\n",
+    "Pour manipuler les images, on a besoin d'une librairie de manipulation d'images."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5c9c7e32",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from PIL import Image, ExifTags"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "960941d7",
+   "metadata": {},
+   "source": [
+    "Vous venez d'importer deux modules qui vous permettrons de manipuler des images et les metadonnées (les tags exifs).\n",
+    "\n",
+    "### Image\n",
+    "\n",
+    "Pour importer une image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cc05608c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "image1 = Image.open(\"image1.jpg\")\n",
+    "image1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "28e7d3fe",
+   "metadata": {},
+   "source": [
+    "Pour obtenir les données exifs on pourra utiliser la méthode `._getexif()` sur l'image."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "75ad9d0a",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "image1._getexif()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8bddb206",
+   "metadata": {},
+   "source": [
+    "Quel type de données est utilisé pour stocker les données exifs?"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "id": "7fb64ce8",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4b9c1b9e",
+   "metadata": {},
+   "source": [
+    "Quelles sont les informations que l'on peut trouver dans les métadonnées d'une image?"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "id": "7211efe2",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f6496594",
+   "metadata": {},
+   "source": [
+    "Quels problèmes a-t-on pour comprendre ce dictionnaire?"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "id": "c1ea645c",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "356814cc",
+   "metadata": {},
+   "source": [
+    "### Comprendre les données exifs\n",
+    "\n",
+    "Pour donner un sens aux clés du dictionnaire des données exifs, le module `ExifTags` a un attribut `.TAGS`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "04a8f787",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ExifTags.TAGS"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "545f1db5",
+   "metadata": {},
+   "source": [
+    "Quel est ce type de données?"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "id": "d5ede170",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a7564aaa",
+   "metadata": {},
+   "source": [
+    "À quelle caractéristique correspond la clé `34853`?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "00d8d07d",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9b695442",
+   "metadata": {},
+   "source": [
+    "À quelle caractéristique correspond la clé `272`?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c3d05add",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1eb8842b",
+   "metadata": {},
+   "source": [
+    "À quelle caractéristique correspond la clé `306`?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0ff2023d",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b14e7a73",
+   "metadata": {},
+   "source": [
+    "Faire une boucle sur les données exifs de l'`image1` en affichant la description de la donnée et la donnée. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "99f357bc",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "95afa782",
+   "metadata": {},
+   "source": [
+    "Ecrire une fonction `extrait_exit` qui prend en argument une image et qui renvoie un dictionaire contenant les données exifs (avec le clés qui doivent être la description de la donnée)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ce958419",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "96fb0759",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3b677187",
+   "metadata": {},
+   "source": [
+    "### Données GPS\n",
+    "\n",
+    "On s'interesse plus précisement aux données GPS de l'image.\n",
+    "\n",
+    "Afficher les données `'GPSInfo'` de l'`image1`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5b901411",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "image1._getexif()[34853]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "033a1730",
+   "metadata": {},
+   "source": [
+    "Quel type est utilisé pour stocker les données GPS?"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "id": "086ee50f",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "322a9278",
+   "metadata": {},
+   "source": [
+    "Quel est le type des clés?"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "id": "a140e2fd",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f4f06f4c",
+   "metadata": {},
+   "source": [
+    "Pour donner un sens à ces clés, le module `ExifTags` a un attibut `GPSTAGS` pour leur donner un sens."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e13b29a0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ExifTags.GPSTAGS"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "732ece8c",
+   "metadata": {},
+   "source": [
+    "Ecrire une fonction `extrait_gps` qui prend en argument une image et qui renvoie un dicitonnaire avec les données GPS (avec des clés compréhensibles)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dbd0945a",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7a282a17",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "77ecc152",
+   "metadata": {},
+   "source": [
+    "La longitude et la latitude sont données sous forme de tuple (degré, minute, secondes).\n",
+    "\n",
+    "Pour les transformer en forme décimale, vous pouvez utiliser la fonction suivante"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c0d9ca0f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def gps_to_degre(gps:tuple) -> float:\n",
+    "    \"\"\"Converti des données GPS en notation décimale\n",
+    "    \n",
+    "    :param gps: tuple de données GPS (degré, minute, secondes)\n",
+    "    :return: gps en décimal\n",
+    "    \n",
+    "    :example:\n",
+    "    >>> gps_to_degre((48.0, 50.0, 44.85))\n",
+    "    48.84579166666667\n",
+    "    \n",
+    "    \"\"\"\n",
+    "    return gps[0] + gps[1]/60 + gps[2]/3600"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1d3726cd",
+   "metadata": {},
+   "source": [
+    "Ecrire une fonction `ajoute_degre` qui prend en argument un dictionnaire contenant toutes les données gps et qui renvoie ces données où l'on a ajouté les clés `degreLattitude` et `degreLongitude` (calculés avec la fonction `gps_to_degre`)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d3e048d8",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "02fc0400",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bbe16539",
+   "metadata": {},
+   "source": [
+    "Extraire les données GPS des images \n",
+    "\n",
+    "- `image2.jpg`\n",
+    "- `image3.jpg`\n",
+    "- `image4.jpg`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8e6348e6",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ccb0bb48",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "27e2647c",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "66c525f8",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2b0004af",
+   "metadata": {},
+   "source": [
+    "## Folium\n",
+    "\n",
+    "Folium est une librairie qui permet de manipuler des cartes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b4e23b6c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from folium import Map, Marker"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ad5694a8",
+   "metadata": {},
+   "source": [
+    "Créer une carte"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a5822416",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "carte = Map(location=[45.5236, -122.6750])\n",
+    "marqueur = Marker(location=[45.5236, -122.6750])\n",
+    "marqueur.add_to(carte)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7ce827c7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "carte"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e8ca713b",
+   "metadata": {},
+   "source": [
+    "À quoi correspond la liste de nombres passés en argument de la fonction `Map` ou de `Marker`?"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "id": "281f1e36",
+   "metadata": {},
+   "source": [
+    " "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "21c54fff",
+   "metadata": {},
+   "source": [
+    "À vous de géolocaliser les images suivantes:\n",
+    "\n",
+    "- `image1.jpg`\n",
+    "- `image2.jpg`\n",
+    "- `image3.jpg`\n",
+    "- `image4.jpg`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ae1323d6",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

1NSI/10_Dictionnaire/exercises.tex

@@ -0,0 +1,7 @@
+\begin{exercise}[subtitle={<++>}, step={1}, origin={<++>}, topics={ Dictionnaire }, tags={ Python }]
+    <++>
+\end{exercise}
+
+\begin{solution}
+    <++>
+\end{solution}

1NSI/10_Dictionnaire/index.rst

@@ -0,0 +1,38 @@
+Dictionnaire
+############
+
+:date: 2023-03-17
+:modified: 2023-03-26
+:authors: Benjamin Bertrand
+:tags: Python
+:category: 1NSI
+:summary: Découverte des dictionnaires
+
+
+Éléments du programme
+=====================
+
+.. list-table:: Interaction Homme machine sur le web
+    :header-rows: 1
+
+    * - Contenus
+      - Capacités attendues
+      - Commentaires
+
+    * - Dictionnaires par clés et valeurs
+      - Construire une entrée de dictionnaire.
+        Itérer sur les éléments d’un dictionnaire.
+      - Il est possible de présenter les données EXIF d’une image sous la forme d’un enregistrement. En Python, les p-uplets nommés sont implémentés par des dictionnaires.  Utiliser les méthodes keys(), values () et items ().
+
+Progression
+===========
+
+- Construction d'un mémo sur les dictionnaires (`notebook découverte des dictionnaires <./1E_dictionnaire.ipynb>`_)
+
+- Exercices de construction de fonctions de manipulation de dictionnaires
+
+    - `Compter les points au scrabble <./scripts/scrabble.py>`_
+    - `Casser le chiffrement de Cesar <./scripts/cesar.py>`_
+
+
+- Manipulation des données Exif et géo-localisation sur une carte (`notebook sur les données exifs <./2E_exif_folium.ipynb>`_)

1NSI/10_Dictionnaire/plan_de_travail.tex

@@ -0,0 +1,44 @@
+\documentclass[a4paper,12pt]{article}
+\usepackage{myXsim}
+
+\author{Benjamin Bertrand}
+\title{Dictionnaire - Plan de travail}
+\tribe{1NSI}
+\date{mars 2023}
+
+\pagestyle{empty}
+
+\DeclareExerciseCollection{banque}
+\xsimsetup{
+}
+
+
+\begin{document}
+\maketitle
+
+% Résumé
+
+\bigskip
+
+Savoir-faire de la séquence
+\begin{itemize}
+    \item
+\end{itemize}
+
+\bigskip
+
+Ordre des étapes à respecter
+
+
+\section{}
+
+\listsectionexercises
+
+
+\pagebreak
+
+\input{exercises.tex}
+\printcollection{banque}
+
+
+\end{document}

1NSI/10_Dictionnaire/scripts/cesar.py

@@ -0,0 +1,61 @@
+def chiffre_cesar(message:str, cle:int)->str:
+    """
+    Chiffre un message avec le chiffrement par décalage sur les caractères imprimables ASCII.
+
+    :param message: le message à chiffrer
+    :param cle: décalage à appliquer
+    :return: le message chiffré
+    """
+    message_chiffre = ""
+    for caractere in message:
+        caractere_chiffre = chr((ord(caractere) - 32 + cle) % 95 + 32)
+        message_chiffre += caractere_chiffre
+    return message_chiffre
+
+def dechffre_cesar(message_chiffre:str, cle:int) -> str:
+    """ Déchiffre un message chiffré avec la méthode César"""
+    return chiffre_cesar(message_chiffre, -cle)
+
+# On souhaite casser ce chiffrement c'est à dire trouver la clé de chiffrement
+def signature(message: str) -> dict:
+    """ Compte le nombre d'occurrences de chaque caractère"""
+    # à compléter
+    pass
+
+# Tests à ajouter
+
+
+
+def caractere_plus_courant(message:str) -> str:
+    """ Donne le caractère le plus présent du message
+
+    En cas d'égalité, on renverra un des plus présent
+    """
+    assert len(message) > 0
+    # à compléter
+    pass
+
+# Ajouter deux tests
+assert caractere_plus_courant("uiopyyy") == "y"
+
+def decalage(caractere:str) -> int:
+    """ En supposant que caractere soit le caractère le plus présent du message, c'est certainement le caractère correspondant à l'espace. On peut donc calculer la clé"""
+    # à compléter
+    pass
+
+# Tests (ajouter deux tests)
+assert decalage("#") == 3
+assert decalage("~") == 94
+
+def trouve_cle(message_chiffre:str) -> int:
+    """ À partir d'un message chiffré, retrouve la clé"""
+    # à compléter
+    pass
+
+def casse_cesar(message_chiffre:str) -> str:
+    """ À partir d'un message chiffré, déchiffre le message"""
+    # à compléter
+    pass
+
+message = "Au théâtre, Victor Hugo s'est imposé comme un des chefs de file du romantisme français en présentant sa conception du drame romantique dans les préfaces qui introduisent Cromwell en 1827, puis Hernani en 1830, qui sont de véritables manifestes, puis par ses autres œuvres dramatiques, en particulier Lucrèce Borgia en 1833 et Ruy Blas en 1838."
+# Dans la suite, chiffrer ce message puis essayer de casser le chiffrement avec votre fonction.

1NSI/10_Dictionnaire/scripts/scrabble.py

@@ -0,0 +1,98 @@
+valeur_lettres = {
+    "a": 1,
+    "e": 1,
+    "i": 1,
+    "o": 1,
+    "n": 1,
+    "r": 1,
+    "t": 1,
+    "l": 1,
+    "s": 1,
+    "u": 1,
+    "d": 2,
+    "g": 2,
+    "b": 3,
+    "c": 3,
+    "m": 3,
+    "p": 3,
+    "f": 4,
+    "h": 4,
+    "v": 4,
+    "w": 4,
+    "y": 4,
+    "k": 5,
+    "j": 8,
+    "x": 8,
+    "q": 10,
+    "z": 10,
+}
+
+## Signature d'un mot
+
+def signature(mot:str) -> dict:
+    """Fonction qui compte le nombre de fois que chaque lettre apparait dans le mot
+
+    :param mot: le mot à étudier
+    :return: dictionnaire avec en clé les lettres et en valeur le nombre de fois qu'elles apparaissent
+    """
+    # à compléter
+    pass
+
+# Ajouter deux tests en plus
+assert signature("coucou") == {'c': 2, 'o': 2, 'u': 2}
+assert signature("") == {}
+
+## Score d'un mot
+
+def score(mot: str, valeurs: dict) -> int:
+    """ Calcul le score que fait un mot
+
+    :param mot: le mot à étudier
+    :param valeurs: dictionnaire avec les valeurs de chaque lettre
+    :return: le score du mot
+    """
+    # à compléter
+    pass
+
+# Ajouter deux tests en plus
+assert score("coucou", valeur_lettres) == 10
+assert score("", valeur_lettres) == 0
+
+
+## Meilleur score
+def meilleur_score(mots_possibles:list, valeurs:dict) -> str:
+    """ Renvoie le mot qui fait le plus de points dans la liste des mots possibles"""
+    # à compléter
+    pass
+
+assert meilleur_score(["coucou", "hop"], valeur_lettres) ==  "coucou"
+
+autres_valeurs_lettres =  {
+    "a": 1,
+    "e": 1,
+    "i": 1,
+    "o": 1,
+    "n": 1,
+    "r": 1,
+    "t": 1,
+    "l": 1,
+    "s": 1,
+    "u": 1,
+    "d": 2,
+    "g": 2,
+    "b": 3,
+    "c": 3,
+    "m": 3,
+    "p": 3,
+    "f": 4,
+    "h": 100,
+    "v": 4,
+    "w": 4,
+    "y": 4,
+    "k": 5,
+    "j": 8,
+    "x": 8,
+    "q": 10,
+    "z": 10,
+}
+assert meilleur_score(["coucou", "hop"], autres_valeurs_lettres) ==  "hop"

1NSI/10_Dictionnaire/solutions.tex

@@ -0,0 +1,28 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+
+\usetikzlibrary{shapes.geometric}
+
+\author{Benjamin Bertrand}
+\title{Dictionnaire - Solutions}
+\tribe{1NSI}
+\date{mars 2023}
+
+\DeclareExerciseCollection{banque}
+\xsimsetup{
+    exercise/print=false,
+    solution/print=true,
+}
+
+\pagestyle{empty}
+
+
+\begin{document}
+
+\maketitle
+
+\input{exercises.tex}
+%\printcollection{banque}
+%\printsolutions{exercises}
+
+\end{document}

1NSI/11_Reseau/1B_reseau.tex

@@ -0,0 +1,66 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+
+\author{Benjamin Bertrand}
+\title{Réseau - Cours}
+\date{avril 2023}
+
+\pagestyle{empty}
+
+\begin{document}
+
+\maketitle
+
+\section{Le réseau}
+
+\begin{definition}[ Le réseau ]
+    \begin{itemize}
+        \item Un \textbf{réseau informatique} est un ensemble d'équipements informatiques reliés entre eux par un moyen de communication. On le représente en général sous forme de graphe.
+
+        \item Un \textbf{protocole} est un ensemble de règles permettant d'échanger des informations entre deux équipements informatiques.
+
+        \item Les équipements sont reliés au moyen de communication par une \textbf{interface réseau}.
+    \end{itemize}
+\end{definition}
+
+\paragraph{Exemple:}~\\
+
+\begin{minipage}{0.5\linewidth}
+    \includegraphics[scale=0.5]{./fig/reseau}
+\end{minipage}
+\begin{minipage}{0.5\linewidth}
+    Équipements :
+
+    \vspace{2cm}
+
+    Mode de liaisons :
+
+    \vspace{2cm}
+\end{minipage}
+
+\begin{definition}[ Modèle TCP/IP ]
+    Faire communiquer des équipements en réseau pose des problèmes à plusieurs niveaux:
+    \begin{itemize}
+        \item
+        \item
+        \item
+        \item
+    \end{itemize}
+    Pour résoudre ces problèmes, le modèle OSI a été proposé. Il décompose la situation en plusieurs couches. Chaque couche va résoudre certain problème uniquement. Dans la pratique, l'Internet s'appuie sur un modèle \textbf{TCP/IP} basé sur le modèle OSI.
+
+    \begin{center}
+        \includegraphics[scale=1]{./fig/osi_tcpip}
+    \end{center}
+    Au passage de chaque couche les données seront \textbf{encapsulée} avant d'être passée à la couche suivante.
+\end{definition}
+
+\paragraph{Exemple:}~\\
+\begin{minipage}{0.5\linewidth}
+   \includegraphics[scale=0.7]{./fig/encapsulation}
+\end{minipage}
+\begin{minipage}{0.5\linewidth}
+    Encapsulation de données
+    \vspace{7cm}
+
+\end{minipage}
+\end{document}

1NSI/11_Reseau/2B_acces.tex

@@ -0,0 +1,56 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+
+\author{Benjamin Bertrand}
+\title{Réseau - Cours}
+\date{avril 2023}
+
+\pagestyle{empty}
+
+\begin{document}
+
+\maketitle
+
+\setcounter{section}{1}
+\section{Couche accès réseau}
+
+\begin{definition}[Couche accès réseau]
+    Les protocoles de la couche accès réseau permettent aux équipements d'établir une connexion directe, avec la même technologie et entre deux hôtes d'un même réseau (LAN).
+
+    Les équipements sont identifiés de manière unique par une \textbf{adresse MAC} c'est une adresse physique attachée à un équipement. Elle est constituée de 6octets (ou 48bits) que l'on représente le plus souvent sous forme hexadécimal séparée par ":".
+
+    Exemples de protocoles:
+    \begin{itemize}
+        \item Ethernet: établir un lien entre deux équipements reliés par une liaison filaire. Pour relier plus de deux équipements, on pourra utiliser un \textbf{communtateur} ou \textbf{switch}.
+        \item Wifi: établir un lien entre deux équipements reliés par ondes
+    \end{itemize}
+
+    Le protocole ARP permet d'établir un lien entre une adresse IP (voir couche suivante) et une adresse MAC en diffusant une demande à tout le réseau à travers l'adresse broadcast \texttt{ff:ff:ff:ff:ff}.
+\end{definition}
+
+\section{Couche Internet}
+
+\begin{definition}[Couche Internet]
+    La couche Internet apporte la notion d'IP (Internet Protocole) qui permet essentiellement de faire deux choses:
+    \begin{itemize}
+        \item Donner une adresse logique (une IP) aux équipements. Dans sa version 4, elle est composée de 4octets que l'on note généralement en notation décimal séparée par un point.
+            \begin{center}
+                \includegraphics[scale=0.3]{./fig/IPV4}
+            \end{center}
+        \item Un protocole de \textbf{routage} entre différents réseaux locaux. C'est le rôle du \textbf{routeur} de diriger les paquets à travers les bons réseaux jusqu'au bon destinataire.
+    \end{itemize}
+
+    Chaque interface réseau est associée une configuration réseau composée de
+    \begin{itemize}
+        \item Une adresse IP
+        \item Un masque réseau (pour définir le réseau local)
+        \item Une passerelle réseau (pour aller vers d'autres réseaux)
+    \end{itemize}
+
+    Cette configuration peur être fixe ou attribuée automatiquement à travers le protocole \textbf{DHCP}.
+
+\end{definition}
+
+
+
+\end{document}

1NSI/11_Reseau/4B_transport.tex

@@ -0,0 +1,59 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+
+\author{Benjamin Bertrand}
+\title{Réseau - Cours}
+\date{avril 2023}
+
+\pagestyle{empty}
+
+\begin{document}
+
+\maketitle
+
+\setcounter{section}{3}
+\section{Couche transport}
+
+\begin{definition}[Couche transport]
+  La couche transport gère les communications de bout en bout entre les processus (application).
+
+  Comme il peut y avoir plusieurs processus qui souhaitent échanger sur le protocole TCP/IP en même temps, la couche transport va devoir designer chaque processus par un nombre: \textbf{le port}.
+
+  \vspace{2cm}
+
+  La couche transport va être en charge de réaliser un \textbf{multiplexage} de la communication. Les informations sont divisées en paquets qui sont transmis individuellements et donc qui peuvent arriver dans le désordre. Des méchanismes pour garantir la fiabilité des transmissions sont donc necessaires: ordonner les paquets, réémissions d'un paquet perdu, somme de contrôle...
+
+  A cette couche, on distingue surtout deux protocoles
+  \begin{itemize}
+    \item Le protocole \textbf{UDP}: les informations ne sont pas vérifiées et sont transmis sans validation de la communication. Il est utilisé en particulier pour la communication DNS.
+    \item Le protocole \textbf{TCP}: les informations sont vérifiées, corrigées, avec accusé de récéption et la transmission doit être validé par les deux processus. Il est utilisé en particilier pour la communication HTTP.
+  \end{itemize}
+\end{definition}
+
+\paragraph{Exemples}:
+\begin{itemize}
+  \item Echanges DNS (sur UDP):
+    \begin{center}
+      \includegraphics[scale=0.4]{./fig/echanges_dns}
+    \end{center}
+  \item Echanges HTTP (sur TCP):
+    \begin{center}
+      \includegraphics[scale=0.4]{./fig/echange_http}
+    \end{center}
+\end{itemize}
+
+\section{Couche application}
+
+La couche application est la couche qui permet aux applications d'utiliser le réseau.
+
+\paragraph{Exemples d'applications}
+\begin{itemize}
+  \item HTTP: échanges de fichier pour le web. Utilise par défaut le port 80.
+  \item HTTPs: échanges chiffrés de fichier pour le web. Utilise par défaut le port 443.
+  \item ssh: se connecter à une machine distante. Utilise par défaut le port 22.
+  \item IMAP: protocole d'envoie d'email. Utilise par défaut le port 143.
+  \item SMTP: protocole de récupération d'email. Utilise par défaut le port 25.
+  \item FTP: protocole d'échangees de fichiers. Utilise par défaut le port 21.
+\end{itemize}
+
+\end{document}

1NSI/11_Reseau/exercises.tex

@@ -0,0 +1,243 @@
+\begin{exercise}[subtitle={Découverte des réseau}, step={1}, origin={Ma tête}, topics={ Réseau }, tags={ Réseau, IP }]
+  Cet exercice se fait avec le logiciel \href{https://www.lernsoftware-filius.de/Herunterladen}{Filius}. C'est un logiciel que vous pouvez télécharger et installer librement sur votre ordinateur.
+
+  \begin{enumerate}
+    \item Récupérer et ouvrir avec Filius le fichier \texttt{complet.fls}
+    \item Décrire le matériel dont est composé ce réseau de réseaux.
+    \item Repérer l'ordinateur de Josy ainsi que le serveur opytex.org.
+    \item Lancer le mode simulation \includegraphics[scale=0.5]{./fig/simulation}, attendre une petite minute puis régler la vitesse à 10\% \includegraphics[scale=0.5]{./fig/vitesse_10}.
+    \item Ouvrir l'ordinateur de Josy, placer la fenêtre de tel sorte que vous puissiez voir l'ensemble du réseau, lancer le navigateur web, se connecter au site \texttt{opytex.org} puis observer le chemin des messages échangés (ils s'illuminent en vert). Noter le chemin parcouru jusqu'à l'obtention de la page web demandé.
+    \item En cliquant avec clic-droit sur l'ordi de Josy, afficher les données échangées. S'il y a déjà des choses dans cette table, vider les tables. Relancer la connection avec le navigateur sur \texttt{opytex.org} et observer la table des données échangées.
+      \begin{enumerate}
+        \item Quels sont les protocoles des échanges ?
+        \item Qui sont les sources et les destinataires ?
+        \item Cliquer sur une trame HTTP et noter le contenu. Que reconnaissez-vous ?
+      \end{enumerate}
+  \end{enumerate}
+\end{exercise}
+
+\begin{exercise}[subtitle={Liaison directe}, step={2}, origin={Ma tête}, topics={ Réseau }, tags={ Réseau, IP }]
+  Dans cet exercice, vous allez mettre en réseau deux ordinateurs et leur faire échanger des informations.
+  \begin{enumerate}
+    \item Ouvrir Filius et sélectionner le mode construction \includegraphics[scale=0.5]{./fig/construction}.
+      \begin{enumerate}
+        \item Ajouter deux ordinateurs portables et relier les avec un cable.
+        \item En faisant un clic droit sur un des deux ordinateurs puis en cliquant sur \texttt{configurer}, renommer le en \texttt{ordi1} puis donner lui l'adresse IP \texttt{192.168.0.1}.
+        \item Faire la même chose avec le deuxième ordinateur en le nommant \texttt{ordi2} et en lui donnant l'adresse IP \texttt{192.168.0.2}.
+      \end{enumerate}
+    \item Aller dans le mode simulation \includegraphics[scale=0.5]{./fig/simulation}.
+      \begin{enumerate}
+        \item Faire un clic droit sur \texttt{ordi1} puis ajouter \texttt{Ligne de commande} dans les logiciels installés et appliquer les modifications.
+        \item Ouvrir la ligne de commande et tapper \mintinline{bash}{ping 192.168.0.2}. Décrire ce qui se passe (pensez à observer votre réseau)
+        \item Ouvrir le tableau des données échangées (clic droit sur un des ordinateurs).
+        \item Noter les protocoles utilisés pour échanger des données.
+        \item Qu'est-il échangé lors des deux premiers échanges ARP?
+        \item Qu'est-il échangé lors des échanges ICMP?
+      \end{enumerate}
+  \end{enumerate}
+\end{exercise}
+
+\begin{exercise}[subtitle={Relier plus de deux ordinateurs}, step={2}, origin={Ma tête}, topics={ Réseau }, tags={ Réseau, IP }]
+  Ce TP se base sur le fichier \texttt{switch.fls}.
+  \begin{enumerate}
+    \item Décrire les éléments de ce réseau puis se mettre en mode simulation.
+    \item La commande \mintinline{bash}{arp} permet de connaître les associations adresse IP et adresse MAC connu par un ordinateur. Sur le poste P1, noter la réponse de la commande \mintinline{bash}{arp}.
+    \item Lancer un \mintinline{bash}{ping} vers 192.168.0.2 depuis P1. Relancer la commande \mintinline{bash}{arp} et noter le contenu.
+    \item Sur chacun des ordinateurs ouvrir le tableau des échanges.
+    \item Décrire ce qui se passe au niveau des échanges ARP.
+    \item Avec la commande \mintinline{bash}{ping}, faire en sorte que la table arp contienne tous les ordinateurs du réseau.
+    \item À quoi ressemble une adresse MAC?
+  \end{enumerate}
+\end{exercise}
+
+\begin{exercise}[subtitle={Protocole du bit alterné}, step={2}, origin={Inspiré de https://glassus.github.io/premiere_nsi/T3_Architecture_materielle/3.4_Protocoles_de_communication/cours/}, topics={ Réseau }, tags={ Réseau, IP }]
+    \label{bitAlterne}
+  Alice souhaite envoyer un message à Bob. Elle a découpé ce message en 4 morceaux M1, M2, M3 et M4. Elle envoie les morceaux de messages un par un.
+  \begin{enumerate}
+      \item On suppose que tout se passe bien. Faire un schéma pour illustrer la situation ainsi que le message reçu par Bob.
+      \item Imaginer des problèmes qui peuvent arriver et qui feraient que Bob n'arrive pas à avoir le bon message.
+      \item On suppose que le deuxième morceau n'arrive jamais.
+          \begin{enumerate}
+              \item Refaire le schéma de la situation.
+              \item Que pourrait-on mettre en place pour garantir que dans ces conditions, le message arrive bien au complet à Bob?
+              \item Alice et Bob se mettent d'accord pour que Bob renvoie un accusé de réception (ACK) et que si Alice ne le reçoit pas après un certain temps, elle renvoie le morceau. Expliquer à travers votre schéma en quoi ces mesures permettent alors à Bob d'avoir le bon message.
+          \end{enumerate}
+      \item On suppose maintenant que c'est l'accusé de réception de M2 qui n'arrive jamais. Quel message aura alors reçu Bob?
+  \end{enumerate}
+    Ils décident alors qu'Alice ajoute bit de contrôle appelé FLAG. Le premier message aura un FLAG égal à 0. Ensuite Bob ajoutera à son accusé de réception un FLAG lui aussi égal à 0. Tant que qu'elle n'a pas reçu d'accusé de réception avec le FLAG égal à 0 elle renverra le même message avec le même FLAG. Quand elle reçoit l'accusé de réception avec un FLAG égal à 0, elle envoie le morceau suivant avec le FLAG égal à 1 et ainsi de suite. Bob enverra toujours un accusé de réception avec le FLAG égal à celui du message.
+  \begin{enumerate}
+      \setcounter{enumi}{4}
+      \item Montrer que ce protocole, permet à Bob de recevoir le bon message dans les 3 cas suivants:
+          \begin{itemize}
+              \item Un morceau n'arrive jamais.
+              \item Un accusé de réception n'arrive jamais.
+              \item Un morceau arrive après le même message renvoyé par Alice.
+          \end{itemize}
+  \end{enumerate}
+  Ce protocole est appelé \textbf{bit alterné}
+\end{exercise}
+
+
+\begin{exercise}[subtitle={Relier plusieurs réseaux}, step={3}, origin={Ma tête}, topics={ Réseau }, tags={ Réseau, IP }]
+  Ce TP se base sur le fichier \texttt{routeur.fls}.
+  \begin{enumerate}
+    \item Décrire les éléments de ce réseau. Identifier les deux réseaux reliés et le matériel qui permet de les relier.
+    \item Entrer en mode simulation.
+    \item Échanges dans un réseau
+      \begin{enumerate}
+        \item Depuis le poste P1, noter l'état la table arp puis lancer un ping vers P2.
+        \item Quel matériel a été sollicité par ce ping?
+        \item Noter à nouveau l'état de la table arp de P1.
+      \end{enumerate}
+    \item Échange entre réseaux
+      \begin{enumerate}
+        \item Depuis le poste P1? Lancer un ping vers P4.
+        \item Quel matériel a été sollicité par ce ping?
+      \end{enumerate}
+    \item Pour suivre le chemin fait par un paquet pour relier P1 et P4, on peut utiliser la commande \mintinline{bash}{traceroute 192.168.1.2} depuis P1. Noter la réponse de cette commande.
+    \item Repasser en mode construction
+      \begin{enumerate}
+        \item Après avoir fait clic droit sur P1 et configurer, noter l'adresse IP, le masque et la passerelle (on appelle ces informations configuration réseau)
+        \item Idem pour les postes P2, et P4. Comparer ces informations.
+        \item On souhaite faire passer P4 sur l'autre réseau. Supprimer le cable et recabler l'ordinateur au bon réseau. Comment reconfigurer le réseau pour qu'il puisse échanger avec tous les ordinateurs des deux réseaux?
+      \end{enumerate}
+  \end{enumerate}
+\end{exercise}
+
+\begin{exercise}[subtitle={Routage}, step={3}, origin={https://frederic-junier.org/NSI/premiere/chapitre25/tp/TP-Filius-NSI-2020V1.pdf}, topics={ Réseau }, tags={ Réseau, IP }]
+\begin{exercise}[subtitle={Routage}, step={3}, origin={https://frederic-junier.org/NSI/premiere/chapitre25/tp/TP-Filius-NSI-2020V1.pdf}, topics={ Réseau }, tags={ Réseau, IP }]
+  Ce TP se base sur le fichier \texttt{routage.fls}.
+  \begin{enumerate}
+    \item Décrire les réseaux présents dans ce grand réseau.
+    \item Récupérer les adresses IP des ordinateurs \texttt{M14} et \texttt{M9}.
+    \item Vérifier avec un ping que la communication est possible entre ces deux machines.
+    \item Lancer un \mintinline{bash}{traceroute} depuis \texttt{M14} vers \texttt{M9}. Quel est le chemin emprunté pour échanger des messages entre ces deux machines ?
+    \item Supprimer le cable réseau reliant le routeur F et le routeur E (avec un clic droit). Relancer le \mintinline{bash}{traceroute} entre \texttt{M14} et \texttt{M9} (il est possible que la commande n'arrive pas à destination, si c'est le cas, il faudra attendre quelques minutes le temps que les tables de routages se mettent à jour).
+    \item Que peut-on conclure sur le routage des paquets?
+  \end{enumerate}
+\end{exercise}
+  Ce TP se base sur le fichier \texttt{routage.fls}.
+  \begin{enumerate}
+    \item Décrire les réseaux présents dans ce grand réseau.
+    \item Récupérer les adresses IP des ordinateurs \texttt{M14} et \texttt{M9}.
+    \item Vérifier avec un ping que la communication est possible entre ces deux machines.
+    \item Lancer un \mintinline{bash}{traceroute} depuis \texttt{M14} vers \texttt{M9}. Quel est le chemin emprunté pour échanger des messages entre ces deux machines ?
+    \item Supprimer le cable réseau reliant le routeur F et le routeur E (avec un clic droit). Relancer le \mintinline{bash}{traceroute} entre \texttt{M14} et \texttt{M9} (il est possible que la commande n'arrive pas à destination, si c'est le cas, il faudra attendre quelques minutes le temps que les tables de routages se mettent à jour).
+    \item Que peut-on conclure sur le routage des paquets?
+  \end{enumerate}
+\end{exercise}
+
+\begin{exercise}[subtitle={Protocole TCP}, step={4}, origin={Ma tête}, topics={ Réseau }, tags={ Réseau, IP }]
+    Ouvrir le fichier \texttt{complet.fls} dans Filius puis lancer une requête http depuis le navigateur depuis l'ordinateur de Josy.
+
+    On veut analyser le contenu de la couche transport des trames DNS jusqu'à la dernière TCP (13 trames.)
+    \begin{enumerate}
+        \item Quelles sont les informations présentes dans la couche transport ?
+        \item Quels sont les deux protocoles de la couche transport dans ces trames ?
+        \item Analyser uniquement les trames TCP, quelles similarités voyez-vous dans le champ commentaire avec l'exercice \ref{bitAlterne}
+        \item Faire un schéma pour illustrer les échanges entre l'ordinateur de Josy et le serveur de opytex.org.
+    \end{enumerate}
+\end{exercise}
+
+\begin{exercise}[subtitle={DNS et HTTP}, step={5}, origin={Ma tête}, topics={ Réseau }, tags={ Réseau, IP }]
+    \begin{enumerate}
+        \item Ouvrir le fichier \texttt{complet.fls} dans Filius puis lancer une requête http depuis le navigateur depuis l'ordinateur de Josy.
+        \item Étudier les 2 trames DNS au niveau de la couche application. Qu'est-ce qui est demandé ? Qu'est-ce qui est renvoyé?
+        \item Étudier les 2 trames HTTP au niveau de la couche application. Qu'est-ce qui est demandé ? Qu'est-ce qui est renvoyé? reconnaissez-vous quelque chose de connu?
+    \end{enumerate}
+\end{exercise}
+
+\begin{exercise}[subtitle={Client générique}, step={5}, origin={Ma tête}, topics={ Réseau }, tags={ Réseau, IP }]
+    \begin{enumerate}
+        \item Ouvrir le fichier \texttt{complet.fls} dans Filius.
+        \item Depuis l'ordinateur de Foo, lancer le client générique sur le serveur perso.com et sur le port 55555 puis envoyer un message.
+        \item Étudier les 2 trames DNS au niveau de la couche application. Qu'est-ce qui est demandé ? Qu'est-ce qui est renvoyé ?
+        \item Étudier les 2 autres trames application au niveau de la couche application. Qu'est-ce qui est échangé ?
+    \end{enumerate}
+\end{exercise}
+
+\begin{exercise}[subtitle={Email: POP3 et SMTP}, step={5}, origin={Ma tête}, topics={ Réseau }, tags={ Réseau, IP }]
+    \begin{enumerate}
+        \item Ouvrir le fichier \texttt{complet.fls} dans Filius.
+        \item Protocole POP3:
+            \begin{enumerate}
+                \item Depuis l'ordinateur de Bob, ouvrir le client mail puis appuyer sur le bouton Relever.
+                \item Étudier les 2 trames DNS au niveau de la couche application. Qu'est-ce qui est demandé ? Qu'est-ce qui est renvoyé ?
+                \item Étudier les trames POP3 au niveau de la couche application. Qu'est-il échangé?
+            \end{enumerate}
+        \item Protocole SMTP
+            \begin{enumerate}
+                \item Depuis l'ordinateur de Bob, ouvrir le client mail puis envoyer un nouveau message à hannah@mail.com
+                \item Étudier les trames SMTP au niveau de la couche application. Qu'est-il échangé?
+            \end{enumerate}
+    \end{enumerate}
+\end{exercise}
+
+\begin{exercise}[subtitle={QCM}, step={6}, origin={Ma tête}, topics={ Réseau }, tags={ Réseau, IP }]
+    \begin{enumerate}
+        \item Dans le protocole de communication IP :
+            \begin{tasks}
+                \task Les données sont envoyées en une seule partie.
+                \task Les données sont envoyées en plusieurs parties qui suivent le même itinéraire au sein du réseau.
+                \task Les données sont envoyées en plusieurs parties qui suivent des itinéraires différents au sein du réseau et arrivent à destination en respectant l’ordre de leur envoi.
+                \task Les données sont envoyées en plusieurs parties qui suivent des itinéraires différents au sein du réseau et arrivent à destination dans un ordre quelconque.
+            \end{tasks}
+
+        \item L'adresse IP du site www.education.gouv.fr est 185.75.143.24. Quel dispositif permet d'associer l'adresse IP et l'URL www.education.gouv.fr ?
+            \begin{tasks}(2)
+                \task un routeur
+                \task un serveur DNS
+                \task un serveur de temps
+                \task un serveur web
+            \end{tasks}
+
+        \item Quelle est l’utilité de la commande ping dans un réseau informatique ?
+            \begin{tasks}(1)
+                \task établir un réseau privé virtuel
+                \task tester si la connexion peut être établie avec une machine distante
+                \task obtenir la route suivie par un paquet dans le réseau
+                \task mesurer les performances d'une machine distante
+            \end{tasks}
+
+        \item Dans un terminal sous Linux, à quoi sert la commande traceroute ?
+            \begin{tasks}(1)
+                \task à afficher un itinéraire routier entre deux villes
+                \task c'est un synonyme pour la commande ping
+                \task à afficher le chemin suivi par des paquets à travers un protocole IP
+                \task à suivre pas à pas l'exécution d'un programme
+            \end{tasks}
+
+        \item Dans quel but le protocole du bit alterné peut-il être utilisé ?
+            \begin{tasks}(1)
+                \task Pour chiffrer des données lors de transmission de données sur un réseau
+                \task Pour détecter des pertes de paquets de données lors de transmission de données sur un réseau
+                \task Pour créer des paquets de données lors de transmission de données sur un réseau
+                \task Pour envoyer les paquets de données à la bonne l’adresse IP de la machine de destination
+            \end{tasks}
+
+        \item Quel matériel permet d'interconnecter des réseaux entre eux :
+            \begin{tasks}(2)
+                \task un routeur
+                \task un commutateur (ou switch)
+                \task un interconnecteur
+                \task un serveur
+             \end{tasks}
+
+         \item Un protocole est un ensemble de …
+            \begin{tasks}(1)
+                \task matériels connectés entre eux
+                \task serveurs et de clients connectés entre eux
+                \task règles qui régissent les échanges entre équipements informatiques
+                \task règles qui régissent les échanges entre un système d’exploitation et les applications
+            \end{tasks}
+
+        \item Laquelle de ces adresses IP v4 n'est pas valide ?
+            \begin{tasks}(2)
+                \task 201.201.123.147
+                \task 168.124.211.12
+                \task 10.19.9.1
+                \task 192.168.123.267
+            \end{tasks}
+
+    \end{enumerate}
+\end{exercise}