Fix: opytex.org bucket is empty...

tableaux de fonctions

.drone.yml

@@ -6,47 +6,107 @@ type: docker
 clone:
   skip_verify: true
 
-workspace:
-    path: /drone/content/
-
 steps:
-- 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: Clean before push
+    image: alpine
+    volumes:
+      - name: tosend
+        path: /tosend
+    commands:
+      - apk add --no-cache rsync
+      - >
+        rsync -am --include="*/" 
+        --include="*.html"
+        --include="*.css"
+        --include="*.png"
+        --include="*.jpg"
+        --include="*.odt"
+        --include="*.pdf" 
+        --exclude="*" 
+        ./ /tosend
 
-- name: Build Opytex 2022-2023
-  image: python:3.8-alpine
-  commands:
-  - apk add --no-cache git imagemagick-dev imagemagick
-  - cd ..
-  - git init .
-  - git remote add origin https://git.opytex.org/lafrite/site_opytex.git
-  - git pull origin 2022-2023
-  - git checkout 2022-2023
-  - git submodule init
-  - git submodule update
-  - pip install --no-cache-dir -r requirements.txt
-  - export MAGICK_HOME=/usr
-  - pelican content/ -o output -s publishconf.py --relative-urls
+  - 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
 
-  - 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 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 ..
+      - git init .
+      - git remote add origin https://git.opytex.org/lafrite/site_opytex.git
+      - git pull origin 2022-2023
+      - git checkout 2022-2023
+      - git submodule init
+      - git submodule update
+      - pip install --no-cache-dir -r requirements.txt
+      - export MAGICK_HOME=/usr
+      - pelican ./src/ -o /output -s publishconf.py --relative-urls
+      - ls /output
+
+  - 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_Divers/index.rst

@@ -1,13 +0,0 @@
-Accueil
-#######
-
-:date: 2022-08-21
-:modified: 2022-08-29
-:authors: Benjamin Bertrand
-:tags: Divers
-:category: 1NSI
-:summary: Documents d'accueil et de présentation de la spécialité NSI
-:slug: divers_1NSI
-
-Étape 1:
-========

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/doc_pygame.tex

@@ -0,0 +1,142 @@
+\documentclass[a4paper,12pt]{article}
+\usepackage{myXsim}
+
+\usepackage{listings}
+
+\date{Décembre 2022}
+\title{Documentation Pygame}
+\tribe{ISN}
+
+\definecolor{mygreen}{rgb}{0,0.6,0}
+\definecolor{mygray}{rgb}{0.5,0.5,0.5}
+\definecolor{mymauve}{rgb}{0.58,0,0.82}
+
+\lstset{ %
+  backgroundcolor=\color{white},   % choose the background color
+  basicstyle=\footnotesize,        % size of fonts used for the code
+  breaklines=true,                 % automatic line breaking only at whitespace
+  captionpos=b,                    % sets the caption-position to bottom
+  commentstyle=\color{mygreen},    % comment style
+  escapeinside={\%*}{*)},          % if you want to add LaTeX within your code
+  keywordstyle=\color{blue},       % keyword style
+  stringstyle=\color{mymauve},     % string literal style
+}
+
+\pagestyle{empty}
+
+\begin{document}
+
+\maketitle
+
+\section{Code minimal}
+
+\lstinputlisting[language=Python, frame=single]{pygame_base.py}
+
+\section{Dessiner sur la fenêtre: Draw}
+
+Dans toute la suite, on supposera que vous avez appelé la fenêtre \texttt{windowSurface}.
+
+Les couleurs se définissent avec leur code RGB:
+
+\begin{lstlisting}[language=Python, frame=single]
+BLACK = (0, 0, 0)
+WHITE = (255, 255, 255)
+RED = (255, 0, 0)
+GREEN = (0, 255, 0)
+BLUE = (0, 0, 255)
+\end{lstlisting}
+
+Tracer de objets géométriques
+
+\begin{itemize}
+    \item \textbf{Un segment:} \texttt{(60, 60)} sont les coordonnées du points de départ, \texttt{(120,60)} le point d'arrivé et \texttt{4} est l'épaisseur du trait.
+        \begin{lstlisting}[language=Python, frame=single]
+    pygame.draw.line(windowSurface, color, (60, 60), (120, 60), 4)
+        \end{lstlisting}
+    \item \textbf{Un cercle:}  \texttt{(300, 50)} sont les coordonnées du centre, \texttt{50} le rayon et \texttt{0} l'épaisseur du trait (0 signifie que le cercle est entièrement colorié).
+        \begin{lstlisting}[language=Python, frame=single]
+    pygame.draw.circle(windowSurface, color, (300, 50), 20, 0)
+        \end{lstlisting}
+    \item \textbf{Une ellipse:} \texttt{300} et \texttt{250} sont les coordonnées du centre, \texttt{40} le rayon horizontal, \texttt{80} le rayon vertical et \texttt{1} l'épaisseur du trait.
+        \begin{lstlisting}[language=Python, frame=single]
+    pygame.draw.ellipse(windowSurface, color, (300, 250, 40,80), 1)
+        \end{lstlisting}
+    \item \textbf{Un rectangle:} \texttt{20} et \texttt{30} sont les coordonnées du coin en haut à gauche du rectangle, \texttt{40} est la largeur et \texttt{50} est la hauteur.
+        \begin{lstlisting}[language=Python, frame=single]
+    pygame.draw.rect(windowSurface, color, (20, 30, 40, 50))
+        \end{lstlisting}
+    \item \textbf{Un polygone:} \texttt{((146, 0), (291, 106), (236, 277), (56, 277), (0, 106))} sont les coordonnées des sommets du polygone.
+        \begin{lstlisting}[language=Python, frame=single]
+    pygame.draw.polygon(windowSurface, color,
+            ((146, 0), (291, 106), (236, 277), (56, 277), (0, 106))
+            )
+        \end{lstlisting}
+\end{itemize}
+
+Il ne faut pas oublier la ligne suivante après avoir tracé tout ce que vous vouliez, sinon rien ne s'affichera.
+\begin{lstlisting}[language=Python, frame=single]
+pygame.display.update()
+\end{lstlisting}
+
+
+D'autres fonctions de dessins existent. Voici un exemple de tout ce qui peut être fait en dessin avec pygame.
+
+\lstinputlisting[language=Python, frame=single]{./draw_example.py}
+
+\paragraph{Ajouter une image:} Pygame permet d'ajouter des images ayant les formats suivant: JPG, PNG, GIF (non-animated), BMP. On supposera dans la suite qu'elles sont rangées dans le même dossier que notre programme.
+\begin{lstlisting}[language=Python, frame=single]
+#Charger l'image
+img = pygame.image.load('image.jpg')
+# L'afficher sur la surface
+windowSurface.blit(img, (0,0))
+\end{lstlisting}
+Les coordonnées \texttt{(0,0)} sont les coordonnées de l'angle en haut à droit de l'image sur la surface.
+
+
+\section{Interaction avec les périphériques: Events}
+
+L'interaction avec l'utilisateur se fait dans la boucle des évènements.
+
+\begin{lstlisting}[language=Python, frame=single]
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            running = False
+        elif event.type == pygame.KEYUP:
+            # choses a faire quand une touche du clavier est relachee
+            if event.key == pygame.K_UP:
+                # choses a faire quand c'est la touche fleche du haut
+            elif event.key == pygame.K_DOWN:
+                # choses a faire quand c'est la touche fleche du bas
+        elif event.type == pygame.KEYDOWN:
+            # choses a faire quand une touche du clavier est pressee
+            elif event.key == pygame.K_LEFT:
+                # choses a faire quand c'est la touche fleche de gauche
+            elif event.key == pygame.K_RIGHT:
+                # choses a faire quand c'est la touche fleche de droite
+        elif event.type == pygame.MOUSEBUTTONUP:
+            # choses a faire quand le bouton de la souris est relache
+        elif event.type == pygame.MOUSEBUTTONDOWN:
+            # choses a faire quand le bouton de la souris est pressee
+\end{lstlisting}
+
+De manière générale, le nom des touches de clavier sont faite sur le même modèle: \texttt{K\_\#\#\#} où on remplace les \texttt{\#} par le nom de la touche.
+\begin{itemize}
+    \item Touche flèche du haut: \texttt{K\_UP}
+    \item Touche E: \texttt{K\_E}
+    \item Touche entrée: \texttt{K\_ESCAPE}
+\end{itemize}
+
+Quelques méthodes pratiques pour manipuler la souris
+
+\begin{itemize}
+    \item \texttt{pygame.mouse.get\_pos()} : connaître la position de la souris sur la fenêtre.
+    \item \texttt{pygame.mouse.set\_pos((x,y))}: déplacer la souris à un endroit.
+\end{itemize}
+
+
+\end{document}
+
+%%% Local Variables:
+%%% mode: latex
+%%% TeX-master: "master"
+%%% End:

1NSI/00_Projets/draw.py

@@ -0,0 +1,66 @@
+import pygame, sys
+
+pygame.init()
+
+windowSurface = pygame.display.set_mode((500, 400))
+pygame.display.set_caption('Hello world!')
+
+BLACK = (0, 0, 0)
+WHITE = (255, 255, 255)
+RED = (255, 0, 0)
+GREEN = (0, 255, 0)
+BLUE = (0, 0, 255)
+
+color_text = WHITE
+color_background = WHITE
+color_polygon = GREEN
+color_border = RED
+
+running = True
+while running:
+
+    windowSurface.fill(color_background)
+
+    pygame.draw.polygon(windowSurface, color_polygon,
+            ((146, 0), (291, 106), (236, 277), (56, 277), (0, 106))
+            )
+
+    pygame.draw.line(windowSurface, BLUE, (60, 60), (120, 60), 4)
+    pygame.draw.line(windowSurface, BLUE, (120, 60), (60, 120))
+    pygame.draw.line(windowSurface, BLUE, (60, 120), (120, 120), 4)
+
+    pygame.draw.circle(windowSurface, BLUE, (300, 50), 20, 0)
+
+    pygame.draw.ellipse(windowSurface, RED, (300, 250, 40,80), 1)
+
+    basic_font = pygame.font.SysFont(None, 48)
+    text = basic_font.render('Hello world!', True, color_text ,BLUE)
+    text_rect = text.get_rect()
+    text_rect.centerx = windowSurface.get_rect().centerx
+    text_rect.centery = windowSurface.get_rect().centery
+
+    pygame.draw.rect(windowSurface, color_border,
+            (text_rect.left - 20, text_rect.top - 20,
+                text_rect.width + 40, text_rect.height + 40)
+            )
+
+
+    windowSurface.blit(text, text_rect)
+
+    pygame.display.update()
+
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            running = False
+        elif event.type == pygame.MOUSEBUTTONUP:
+            color_background = WHITE
+            color_border = (255, (color_border[1] + 10) % 256, 0)
+        elif event.type == pygame.MOUSEBUTTONDOWN:
+            color_background = RED
+        elif event.type == pygame.KEYUP:
+            if event.key == pygame.K_UP:
+                color_polygon = BLACK
+            elif event.key == pygame.K_DOWN:
+                color_polygon = GREEN
+
+pygame.quit()

1NSI/00_Projets/draw_example.py

@@ -0,0 +1,83 @@
+# Import a library of functions called 'pygame'
+import pygame
+from math import pi
+
+# Initialize the game engine
+pygame.init()
+
+# Define the colors we will use in RGB format
+BLACK = (  0,   0,   0)
+WHITE = (255, 255, 255)
+BLUE =  (  0,   0, 255)
+GREEN = (  0, 255,   0)
+RED =   (255,   0,   0)
+
+# Set the height and width of the screen
+size = [400, 300]
+screen = pygame.display.set_mode(size)
+
+pygame.display.set_caption("Example code for the draw module")
+
+#Loop until the user clicks the close button.
+done = False
+clock = pygame.time.Clock()
+
+while not done:
+
+    # This limits the while loop to a max of 10 times per second.
+    # Leave this out and we will use all CPU we can.
+    clock.tick(10)
+
+    for event in pygame.event.get(): # User did something
+        if event.type == pygame.QUIT: # If user clicked close
+            done=True # Flag that we are done so we exit this loop
+
+    # All drawing code happens after the for loop and but
+    # inside the main while done==False loop.
+
+    # Clear the screen and set the screen background
+    screen.fill(WHITE)
+
+    # Draw on the screen a GREEN line from (0,0) to (50.75)
+    # 5 pixels wide.
+    pygame.draw.line(screen, GREEN, [0, 0], [50,30], 5)
+
+    # Draw on the screen a GREEN line from (0,0) to (50.75)
+    # 5 pixels wide.
+    pygame.draw.lines(screen, BLACK, False, [[0, 80], [50, 90], [200, 80], [220, 30]], 5)
+
+    # Draw on the screen a GREEN line from (0,0) to (50.75)
+    # 5 pixels wide.
+    pygame.draw.aaline(screen, GREEN, [0, 50],[50, 80], True)
+
+    # Draw a rectangle outline
+    pygame.draw.rect(screen, BLACK, [75, 10, 50, 20], 2)
+
+    # Draw a solid rectangle
+    pygame.draw.rect(screen, BLACK, [150, 10, 50, 20])
+
+    # Draw an ellipse outline, using a rectangle as the outside boundaries
+    pygame.draw.ellipse(screen, RED, [225, 10, 50, 20], 2)
+
+    # Draw an solid ellipse, using a rectangle as the outside boundaries
+    pygame.draw.ellipse(screen, RED, [300, 10, 50, 20])
+
+    # This draws a triangle using the polygon command
+    pygame.draw.polygon(screen, BLACK, [[100, 100], [0, 200], [200, 200]], 5)
+
+    # Draw an arc as part of an ellipse.
+    # Use radians to determine what angle to draw.
+    pygame.draw.arc(screen, BLACK,[210, 75, 150, 125], 0, pi/2, 2)
+    pygame.draw.arc(screen, GREEN,[210, 75, 150, 125], pi/2, pi, 2)
+    pygame.draw.arc(screen, BLUE, [210, 75, 150, 125], pi,3*pi/2, 2)
+    pygame.draw.arc(screen, RED,  [210, 75, 150, 125], 3*pi/2, 2*pi, 2)
+
+    # Draw a circle
+    pygame.draw.circle(screen, BLUE, [60, 250], 40)
+
+    # Go ahead and update the screen with what we've drawn.
+    # This MUST happen after all the other drawing commands.
+    pygame.display.update()
+
+# Be IDLE friendly
+pygame.quit()

1NSI/00_Projets/index.rst

@@ -0,0 +1,185 @@
+Projets
+#######
+
+:date: 2022-12-06
+:modified: 2023-04-06
+:authors: Benjamin Bertrand
+:tags: Divers
+:category: 1NSI
+:summary: Projets avec les 1NSI
+:slug: divers_1NSI
+
+Le programme
+============
+
+- Une part de l’horaire de l’enseignement d’au moins un quart du total en classe de première doit être réservée à la conception et à l’élaboration de projets conduits par des groupes de deux à quatre élèves.
+- La gestion d’un projet inclut des points d’étape pour faire un bilan avec le professeur, valider des éléments, contrôler l’avancement du projet ou adapter ses objectifs, voire le redéfinir partiellement, afin de maintenir la motivation des élèves.
+
+Du coup, on part sur une heure par semaine dédié au projet.
+
+Organisation
+============
+
+Je m'inspire de la gestion de projet proposée par Jean-Luc Richter (je n'arrive pas à remettre la main sur l'article où il détaillait ça...).
+
+Trimestre 1: présentation/vente du projet
+-----------------------------------------
+
+Les deux premières semaines sont consacrés à découvrir/chercher des projets déjà réalisé par d'autres élèves de première et à choisir un projet qui motive l'élève. Une banque à projets sourcées est constitué. Les groupes sont ensuite constitués en fonction des intérêts de chacun.
+
+Les élèves ensuite se lancent dans la réalisation d'un site internet vantant/vendant leur projet. Ils peuvent promettre ceux qu'ils veulent tant pis s'il ne le réalise pas. Ils doivent faire un site qui claque le plus et qui donne envie de voir le projet réalisé.
+
+Pour l'organisation, on a choisi d'utiliser un Kanban. Les séances projets commencent avec la lecture des taches déjà réalisées, en cours ou à faire. Ils peuvent ajouter d'autres. Puis ils sélectionnent les taches qu'ils vont réalisé pendant l'heure. Ces taches sont disposés sur le tableau dans les colonnes appropriés. Les élèves partent ensuite faire leur projet, en avançant les taches. A la fin, un bilan est réalisé et les taches mises à jour. Mon role ici est d'accompagner les élèves à écrire et sélectionner les taches puis de les garder le plus concentré possible sur ce qu'ils ont décidé de faire.
+
+A la fin du trimestre, le site est déposé sur le serveur pour notation.
+
+Barème:
+
+- Présentation:
+  - Clareté /3
+  - Fait envie /2
+- Technique
+  - Validité du code /2
+  - Mobilisation des outils étudiées en html et css /6
+  - Nouveau outils découverts /2
+- Organisation
+  - autonomie dans le travail /2
+  - Collaboration dans l'équipe /2
+  - Précision des taches à réaliser /1
+
+Trimestre 2: Première ébauche du projet
+---------------------------------------
+
+Le deuxième trimestre a pour but de réaliser une première version rustique du projet. Les élèves devront être capable de faire une démonstration.
+
+On commence par une introduction à Pygame sur deux semaines. On verra plus tard pour une introduction à flask et javascript.
+
+Introduction à Pygame: snake
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Les élèves travaillent sur `le programme draw.py <./draw.py>`_.
+
+Ils doivent l'exécuter, commenter chaque ligne en expliquant ce qu'il s'y passe et se construire un mémo des fonctions de Pygame.
+
+Ils sont très fortement invités à modifier le programme pour se l'approprier.
+
+On coupera régulièrement la séance pour faire des petits bilans sur les questions intéressantes que se posent les élèves. Voici quelques sujets qui seront sans aucuns doutes traités :
+ - La couleur et le code RGB
+ - Le repère et les coordonnées dans Pygame
+ - Les coordonnées dans les fonctions pour tracer les éléments
+ - la gestion des évènements
+
+.. image:: ./doc_pygame.pdf
+    :height: 200px
+    :alt: Documentation maison sur pygame
+
+
+Le but est de refaire le `jeu snake <./snake.pdf>`_.
+
+Ce projet est décomposer en étapes. Les premières sont à faire dans l'ordre mais on peut laisser à partir de l'étape 4 la liberté aux élèves d'ajouter des étapes ou de faire les étapes dans l'ordre qui leur convient le mieux.
+
+.. image:: ./snake.pdf
+    :height: 200px
+    :alt: Propositions d'étapes pour réaliser snake
+
+
+Pour les accompagner, on peut leur donner `ce modèle <./pygame_base.py>`_ pour commencer un projet Pygame.
+
+Notation du projet Snake
+
+.. list-table:: Notation
+    :header-rows: 1
+
+    * - Description
+      - Points
+    * - Qualité du code (lisibilité, nom explicite des variables, organisation...)
+      - 2
+    * - Utilisation de fonctions
+      - 1
+    * - Grille et éléments graphiques
+      - 2
+    * - Déplacement du serpent et respect des bordures
+      - 2
+    * - Nourriture et points
+      - 2
+    * - Serpent avec plus d'une case
+      - 1
+
+Une "correction" et quelques éléments sur la géométrie de la fenêtre :
+
+.. - `snake version avancé <./snake_corr.py>`_ (Il y a potentiellement encore des milliers de choses à ajouter !)
+
+ - `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/00_Projets/pygame_base.py

@@ -0,0 +1,30 @@
+# Importation de pygame
+import pygame
+
+pygame.init()
+
+# Initialisation de la fenetre
+largeur = 600
+hauteur = 400
+windowSurface = pygame.display.set_mode((largeur, hauteur), 0,32)
+
+# Initialisation des parametres
+
+
+# Boucle de jeu
+clock = pygame.time.Clock()
+running = True
+while running:
+    # Limitation du nombre de tours de boucle par seconde.
+    clock.tick(10)
+    # Boucle des evenements
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            running = False
+
+    # Elements a tracer
+
+    pygame.display.update()
+
+
+pygame.quit()

1NSI/00_Projets/snake.tex

@@ -0,0 +1,44 @@
+\documentclass[a4paper,12pt]{article}
+\usepackage{myXsim}
+
+\date{Décembre 2022}
+\title{Jeu Snake}
+\tribe{ISN}
+
+\pagestyle{empty}
+\begin{document}
+
+\maketitle
+
+\bigskip
+
+Le but de cette activité est de (re)créer le jeu snake en python avec Pygame.
+
+
+\begin{center}
+    \includegraphics[scale=0.6]{./fig/snake_internet.png}
+\end{center}
+
+D'après Wikipédia:
+
+\begin{quote}
+    Le joueur contrôle une longue et fine ligne semblable à un serpent, qui doit slalomer entre les bords de l'écran et les obstacles qui parsèment le niveau. Pour gagner chacun des niveaux, le joueur doit faire manger à son serpent un certain nombre de pastilles similaire à de la nourriture, allongeant à chaque fois la taille du serpent. Alors que le serpent avance inexorablement, le joueur ne peut que lui indiquer une direction à suivre (en haut, en bas, à gauche, à droite) afin d'éviter que la tête du serpent ne touche les murs ou son propre corps, auquel cas il risque de mourir.
+\end{quote}
+
+\section*{Proposition d'étapes à suivre}
+
+\begin{enumerate}
+    \item \textbf{Scène et acteurs:} Afficher le nom du jeu (sans la partie statistique et contrôles), la grille de jeu et notre serpent (jusqu'à l'étape 6, le serpent ne fera qu'une seule case).
+    \item \textbf{Contrôles}: Faire déplacer le serpent avec les flèches du clavier.
+    \item \textbf{Déplacement et contrôles:} Dans le jeu Snake, le serpent ne s'arrête jamais. Le joueur peut seulement changer la direction du serpent avec les touches du clavier. Programmer ce comportement. Penser à ajouter ajouter un texte qui explique comment jouer.
+    \item \textbf{Game Over:} Le jeu annonce Game Over et s'arrête quand le serpent sort de la grille de jeu.
+    \item \textbf{La nourriture:} La nourriture apparait aléatoirement sur la grille. Dès que le serpent arrive sur cette case, il gagne un point et la nourriture apparait ailleurs. Les points s'affichent sur le côté.
+    \item \textbf{Un beau serpent:} Le serpent faire 3 cases de long. À chaque fois qu'il mange, il grandit d'une case. S'il se déplace sur sa queue, la partie est terminée.
+\end{enumerate}
+
+\end{document}
+
+%%% Local Variables:
+%%% mode: latex
+%%% TeX-master: "master"
+%%% End:

1NSI/00_Projets/snake_corr.py

@@ -0,0 +1,180 @@
+"""
+ Snake pour l'ISN
+
+"""
+
+import pygame
+from random import randint
+
+def draw_grid():
+    """ Dessine la grille """
+    for i in range(COLUMN+1):
+        pygame.draw.line(screen, WHITE, (i*CELLSIZE, 0), (i*CELLSIZE, ROW*CELLSIZE))
+    for i in range(ROW+1):
+        pygame.draw.line(screen, WHITE, (0, i*CELLSIZE), (COLUMN*CELLSIZE, i*CELLSIZE))
+
+def draw_snake(snake):
+    """ Dessine le serpent """
+    for i, j in snake:
+        top_left = (i * CELLSIZE, j * CELLSIZE)
+        pygame.draw.rect(screen, GREEN, (*top_left, CELLSIZE, CELLSIZE))
+
+def draw_cherry(cherry):
+    """ Dessine les cherry (bonus) """
+    center = (int((cherry[0] + 0.5) * CELLSIZE), int((cherry[1] + 0.5) * CELLSIZE))
+    radius = int(0.5*CELLSIZE)
+    pygame.draw.circle(screen, RED, center, radius)
+
+def draw_right(score):
+    """ Dessine la partie droite de la fenête """
+    width_right_bar = s_width - COLUMN*CELLSIZE
+    top_left_right_bar = (COLUMN*CELLSIZE, 0)
+    title = TITLEFONT.render("SNAKE", True, WHITE)
+    title_rect = title.get_rect()
+    title_rect.centerx = int(top_left_right_bar[0] + width_right_bar/2)
+    title_rect.centery = 50
+    screen.blit(title, title_rect)
+
+    score_text = "Score " + str(score)
+    score = TEXTFONT.render(score_text, True, WHITE)
+    score_rect = score.get_rect()
+    score_rect.centerx = int(top_left_right_bar[0] + width_right_bar/2)
+    score_rect.centery = 100
+    screen.blit(score, score_rect)
+
+def random_place(row, col):
+    """ Retourne un lieu aléatoire sur la grille """
+    return [randint(0, row-1), randint(0, col-1)]
+
+def move_snake(snake, snake_direction, growing):
+    """ Retourne la nouvelle position du snake
+
+    Si growing est True, on ne supprime par le dernier élément de la queue pour que le serpent grandisse
+
+    L'idée est de trouver les coordonnées de la nouvelle tête (new_head) puis de coller le corp du serpent (en supprimant la dernière partie si l'on veut que le serpent de grandisse pas.
+
+    """
+    new_head = [snake[0][0] + snake_direction[0], snake[0][1] + snake_direction[1]]
+    if growing:
+        return [new_head] + snake
+    else:
+        # [:-1] permet de dire que l'on veut la liste sauf le dernier élément.
+        return [new_head] + snake[:-1]
+
+def is_out(snake):
+    """ Retourne True si le snake est sorti de la grille """
+    # le snake[0] est la tête du serpent.
+    return snake[0][0] > COLUMN or \
+            snake[0][0] < 0 or \
+            snake[0][1] > ROW or\
+            snake[0][1] < 0
+
+def is_eating_queue(snake):
+    """ Retourne True si le serpent se mort la queue """
+    # On se demande si la tête du serpent est dans (in) la queue dans ce cas il se mort la queue
+    return snake[0] in snake[1:]
+
+def is_eating(snake, cherry):
+    """ Retroune True si le snake mange la cherry"""
+    return snake[0] == cherry
+
+# Call this function so the Pygame library can initialize itself
+pygame.init()
+
+# --- Globals ---
+# Colors
+BLACK = (0, 0, 0)
+GREEN = (0, 255, 0)
+RED = (255, 0, 0)
+WHITE = (255, 255, 255)
+# font
+TITLEFONT = pygame.font.SysFont(None, 48)
+TEXTFONT = pygame.font.SysFont(None, 30)
+
+# THE GRID
+ROW = 20
+COLUMN = 20
+
+# CELL
+CELLSIZE = 20
+
+# Create an 800x600 sized screen
+s_width = COLUMN * CELLSIZE + 200
+s_height = ROW * CELLSIZE + 1
+screen = pygame.display.set_mode([s_width, s_height])
+
+# Set the title of the window
+pygame.display.set_caption('Snake')
+
+clock = pygame.time.Clock()
+
+# The snake
+snake = [[5, 5], [4, 5], [3, 5]]
+snake_direction = [1, 0]
+
+# The cherry
+cherry = random_place(ROW, COLUMN)
+
+# The score
+score = 0
+growing = False
+
+running = True
+while running:
+    # Event loop
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            running = False
+        elif event.type == pygame.KEYUP:
+            # On empèche que le snake fasse demi tour
+            if event.key == pygame.K_UP:
+                if snake_direction != [0, 1]:
+                    snake_direction = [0, -1]
+            elif event.key == pygame.K_DOWN:
+                if snake_direction != [0, -1]:
+                    snake_direction = [0, 1]
+            elif event.key == pygame.K_LEFT:
+                if snake_direction != [1, 0]:
+                    snake_direction = [-1, 0]
+            elif event.key == pygame.K_RIGHT:
+                if snake_direction != [-1, 0]:
+                    snake_direction = [1, 0]
+
+    # Move the snake
+    if growing:
+        snake = move_snake(snake, snake_direction, True)
+        growing = False
+    else:
+        snake = move_snake(snake, snake_direction, False)
+
+    # Draw elements
+    screen.fill(BLACK)
+    draw_grid()
+    draw_right(score)
+    draw_snake(snake)
+    draw_cherry(cherry)
+
+    # Flip screen
+    pygame.display.flip()
+
+    if is_eating(snake, cherry):
+        score = score + 1
+        growing = True
+        cherry = random_place(ROW, COLUMN)
+
+    # loosing!
+    if is_out(snake) or is_eating_queue(snake):
+        screen.fill(BLACK)
+        text = TITLEFONT.render('You loose!!', True, BLACK,WHITE)
+        textRect = text.get_rect()
+        textRect.centerx = screen.get_rect().centerx
+        textRect.centery = screen.get_rect().centery
+        screen.blit(text, textRect)
+        pygame.display.flip()
+        pygame.time.wait(1000)
+        running = False
+
+    # Pause
+    clock.tick(2)
+
+pygame.quit()

1NSI/00_Projets/snake_expl.svg

@@ -0,0 +1,311 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:xlink="http://www.w3.org/1999/xlink"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   viewBox="0 0 801.33331 570.66669"
+   height="570.66669"
+   width="801.33331"
+   id="svg869"
+   version="1.1"
+   sodipodi:docname="snake_expl.svg"
+   inkscape:version="0.92.2 2405546, 2018-03-11">
+  <sodipodi:namedview
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1"
+     objecttolerance="10"
+     gridtolerance="10"
+     guidetolerance="10"
+     inkscape:pageopacity="0"
+     inkscape:pageshadow="2"
+     inkscape:window-width="1920"
+     inkscape:window-height="1052"
+     id="namedview48"
+     showgrid="false"
+     inkscape:zoom="1.1697"
+     inkscape:cx="323.7925"
+     inkscape:cy="206.6537"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg869" />
+  <metadata
+     id="metadata875">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title />
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <defs
+     id="defs873">
+    <marker
+       inkscape:stockid="Arrow1Mend"
+       orient="auto"
+       refY="0.0"
+       refX="0.0"
+       id="Arrow1Mend"
+       style="overflow:visible;"
+       inkscape:isstock="true">
+      <path
+         id="path986"
+         d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
+         transform="scale(0.4) rotate(180) translate(10,0)" />
+    </marker>
+    <marker
+       orient="auto"
+       refY="0.0"
+       refX="0.0"
+       id="marker8051"
+       style="overflow:visible;">
+      <path
+         id="path8049"
+         d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
+         transform="scale(0.8) rotate(180) translate(12.5,0)" />
+    </marker>
+    <marker
+       orient="auto"
+       refY="0.0"
+       refX="0.0"
+       id="marker7709"
+       style="overflow:visible">
+      <path
+         id="path7707"
+         d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
+         transform="scale(0.8) translate(12.5,0)" />
+    </marker>
+    <marker
+       orient="auto"
+       refY="0.0"
+       refX="0.0"
+       id="marker7395"
+       style="overflow:visible">
+      <path
+         id="path7393"
+         d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
+         transform="scale(0.8) translate(12.5,0)" />
+    </marker>
+    <marker
+       orient="auto"
+       refY="0.0"
+       refX="0.0"
+       id="marker7379"
+       style="overflow:visible;">
+      <path
+         id="path7377"
+         d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
+         transform="scale(0.8) rotate(180) translate(12.5,0)" />
+    </marker>
+    <marker
+       orient="auto"
+       refY="0.0"
+       refX="0.0"
+       id="marker7119"
+       style="overflow:visible;">
+      <path
+         id="path7117"
+         d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
+         transform="scale(0.8) rotate(180) translate(12.5,0)" />
+    </marker>
+    <marker
+       style="overflow:visible;"
+       id="marker1407"
+       refX="0.0"
+       refY="0.0"
+       orient="auto">
+      <path
+         transform="scale(0.8) rotate(180) translate(12.5,0)"
+         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
+         d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+         id="path1405" />
+    </marker>
+    <marker
+       style="overflow:visible"
+       id="marker1237"
+       refX="0.0"
+       refY="0.0"
+       orient="auto">
+      <path
+         transform="scale(0.8) translate(12.5,0)"
+         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
+         d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+         id="path1235" />
+    </marker>
+    <marker
+       style="overflow:visible;"
+       id="Arrow1Lend"
+       refX="0.0"
+       refY="0.0"
+       orient="auto">
+      <path
+         transform="scale(0.8) rotate(180) translate(12.5,0)"
+         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
+         d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+         id="path928" />
+    </marker>
+    <marker
+       style="overflow:visible"
+       id="Arrow1Lstart"
+       refX="0.0"
+       refY="0.0"
+       orient="auto">
+      <path
+         transform="scale(0.8) translate(12.5,0)"
+         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
+         d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+         id="path925" />
+    </marker>
+    <marker
+       style="overflow:visible"
+       id="Arrow1Mstart"
+       refX="0.0"
+       refY="0.0"
+       orient="auto">
+      <path
+         transform="scale(0.4) translate(10,0)"
+         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
+         d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+         id="path931" />
+    </marker>
+  </defs>
+  <image
+     sodipodi:absref="/home/lafrite/Cours/Prof/Enseignements/2017-2018/ISN/pygame/fig/snake_corr.png"
+     xlink:href="fig/snake_corr.png"
+     y="109.27795"
+     x="144.4212"
+     id="image877"
+     preserveAspectRatio="none"
+     height="352.11078"
+     width="494.43591" />
+  <path
+     id="path879"
+     d="M 145.96232,87.695672 H 637.31601"
+     style="fill:none;stroke:#000000;stroke-width:1.00157475;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-start:url(#Arrow1Lstart);marker-end:url(#Arrow1Lend)" />
+  <path
+     id="path881"
+     d="M 648.04522,135.73483 V 462.01432"
+     style="fill:none;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;marker-start:url(#marker1237);marker-end:url(#marker1407)" />
+  <g
+     id="g917">
+    <text
+       xml:space="preserve"
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:16px;line-height:1;font-family:Consolas, 'Liberation Mono', Menlo, Courier, monospace;-inkscape-font-specification:'Consolas, Liberation Mono, Menlo, Courier, monospace';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none"
+       x="132.58679"
+       y="143.47269"
+       id="text885"><tspan
+         x="132.58679"
+         y="143.47269"
+         id="tspan887"
+         style="font-size:13.33333302px;line-height:1">0</tspan><tspan
+         x="132.58679"
+         y="159.47269"
+         style="font-size:13.33333302px;line-height:1"
+         id="tspan893">1</tspan><tspan
+         x="132.58679"
+         y="175.47269"
+         id="tspan889"
+         style="font-size:13.33333302px;line-height:1">2</tspan></text>
+    <text
+       xml:space="preserve"
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:13.33333302px;line-height:1.25;font-family:Consolas, 'Liberation Mono', Menlo, Courier, monospace;-inkscape-font-specification:'Consolas, Liberation Mono, Menlo, Courier, monospace';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none"
+       x="115.35721"
+       y="456.22137"
+       id="text897"><tspan
+         id="tspan895"
+         x="115.35721"
+         y="456.22137">ROW</tspan></text>
+  </g>
+  <text
+     id="text901"
+     y="479.93118"
+     x="152.74573"
+     style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:16px;line-height:1.25;font-family:Consolas, 'Liberation Mono', Menlo, Courier, monospace;-inkscape-font-specification:'Consolas, Liberation Mono, Menlo, Courier, monospace';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none"
+     xml:space="preserve"><tspan
+       y="491.57919"
+       x="152.74573"
+       id="tspan899" /></text>
+  <g
+     id="g923">
+    <text
+       xml:space="preserve"
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:16px;line-height:1.25;font-family:Consolas, 'Liberation Mono', Menlo, Courier, monospace;-inkscape-font-specification:'Consolas, Liberation Mono, Menlo, Courier, monospace';letter-spacing:-1.29999995px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none"
+       x="148.18616"
+       y="474.45969"
+       id="text905"><tspan
+         id="tspan903"
+         x="148.18616"
+         y="474.45969">0 1 2</tspan></text>
+    <text
+       xml:space="preserve"
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:16px;line-height:1.25;font-family:Consolas, 'Liberation Mono', Menlo, Courier, monospace;-inkscape-font-specification:'Consolas, Liberation Mono, Menlo, Courier, monospace';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none"
+       x="439.54291"
+       y="474.12369"
+       id="text909"><tspan
+         id="tspan907"
+         x="439.54291"
+         y="474.12369">COLUMN</tspan></text>
+  </g>
+  <text
+     id="text1743"
+     y="77.378532"
+     x="357.61792"
+     style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:16px;line-height:1.25;font-family:Consolas, 'Liberation Mono', Menlo, Courier, monospace;-inkscape-font-specification:'Consolas, Liberation Mono, Menlo, Courier, monospace';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none"
+     xml:space="preserve"><tspan
+       y="77.378532"
+       x="357.61792"
+       id="tspan1741">s_width</tspan></text>
+  <text
+     id="text1747"
+     y="288.85159"
+     x="671.25879"
+     style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:16px;line-height:1.25;font-family:Consolas, 'Liberation Mono', Menlo, Courier, monospace;-inkscape-font-specification:'Consolas, Liberation Mono, Menlo, Courier, monospace';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none"
+     xml:space="preserve"><tspan
+       y="288.85159"
+       x="671.25879"
+       id="tspan1745">s_height</tspan></text>
+  <text
+     id="text7577"
+     y="274.75037"
+     x="64.289993"
+     style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:13.33333302px;line-height:1.25;font-family:Consolas, 'Liberation Mono', Menlo, Courier, monospace;-inkscape-font-specification:'Consolas, Liberation Mono, Menlo, Courier, monospace';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none"
+     xml:space="preserve"><tspan
+       y="274.75037"
+       x="64.289993"
+       id="tspan7575">CELLSIZE</tspan></text>
+  <path
+     style="fill:none;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;marker-start:url(#Arrow1Mstart);marker-end:url(#Arrow1Mend)"
+     d="m 132.51261,263.9641 v 14.31991"
+     id="path915"
+     inkscape:connector-curvature="0" />
+  <path
+     style="fill:none;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;marker-start:url(#marker1237);marker-end:url(#marker7119)"
+     d="M 479.61017,497.14356 H 636.06055"
+     id="path1319"
+     inkscape:connector-curvature="0" />
+  <text
+     xml:space="preserve"
+     style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:13.33333302px;line-height:1.25;font-family:Consolas, 'Liberation Mono', Menlo, Courier, monospace;-inkscape-font-specification:'Consolas, Liberation Mono, Menlo, Courier, monospace';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none"
+     x="496.70856"
+     y="519.37146"
+     id="text1323"><tspan
+       sodipodi:role="line"
+       id="tspan1321"
+       x="496.70856"
+       y="519.37146">width_right_bar</tspan></text>
+</svg>

1NSI/02_Programmation_Python_et_microbit/techniques.tex

@@ -0,0 +1,24 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+
+\author{Benjamin Bertrand}
+\title{Python et micro:bit - Plan de travail}
+\tribe{1NSI}
+\date{septembre 2022}
+
+\DeclareExerciseCollection[step=7]{banque}
+\xsimsetup{collect}
+
+
+\pagestyle{empty}
+
+\begin{document}
+\input{exercises.tex}
+
+\setcounter{exercise}{10}
+
+\printcollection{banque}
+\vfill
+\printcollection{banque}
+
+\end{document}

1NSI/03_Systeme_dexploitation/2B_command_memo.tex

@@ -0,0 +1,249 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+\usepackage{minted}
+
+\author{Bertrand Benjamin}
+\title{Système d'exploitation - Cours}
+\date{octobre 2022}
+
+\pagestyle{empty}
+
+\begin{document}
+
+\maketitle
+
+\setcounter{section}{1}
+
+\section{Commandes shell}
+
+\begin{definition}[ Commande shell ]
+    Une commande shell est constituée du nom de la commande suivi d’un ou plusieurs arguments. Des options peuvent être ajoutées pour modifier le comportement de la commande
+
+
+    \begin{center}
+        \begin{minipage}{0.5\linewidth}
+            \begin{minted}[bgcolor=base3]{bash}
+        commande -option1 -option2 ... arg1 arg2...
+            \end{minted}
+        \end{minipage}
+    \end{center}
+\end{definition}
+
+\subsection*{Mémo des commandes shell}
+
+\setlength{\columnseprule}{0pt}
+
+\begin{multicols}{2}
+    \begin{encadre}{\mintinline{bash}{ssh}}
+        \bigskip
+        \textbf{Description:} \dotfill \\[0.2cm] .\dotfill \\
+
+        \textbf{Exemples:}
+
+        \dotfill \\[0.2cm]
+        .\dotfill \\[0.2cm]
+        .\dotfill \\[0.2cm]
+        .\dotfill \\
+        \bigskip
+    \end{encadre}
+
+    \begin{encadre}{\mintinline{bash}{pwd}}
+        \bigskip
+        \textbf{Description:} \dotfill \\[0.2cm] .\dotfill \\
+
+        \textbf{Exemples:}
+
+        \dotfill \\[0.2cm]
+        .\dotfill \\[0.2cm]
+        .\dotfill \\[0.2cm]
+        .\dotfill \\
+        \bigskip
+    \end{encadre}
+
+    \begin{encadre}{\mintinline{bash}{cd [DOSSIER]}}
+        \bigskip
+        \textbf{Description:}
+        \dotfill \\[0.2cm]
+        .\dotfill \\
+
+        \textbf{Exemples:}
+        \begin{itemize}[leftmargin=*]
+            \item \dotfill
+            \item \dotfill
+            \item \dotfill
+            \item \dotfill
+        \end{itemize}
+        \bigskip
+    \end{encadre}
+
+    \begin{encadre}{\mintinline{bash}{tree [OPTION]... [DOSSIER]...}}
+        \bigskip
+        \textbf{Description:}
+        \dotfill \\[0.2cm]
+        .\dotfill \\
+
+        \textbf{Options courantes:}
+        \begin{itemize}[leftmargin=*]
+            \item \dotfill
+            \item \dotfill
+            \item \dotfill
+            \item \dotfill
+        \end{itemize}
+        \bigskip
+        \textbf{Exemples:}
+        \begin{itemize}[leftmargin=*]
+            \item \dotfill
+            \item \dotfill
+            \item \dotfill
+            \item \dotfill
+        \end{itemize}
+        \bigskip
+    \end{encadre}
+
+    \begin{encadre}{\mintinline{bash}{cat [OPTION]... [FICHIER]...}}
+        \bigskip
+        \textbf{Description:}
+        \dotfill \\[0.2cm]
+        .\dotfill \\
+
+        \textbf{Options courantes:}
+        \begin{itemize}[leftmargin=*]
+            \item \dotfill
+            \item \dotfill
+            \item \dotfill
+            \item \dotfill
+        \end{itemize}
+        \bigskip
+        \textbf{Exemples:}
+        \begin{itemize}[leftmargin=*]
+            \item \dotfill
+            \item \dotfill
+            \item \dotfill
+            \item \dotfill
+        \end{itemize}
+        \bigskip
+    \end{encadre}
+
+    \begin{encadre}{\mintinline{bash}{mv [OPTION]... [SOURCE] [CIBLE]}}
+        \bigskip
+        \textbf{Description:}
+        \dotfill \\[0.2cm]
+        .\dotfill \\
+
+        \textbf{Options courantes:}
+        \begin{itemize}[leftmargin=*]
+            \item \dotfill
+            \item \dotfill
+        \end{itemize}
+        \bigskip
+        \textbf{Exemples:}
+        \begin{itemize}[leftmargin=*]
+            \item \dotfill
+            \item \dotfill
+            \item \dotfill
+            \item \dotfill
+        \end{itemize}
+        \bigskip
+    \end{encadre}
+
+    \begin{encadre}{\mintinline{bash}{cp [OPTION]... [SOURCE] [CIBLE]}}
+        \bigskip
+        \textbf{Description:}
+        \dotfill \\[0.2cm]
+        .\dotfill \\
+
+        \textbf{Options courantes:}
+        \begin{itemize}[leftmargin=*]
+            \item \dotfill
+            \item \dotfill
+        \end{itemize}
+        \bigskip
+        \textbf{Exemples:}
+        \begin{itemize}[leftmargin=*]
+            \item \dotfill
+            \item \dotfill
+            \item \dotfill
+            \item \dotfill
+        \end{itemize}
+        \bigskip
+    \end{encadre}
+
+    \begin{encadre}{\mintinline{bash}{touch [FICHIER]...}}
+        \bigskip
+        \textbf{Description:}
+        \dotfill \\[0.2cm]
+        .\dotfill \\
+
+        \textbf{Exemples:}
+        \begin{itemize}[leftmargin=*]
+            \item \dotfill
+            \item \dotfill
+            \item \dotfill
+            \item \dotfill
+        \end{itemize}
+        \bigskip
+    \end{encadre}
+
+    \begin{encadre}{\mintinline{bash}{rm [OPTION]... [DOSSIER]...}}
+        \bigskip
+        \textbf{Description:}
+        \dotfill \\[0.2cm]
+        .\dotfill \\
+
+        \textbf{Options courantes:}
+        \begin{itemize}[leftmargin=*]
+            \item \dotfill
+            \item \dotfill
+            \item \dotfill
+        \end{itemize}
+        \bigskip
+        \textbf{Exemples:}
+        \begin{itemize}[leftmargin=*]
+            \item \dotfill
+            \item \dotfill
+            \item \dotfill
+            \item \dotfill
+        \end{itemize}
+        \bigskip
+    \end{encadre}
+
+    \begin{encadre}{\mintinline{bash}{mkdir [OPTION]... [DOSSIER]...}}
+        \bigskip
+        \textbf{Description:}
+        \dotfill \\[0.2cm]
+        .\dotfill \\
+
+        \textbf{Options courantes:}
+        \begin{itemize}[leftmargin=*]
+            \item \dotfill
+        \end{itemize}
+        \bigskip
+        \textbf{Exemples:}
+        \begin{itemize}[leftmargin=*]
+            \item \dotfill
+            \item \dotfill
+            \item \dotfill
+            \item \dotfill
+        \end{itemize}
+        \bigskip
+    \end{encadre}
+
+    \begin{encadre}{\mintinline{bash}{nano [FICHIER]...}}
+        \bigskip
+        \textbf{Description:}
+        \dotfill \\[0.2cm]
+        .\dotfill \\
+
+        \textbf{Exemples:}
+        \begin{itemize}[leftmargin=*]
+            \item \dotfill
+            \item \dotfill
+            \item \dotfill
+            \item \dotfill
+        \end{itemize}
+        \bigskip
+    \end{encadre}
+
+\end{multicols}
+
+\end{document}

1NSI/03_Systeme_dexploitation/3B_fichiers_permissions.tex

@@ -0,0 +1,174 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+\usepackage{minted}
+
+\author{Bertrand Benjamin}
+\title{Système d'exploitation - Cours}
+\date{octobre 2022}
+
+\pagestyle{empty}
+
+\begin{document}
+
+\maketitle
+
+\setcounter{section}{2}
+
+\section{Système de fichiers}
+
+\subsection{Arborescence et chemin}
+
+Sous les systèmes Linux les fichiers sont représentés sous forme d'arborescence dont voici un exemple ci-dessous.
+\begin{center}
+    \includegraphics[scale=0.7]{./fig/linux-fs}
+\end{center}
+
+Les fichiers sont repérés par leur \textbf{chemin}:
+\begin{itemize}
+    \item \textbf{absolu}: c'est à dire depuis la racine.
+    \item \textbf{relatif}: c'est à dire depuis le répertoire courant.
+\end{itemize}
+
+\paragraph{Exemple:}
+Supposons que l'on soit dans le répertoire \texttt{/home/user-1} de l'exemple précédent.
+
+\afaire{Donner le chemin relatif et absolu des fichiers \texttt{image.png} puis \texttt{fstab}}
+
+\paragraph{Exemple - correspondance URL et chemin de fichier:}
+Dans le configuration du serveur NSI, il y a une correspondance entre le chemin relatif des fichiers à partir de \texttt{public\_html} et l'url d'accès \url{http//192.168.221.206/~USER/}.
+
+Correspondance
+
+\begin{center}
+    \begin{tabular}{p{0.45\textwidth}|p{0.45\textwidth}}
+        Système de fichier & Url \\
+        \hline
+        \url{/home/USER/public_html/mapage.html} & \\
+        \hline
+                                                 & \url{http//192.168.221.206/~USER/asset/image.jpg} \\
+        \hline
+        \url{/home/USER/mapage.html} & \\
+        \hline
+                                                 & \url{http//192.168.221.206/~USER/../password} \\
+        \hline
+    \end{tabular}
+\end{center}
+
+\afaire{Compléter le tableau}
+
+\pagebreak
+
+\subsection{Droits et permissions}
+
+\begin{definition}[ Utilisateur et groupe ]
+    Linux est un système d'exploitation multi-utilisateur. C'est à dire qu'il est capable de faire cohabiter plusieurs utilisateurs et de leur donner des droits appropriés.
+
+    L'utilisateur \textbf{root} est le superutilisateur, il peut faire absolument tout ce qu'il veux sur le système. Les autres utilisateurs sont définis dans le fichier \url{/etc/passwd}.
+
+    Chaque utilisateur est membre d'un groupe. La liste des groupes est définis dans le fichier \url{/etc/group}. Pour connaître les groupes auquel on appartient, on peut utiliser la commande \mintinline{bash}{groups}.
+\end{definition}
+
+\begin{definition}[ Droits et permissions ]
+    Dans les systèmes de permission POSIX (Linux, BSD le sont), les éléments suivants sont attribués chaque fichier:
+    \begin{multicols}{2}
+        Trois catégories d'accès
+
+        \begin{itemize}
+            \item le propriétaire (ou \textit{owner}) noté \texttt{u}
+            \item le group (ou \textit{group}) noté \texttt{g}
+            \item les autres (ou \textit{other}) noté \texttt{o}
+        \end{itemize}
+
+        Trois niveaux d'accès
+        \begin{itemize}
+            \item lecture noté \texttt{r} (read)
+            \item écriture noté \texttt{w} (write)
+            \item exécution noté \texttt{x} (execute)
+        \end{itemize}
+    \end{multicols}
+
+    Ces attributs sont accessibles par la commande \mintinline{bash}{ls -l}.
+
+\end{definition}
+
+\paragraph{Exemple}
+
+    \begin{center}
+        \begin{minipage}{0.8\linewidth}
+            \inputminted[bgcolor=base3]{bash}{./annexes/3B_ls.shell}
+        \end{minipage}
+    \end{center}
+
+    \begin{multicols}{2}
+        Pour le fichier \texttt{config.yml}
+
+        \begin{center}
+            \begin{tabular}{|c|p{1cm}|c|c|c|}
+                \hline
+                & Qui & Lecture & Écriture & Execution \\
+                \hline
+                propriétaire & & & & \\
+                \hline
+                groupe & & & & \\
+                \hline
+                autres & & & & \\
+                \hline
+            \end{tabular}
+        \end{center}
+
+        Pour le fichier \texttt{script.sh}
+
+        \begin{center}
+            \begin{tabular}{|c|p{1cm}|c|c|c|}
+                \hline
+                & Qui & Lecture & Écriture & Exécution \\
+                \hline
+                propriétaire & & & & \\
+                \hline
+                groupe & & & & \\
+                \hline
+                autres & & & & \\
+                \hline
+            \end{tabular}
+        \end{center}
+    \end{multicols}
+
+    \afaire{compléter les tableaux}
+
+\paragraph{Remarque:} l'utilisateur \texttt{root} pourra toujours faire tout ce qu'il veut sur tous les fichiers.
+
+\subsection{Changer les droits}
+
+Pour changer le propriétaire d'un fichier, on utilise la commande
+
+    \begin{center}
+        \begin{minipage}{0.8\linewidth}
+            \inputminted[bgcolor=base3]{bash}{./annexes/3B_chown.shell}
+        \end{minipage}
+    \end{center}
+
+
+Pour changer les droits d'un fichier, on utilise la commande
+
+    \begin{center}
+        \begin{minipage}{0.8\linewidth}
+            \inputminted[bgcolor=base3]{bash}{./annexes/3B_chmod.shell}
+        \end{minipage}
+    \end{center}
+
+\paragraph{Exemples}
+\begin{enumerate}
+    \item Commande ajoutant les droits d'écriture au groupe. \\
+
+    \item Commande enlevant les droits d'écriture et de lecture aux autres. \\
+
+    \item Commande enlevant les droits de lecture au groupe et aux autres. \\
+\end{enumerate}
+
+\afaire{Proposer une commande}
+
+\paragraph{Remarque:} l'option \texttt{-R} permet d'appliquer la règle à tous les fichiers contenus dans un répertoire.
+
+
+
+\end{document}

1NSI/03_Systeme_dexploitation/annexes/3B_chmod.shell

@@ -0,0 +1 @@
+chmod [ugo][+-=][rwx] fichier

1NSI/03_Systeme_dexploitation/annexes/3B_chown.shell

@@ -0,0 +1 @@
+chown [PROPRIO][:GROUP] fichier

1NSI/03_Systeme_dexploitation/annexes/3B_ls.shell

@@ -0,0 +1,6 @@
+user@server:$ ls -l
+-rw-r--r-- 1 Me   users   21  7 sept. 21:25 config.yml
+-rw-r--r-- 1 Me   users 1037 20 oct.  10:54 docker-compose.yml
+drwxr-xr-x 2 root root  4096  7 sept. 18:13 log
+-rw-r--r-- 1 Me   users  486  7 sept. 18:14 traefik.yml
+-rwxrx-r-- 1 Me   users  486  7 sept. 18:14 script.sh

1NSI/03_Systeme_dexploitation/annexes/TP_inter1.shell

@@ -0,0 +1,2 @@
+user@server:$ cd ~/TP_interaction
+user@server:$ tree

1NSI/03_Systeme_dexploitation/annexes/droit-ls.shell

@@ -0,0 +1,6 @@
+user@server:$ ls -l
+-rwxrwxr-- 1 admin users        2  6 juin  06:19 automations.sh
+-rw-r--r-- 1 admin users      600  3 nov.  20:58 configuration.yaml
+drwxr-xr-x 2 admin users     4096  6 juin  06:19 deps
+-rw-r--r-- 1 root  root       474  3 nov.  20:59 home-assistant.log
+-rwxrw-r-- 1 root  root         0  3 nov.  20:58 home-assistant.sh

1NSI/03_Systeme_dexploitation/annexes/globbing.shell

@@ -0,0 +1,3 @@
+user@server:$ ls *.png
+user@server:$ ls *.html
+user@server:$ ls image1.*

1NSI/03_Systeme_dexploitation/annexes/globbing_consigne.shell

@@ -0,0 +1,2 @@
+user@server:$ touch image{1,2,3}.{png,jpg,jpeg}
+user@server:$ touch page_{1,2,3,4}.html

1NSI/03_Systeme_dexploitation/annexes/nav_virtu.shell

@@ -0,0 +1,24 @@
+user@server:$ pwd
+/home/user
+user@server:$ ls
+Desktop      Documents       Download     Pictures      Scripts
+user@server:$ cd Documents
+user@server:$ ls -l
+drwxr-xr-x 2 user users     4096  3 sept. 17:22  computing-fundamentals1
+drwxr-xr-x 2 user users     4096  3 sept. 17:23  computing-fundamentals2
+-rwxr-xr-x 2 user users     4096  3 sept. 17:23  notes.txt
+user@server:$ cd ../Scripts
+user@server:$ ls -l
+drwxr-xr-x 2 user users     4096  3 sept. 17:22  beGood
+drwxr-xr-x 2 user users     4096  3 sept. 17:23  WinAll
+-rwxr-xr-x 2 user users     4096  3 sept. 17:23  cheat.doc
+-rwxr-xr-x 2 user users     4096  3 sept. 17:23  ex1.py
+-rwxr-xr-x 2 user users     4096  3 sept. 17:23  index.html
+user@server:$ cd ../../
+user@server:$ ls
+Dan        Foo       user
+user@server:$ ls -a user/Pictures/
+.      ..      Vacances     Famille         2022star.png
+user@server:$ ls -a ~/
+.           ..           .bashrc      .cache        .config
+Desktop     Documents    Download     Pictures      Scripts

1NSI/03_Systeme_dexploitation/annexes/qcm-5.shell

@@ -0,0 +1,3 @@
+cd ~
+cd seances/tp
+mv exercice.txt ./../../exercice.txt

1NSI/03_Systeme_dexploitation/exercises.tex

@@ -0,0 +1,367 @@
+\begin{exercise}[subtitle={Classe renversée}, step={1}, origin={Ma tête}, topics={ Système d'exploitation }, tags={ Linux }, mode={\groupMode}]
+    Faire des recherches, préparer une diapositive puis faire la présentation de votre réponse à une des questions suivantes
+    \begin{multicols}{2}
+        \begin{enumerate}
+            \item À quoi sert un système d'exploitation ?
+            \item Quels sont les principaux systèmes d'exploitations et quels sont les liens historiques entre eux?
+            \item Expliquer ce qu'est un logiciel libre, un logiciel propriétaire et un logiciel gratuit.
+            \item Comment sont organisés les fichiers sous Linux?
+        \end{enumerate}
+    \end{multicols}
+\end{exercise}
+
+% ----------
+% Étape 2
+
+\begin{exercise}[subtitle={TP - navigation}, step={2}, origin={<++>}, topics={ Système d'exploitation }, tags={ Linux }, mode={\infoMode}]
+    Dans ce TP, nous allons nous déplacer et explorer le serveur où vous aviez déposé vos pages webs. Vous profiterez de ce TP pour compléter le mémo du cours.
+    \begin{enumerate}
+        \item \textbf{Connexion au serveur}
+        \item \textbf{Où suis-je ?} La commande \mintinline{bash}{pwd} permet de savoir quel est répertoire nous sommes. Exécuter cette commande, noter le résultat et reconnaître les différents éléments qui le composent.
+        \item \textbf{Que fais-je ?} Pour obtenir de l'aide, vous pouvez accéder au manuel des commandes. Pour cela, vous avez deux possibilités (qui dépendent de l'environnement Linux) :
+            \begin{itemize}
+                \item Exécuter \mintinline{bash}{man command}.
+                \item Exécuter \mintinline{bash}{command --help}.
+            \end{itemize}
+            Aller chercher l'aide de la commande \mintinline{bash}{pwd} pour compléter le mémo. Vous devrez par la suite explorer le manuel des commandes pour chercher le comportement voulu.
+        \item \textbf{Qu'y a-t-il ?} Pour lister les fichiers et dossiers du répertoire d'un répertoire, on utilise la commande \mintinline{bash}{ls}.
+            \begin{enumerate}
+                \item Lister le contenu du répertoire.
+                \item Lister le contenu du répertoire avec l'option \mintinline{bash}{-a}. Quel différence y a-t-il avec le résultat sans cette option?
+                \item Lister le contenu du répertoire avec l'option \mintinline{bash}{-l}. Noter les informations obtenus.
+                \item Lister le contenu du répertoire \texttt{public\_html}.
+            \end{enumerate}
+            On peut aussi utiliser la commande \mintinline{bash}{tree} qui liste les fichiers et dossiers sous forme d'arbre.
+            \begin{enumerate}
+                \setcounter{enumi}{4}
+                \item Exécuter la commande \mintinline{bash}{tree}.
+                \item Exécuter la commande \mintinline{bash}{tree} avec l'option \mintinline{bash}{-L 1} puis \mintinline{bash}{-L 2}. Que permet de faire cette option?
+            \end{enumerate}
+        \item \textbf{Où vais-je ?} Pour se déplacer, on utilisera la commande \mintinline{bash}{cd}.
+            \begin{enumerate}
+                \item Afficher le répertoire courant. Se déplacer dans le répertoire \texttt{public\_html}. Puis afficher à nouveau le répertoire courant.
+                \item Exécuter \mintinline{bash}{cd ../} puis afficher le répertoire courant. Que s'est-il passé ?
+                \item Recommencer l'opération. Afficher le répertoire courant et lister le contenu du répertoire. Que voyez-vous?
+                \item Recommencer encore une fois l'opération.
+                \item Exécuter \mintinline{bash}{cd ~}. Où êtes vous?
+                \item Exécuter \mintinline{bash}{cd ../../}. Où êtes vous?
+            \end{enumerate}
+    \end{enumerate}
+\end{exercise}
+
+\begin{exercise}[subtitle={Navigation virtuelle}, step={2}, origin={<++>}, topics={ Système d'exploitation }, tags={ Linux }, mode={\paperMode}]
+    Ci-dessous, vous trouverez un enchainement de commandes shells avec les sorties. Vous devrez dessiner l'arborescence correspondante (les dossiers seront dans des rectangles et les fichiers dans des ovales) et indiquer en bleu les déplacements réalisés.
+
+    \begin{center}
+        \begin{minipage}{0.8\linewidth}
+            \inputminted[bgcolor=base3]{bash}{./annexes/nav_virtu.shell}
+        \end{minipage}
+    \end{center}
+\end{exercise}
+% ----------
+% Étape 3
+
+\begin{exercise}[subtitle={TP - interaction}, step={3}, origin={<++>}, topics={ Système d'exploitation }, tags={ Linux }, mode={\computerMode}]
+    Dans ce TP, nous allons nous interagir avec le système de fichier. Vous profiterez de ce TP pour compléter le mémo du cours.
+    \begin{enumerate}
+        \item Connecter vous au serveur et assurez vous que vous êtes bien dans votre répertoire personnel.
+        \item \textbf{Créer des dossiers} avec la commande \mintinline{bash}{mkdir}
+            \begin{enumerate}
+                \item Créer un dossier \texttt{TP\_interaction} puis se déplacer dedans.
+                \item Créer les dossiers \texttt{boulot} \texttt{trash} et \texttt{sauvegarde}.
+            \end{enumerate}
+        \item \textbf{Créer un fichier (vide)} avec la commande \mintinline{bash}{touch}
+            \begin{enumerate}
+                \item Dans le répertoire \texttt{boulot} créer les fichiers vides suivants
+                    \begin{center}
+                        \texttt{ex1.py} \qquad \texttt{index.html} \qquad \texttt{style.css} \qquad ex2.py
+                    \end{center}
+                \item Dans ce même répertoire, créer un dossier \texttt{assets} pour y placer un fichier nommé \texttt{image.png}
+                \item Pour vérifier que tout a été bien fait, en exécutant ces deux commandes, vous devriez avoir le résultat suivant:
+                    \begin{center}
+                        \begin{minipage}{0.8\linewidth}
+                            \VerbatimInput{annexes/TP_inter1.shell}
+                            \includegraphics[scale=0.6]{./fig/TP_interaction_tree1}
+                        \end{minipage}
+                    \end{center}
+            \end{enumerate}
+        \item \textbf{Supprimer des fichiers} avec la commande \mintinline{bash}{rm}
+            \begin{enumerate}
+                \item Supprimer les fichiers \texttt{ex1.py} et \texttt{ex2.py}
+                \item Supprimer le dossier \texttt{trash}. Pour cela vous aurez besoin de passer l'option \texttt{-r} pour autoriser la suppression de dossiers.
+            \end{enumerate}
+        \item \textbf{Copier des fichiers} avec la commande \mintinline{bash}{cp}
+            \begin{enumerate}
+                \item Copier le fichier \texttt{index.html} dans le même répertoire avec le nom \texttt{page1.html}
+                \item Copier le fichier \texttt{index.html} dans le répertoire \texttt{sauvegarde} en conservant le même nom.
+                \item Copier tout le dossier \texttt{boulot} dans le répertoire \texttt{sauvegarde}. Vous aurez besoin d'ajouter l'option \texttt{-r} pour autoriser la copie de dossier de façon récursive.
+                \item Pour vérifier que tout a été bien fait, en exécutant ces deux commandes, vous devriez avoir le résultat suivant:
+                    \begin{center}
+                        \begin{minipage}{0.8\linewidth}
+                            \VerbatimInput{annexes/TP_inter1.shell}
+                            \includegraphics[scale=0.6]{./fig/TP_interaction_tree2}
+                        \end{minipage}
+                    \end{center}
+            \end{enumerate}
+        \item \textbf{Renommer/déplacer des fichiers} avec la commande \mintinline{bash}{mv}
+            \begin{enumerate}
+                \item Déplacer le fichier \texttt{page1.html} vers \texttt{home.html}
+                \item Renommer le dossier \texttt{boulot} en \texttt{pageweb}
+                \item Pour vérifier que tout a été bien fait, en exécutant ces deux commandes, vous devriez avoir le résultat suivant:
+                    \begin{center}
+                        \begin{minipage}{0.8\linewidth}
+                            \VerbatimInput{annexes/TP_inter1.shell}
+                            \includegraphics[scale=0.6]{./fig/TP_interaction_tree3}
+                        \end{minipage}
+                    \end{center}
+            \end{enumerate}
+        \item \textbf{Éditer un fichier} avec la commande \mintinline{bash}{nano}.
+
+            Mettre une balise \texttt{h1} avec le titre de votre choix dans le fichier \texttt{index.html}
+    \end{enumerate}
+\end{exercise}
+
+\begin{exercise}[subtitle={Europe}, step={3}, origin={Parlez-vous Shell ? de Thomas Hugel chez Ellipses}, topics={ Système d'exploitation }, tags={ Linux }, mode={\computerMode}]
+    On se place dans le répertoire personnel de l'utilisateur représenté par le raccourci ~.
+
+    \begin{enumerate}
+        \item Dans son répertoire personnel, créer le répertoire ̀̀TP-SHELL puis entrer dans ce répertoire.
+        \item Créer le répertoire Europe et changer de répertoire courant pour Europe.
+        \item Écrire une suite de commandes qui permet de construire l'arborescence ci-dessous sans quitter le répertoire Europe. Les fichiers apparaissant avec des rectangles sont des répertoires et les autres sont des fichiers.
+            \begin{center}
+                \includegraphics[scale=0.4]{./fig/graphe-europe}
+            \end{center}
+
+        \item Créer dans ~/TP-SHELL une copie de tout le répertoire Europe avec ses sous-répertoires et nommer cette copie Vieille-Europe. Les modifications qui suivent devront être faites dans Europe.
+        \item Appliquons le traité de Francfort de 1871. Se placer dans le répertoire Prusse et déplacer Belfort dans France puis déplacer Alsace dans Prusse. Revenir dans Europe et renommer Prusseen Allemagne.
+        \item Depuis Europe, afficher le contenu de Bordeaux puis détruire ce fichier.
+        \item Appliquons le traité de Versailles de 1919. Depuis France, ramener Alsace en France puis détruire Vieille-Europe.
+    \end{enumerate}
+\end{exercise}
+
+\begin{exercise}[subtitle={Expansion des nom, globbing}, step={3}, origin={<++>}, topics={ Système d'exploitation }, tags={ Linux }, mode={\computerMode}]
+    \begin{enumerate}
+        \item \textbf{Mise en place} créer un dossier \texttt{globbing}, exécuter la commande suivante (vous n'avez pas à la comprendre) puis afficher la liste des fichiers :
+            \begin{center}
+                \begin{minipage}{0.8\linewidth}
+                    \inputminted[bgcolor=base3]{bash}{./annexes/globbing_consigne.shell}
+                \end{minipage}
+            \end{center}
+        \item Exécuter les commandes suivantes et noter le résultat.
+            \begin{center}
+                \begin{minipage}{0.8\linewidth}
+                    \inputminted[bgcolor=base3]{bash}{./annexes/globbing.shell}
+                \end{minipage}
+            \end{center}
+        \item Que représente l'opérateur \texttt{*} ?
+        \item Écrire une commande qui affiche les éléments suivants
+            \begin{multicols}{2}
+                \begin{enumerate}[leftmargin=*]
+                    \item Tous les fichiers qui se terminent pas la lettre g.
+                    \item Tous les fichiers jpg et jpeg.
+                    \item Tous les fichiers avec un 1 dans le nom.
+                    \item Tous les fichiers qui commencent par la lettre p.
+                \end{enumerate}
+            \end{multicols}
+    \end{enumerate}
+\end{exercise}
+% ----------
+% Étape 4
+
+\begin{exercise}[subtitle={Lecture des droits}, step={4}, origin={<++>}, topics={ Système d'exploitation }, tags={ Linux }, mode={\paperMode}]
+    Décrire les droits des fichiers listés par la commande \mintinline{bash}{ls -l} sous forme d'un tableau.
+    \begin{center}
+        \begin{minipage}{0.8\linewidth}
+            \inputminted[bgcolor=base3]{bash}{./annexes/droit-ls.shell}
+        \end{minipage}
+    \end{center}
+\end{exercise}
+
+\begin{exercise}[subtitle={Attribution des droits}, step={4}, origin={<++>}, topics={ Système d'exploitation }, tags={ Linux }, mode={\paperMode}]
+    L'utilisateur \textbf{root} a créé un fichier \url{monscript.py}. Il veut attribuer des droits sur ce fichier. Quel commande doit-il taper pour attribuer les droits dans l'ordre suivant:
+    \begin{enumerate}
+        \item Le fichier doit appartenir à l'utilisateur \textbf{admin} et au groupe \textbf{wheel}.
+        \item L'utilisateur a le droit de lire, écrire et exécuter le fichier.
+        \item Le groupe a le droit de lire et écrire sur le fichier mais pas de l'exécuter.
+        \item Les autres auront juste le droit de le lire.
+    \end{enumerate}
+\end{exercise}
+
+
+
+% ----------
+% Étape 4
+
+\begin{exercise}[subtitle={QCM type E3C}, step={5}, origin={https://gitlab.com/frederic-junier/parc-nsi/-/blob/master/docs/chapitre9/TP2/NSI-TP2-systeme-git.md}, topics={ Système d'exploitation }, tags={ Linux }, mode={\trainMode}]
+
+\begin{multicols}{2}
+    \begin{enumerate}[leftmargin=*]
+        \item Dans un système Linux, on dispose d'un répertoire racine contenant deux répertoires \url{documents` et `sauvegardes}. On se trouve dans le répertoire documents où figure un fichier \url{NSI.txt}.
+
+            Quelle commande permet de créer une copie nommée \url{NSI2.txt} de ce fichier dans le répertoire sauvegardes ?
+
+            \textbf{Réponses}
+            \begin{enumerate}
+
+                \item \mintinline{bash}{cp NSI.txt NSI2.txt}
+
+                \item \mintinline{bash}{cp NSI.txt sauvegardes/NSI2.txt}
+
+                \item \mintinline{bash}{cp NSI.txt ../NSI2.txt}
+
+                \item \mintinline{bash}{cp NSI.txt ../sauvegardes/NSI2.txt}
+            \end{enumerate}
+
+        \item À partir du dossier \url{~/Doc/QCM}, quelle commande permet de rejoindre le
+            dossier \url{~/Hack/Reponses} ?
+
+            \textbf{Réponses}
+
+            \begin{enumerate}
+                \item \mintinline{bash}{cd Hack/Reponses}
+
+                \item \mintinline{bash}{cd /Hack/Reponses}
+
+                \item \mintinline{bash}{cd ~/Hack/Reponses}
+
+                \item \mintinline{bash}{cd ../../Hack/Reponses}
+            \end{enumerate}
+
+        \item Sous Linux, les droits d'accès à un fichier dont le propriétaire est
+            Joseph sont les suivants : \mintinline{bash}{-rwxr-xr--}
+
+            Laquelle des affirmations suivantes est **fausse** ?
+
+            \textbf{Réponses}
+
+            \begin{enumerate}
+
+                \item Joseph a l'autorisation de lire ce fichier
+
+                \item  les membres du groupe de Joseph ont l'autorisation de lire ce fichier
+
+                \item tous les utilisateurs ont l'autorisation de lire ce fichier
+
+                \item les membres du groupe de Joseph ont l'autorisation de modifier ce
+                    fichier
+            \end{enumerate}
+
+        \item Dans la console Linux, quelle commande faut-il exécuter pour effacer le
+            fichier \url{test0.csv} ?
+
+            \textbf{Réponses}
+
+            \begin{enumerate}
+                \item  \mintinline{bash}{rm test0.csv}
+
+                \item \mintinline{bash}{cp test0.csv}
+
+                \item \mintinline{bash}{ls test0.csv}
+
+                \item  \mintinline{bash}{mv test0.csv}
+
+            \end{enumerate}
+
+        \item Dans un terminal, on exécute la suite de commandes système suivante :
+
+            \inputminted[bgcolor=base3]{bash}{./annexes/qcm-5.shell}
+
+            Où se trouve finalement placé le fichier exercice.txt ?
+
+            \textbf{Réponses}
+
+            \begin{enumerate}
+                \item dans le répertoire \mintinline{bash}{~/seance/tp}
+
+                \item dans le répertoire \mintinline{bash}{~/seance}
+
+                \item dans le répertoire \mintinline{bash}{~}
+
+                \item dans le répertoire \mintinline{bash}{/home}
+            \end{enumerate}
+
+
+        \item Pour renommer un fichier \url{text1.txt} en \url{text1.old} dans un même répertoire,
+            quelle commande faut-il utiliser ?
+
+            \textbf{Réponses}
+
+            \begin{enumerate}
+                \item \mintinline{bash}{mv text1.txt ../text1.old}
+
+                \item \mintinline{bash}{mv text1.txt text1.old}
+
+                \item \mintinline{bash}{cp text1.txt text1.old}
+
+                \item \mintinline{bash}{lns text1.txt text1.old}
+            \end{enumerate}
+
+        \item Sous Unix, que fait la commande suivante ?  \mintinline{bash}{ls --a /home/pi >> toto.txt}
+
+            \textbf{Réponses}
+
+            \begin{enumerate}
+                \item elle liste uniquement les répertoires cachés du répertoire /home/pi
+
+                \item elle liste tous les fichiers du répertoire /home/pi et enregistre le
+                    résultat dans un fichier toto.txt
+
+                \item elle liste tous les fichiers des répertoires de /home/pi et de
+                    toto.txt
+
+                \item elle liste tous les fichiers du répertoire courant et enregistre le
+                    résultat dans un fichier /home/pi/toto.txt
+            \end{enumerate}
+
+        \item Par quelle ligne de commande peut-on créer, sous le système
+            d'exploitation Linux, trois répertoires nommés : JAVA, PYTHON et PHP ?
+
+            \textbf{Réponses}
+
+            \begin{enumerate}
+                \item  \mintinline{bash}{mkdir JAVA, PYTHON, PHP}
+
+                \item  \mintinline{bash}{mk -dir JAVA PYTHON PHP}
+
+                \item  \mintinline{bash}{mkdir JAVA PYTHON PHP}
+
+                \item  \mintinline{bash}{mk dir JAVA PYTHON PHP}
+            \end{enumerate}
+
+
+        \item À partir du répertoire \url{~/Perso/Doc} quelle commande permet de rejoindre
+            le répertoire \url{~/Public} ?
+
+            \textbf{Réponses}
+
+            \begin{enumerate}
+                \item \mintinline{bash}{cd ./Public}
+
+                \item \mintinline{bash}{cd ../Public}
+
+                \item \mintinline{bash}{cd ././Public}
+
+                \item \mintinline{bash}{cd ../../Public}
+            \end{enumerate}
+
+        \item  Dans la console Linux, quelle commande faut-il exécuter pour obtenir la
+            documentation sur la commande \mintinline{bash}{pwd} ?
+
+            \textbf{Réponses}
+
+            \begin{enumerate}
+                \item \mintinline{bash}{pwd}
+
+                \item \mintinline{bash}{cd pwd}
+
+                \item \mintinline{bash}{mkdir pwd}
+
+                \item \mintinline{bash}{pwd --help}
+            \end{enumerate}
+    \end{enumerate}
+\end{multicols}
+\end{exercise}
+
+\begin{exercise}[subtitle={Hacking}, step={5}, origin={<++>}, topics={ Système d'exploitation }, tags={ Linux }, mode={\groupMode}]
+    Surprise si j'y arrive!
+\end{exercise}

1NSI/03_Systeme_dexploitation/index.rst

@@ -0,0 +1,86 @@
+Système d'exploitation
+######################
+
+:date: 2022-10-29
+:modified: 2022-11-03
+:authors: Benjamin Bertrand
+:tags: Linux
+:category: 1NSI
+:summary: Les systèmes d'exploitation et ligne de commande
+
+Elements du programme
+=====================
+
+.. list-table:: Architectures matérielles et systèmes d’exploitation
+    :header-rows: 1
+
+    * - Contenus
+      - Capacités attendues
+      - Commentaires
+    * - Systèmes d'exploitation
+      - Identifier les fonctions d’un système d’exploitation. Utiliser les commandes de base en ligne de commande. Gérer les droits et permissions d’accès aux fichiers.
+      - Les différences entre systèmes d’exploitation libres et propriétaires sont évoquées. Les élèves utilisent un système d’exploitation libre. Il ne s’agit pas d’une étude théorique des systèmes
+
+
+Progression
+===========
+
+Plan de travail
+
+.. image:: ./plan_de_travail.pdf
+    :height: 200px
+    :alt: Plan de travail
+
+
+Étape 1: système d'exploitation, classe renversée
+-------------------------------------------------
+
+Questions pour les élèves
+
+- À quoi sert un système d'exploitation ?
+- Quels sont les principaux systèmes d'exploitations et quels sont leurs liens historiques ?
+- Différences entre logiciel libre et logiciel propriétaires.
+- Il me faut une 4e question
+
+Les élèves cherchent à la maison des réponses à ces questions. En classe et en groupe, ils font une synthèse, préparent une diapo puis présentent leur réponse à l'oral.
+
+Le bilan se fera à partir des diapos commentées et complétées.
+
+Étape 2: Ligne de commande: Navigation
+--------------------------------------
+
+Cours: anatomie d'une commande shell
+
+.. image:: ./2B_command_memo.pdf
+    :height: 200px
+    :alt: Commande linux
+
+TP: dans les TPs (navigation, interaction et droits) de découverte  de quelques commandes shell, les élèves seront amenés à compléter une fiche mémo sur les commandes: leur fonction, les arguments et quelques options.
+
+Commandes vues dans le TP navigation:
+
+    ssh ls pwd tree cd
+
+Bilan: mise en commun du mémo, représentation de l'arborescence de fichiers, système de fichiers Linux.
+
+Exercices techniques sur ordinateur ou au papier.
+
+Étape 3: Ligne de commande: interaction
+---------------------------------------
+
+Commandes vues dans le TP navigation:
+
+    cat touch mkdir cp mv nano
+
+Bilan: mise en commun de la fiche mémo
+
+Exercices techniques sur ordinateur ou au papier.
+
+Étape 4: Gérer les droits
+-------------------------
+
+Cours: arborescence et permissions
+
+.. image:: ./3B_fichiers_permissions.pdf
+    :height: 200px
+    :alt: arborescence et permissions

1NSI/03_Systeme_dexploitation/plan_de_travail.tex

@@ -0,0 +1,58 @@
+\documentclass[a4paper,12pt]{article}
+\usepackage{myXsim}
+\usepackage{minted}
+
+\author{Benjamin Bertrand}
+\title{Système d'exploitation - Plan de travail}
+\tribe{1NSI}
+\date{octobre 2022}
+
+\pagestyle{empty}
+
+\DeclareExerciseCollection{banque}
+\xsimsetup{
+}
+
+
+\begin{document}
+\maketitle
+
+% Résumé
+
+\bigskip
+
+Savoir-faire de la séquence
+\begin{itemize}
+    \item Identifier les fonctions d’un système d’exploitation.
+    \item Utiliser les commandes de base en ligne de commande.
+    \item Gérer les droits et permissions d’accès aux fichiers.
+\end{itemize}
+
+
+\section{Système d'exploitation}
+
+\listsectionexercises
+
+\section{Navigation en ligne de commande}
+
+\listsectionexercises
+
+\section{Interactions en ligne de commande}
+
+\listsectionexercises
+
+\section{Gestion des droits}
+
+\listsectionexercises
+
+\section{Tout ensemble}
+
+\listsectionexercises
+
+
+\pagebreak
+
+\input{exercises.tex}
+\printcollection{banque}
+
+\end{document}

1NSI/03_Systeme_dexploitation/solutions.tex

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

1NSI/04_Fonctions_specifications_et_tests/1B_fonctions.tex

@@ -0,0 +1,112 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+\usepackage{minted}
+
+\author{Benjamin Bertrand}
+\title{Fonctions spécifications et tests - Cours}
+\date{décembre 2022}
+
+\pagestyle{empty}
+
+\begin{document}
+
+\maketitle
+
+\section{Les fonctions}
+
+\begin{definition}[Les fonctions]
+
+    \textbf{Les fonctions} sont des séries de blocs d'instructions que l'on souhaite isoler et réutiliser. Elles permettent de \textbf{factoriser} des instructions et, quand elles sont bien nommées, donner des informations sur l'intention du programmeur.
+
+    En Python, les fonctions ont la forme suivante
+
+    \begin{center}
+        \begin{minipage}{0.5\linewidth}
+            \begin{minted}[bgcolor=base3,linenos]{python}
+def nom_de_la_fonction(argument1, argument2, ...):
+    instruction 1
+    instruction 2
+    instruction 3
+    ...
+    return valeur
+            \end{minted}
+        \end{minipage}
+    \end{center}
+
+    Le mot clé \mintinline{python}{return} permet de renseigner la valeur que la fonction retournera après son exécution. L'exécution de la fonction s'arrêtera au premier \mintinline{python}{return} rencontré. Si aucun \mintinline{python}{return} la fonction ne renverra aucune valeur, mais toutes les instructions s'exécuteront.
+
+    Si une variable est définie dans une fonction, on ne pourra pas accéder à sa valeur en dehors sauf si elle retournée.
+\end{definition}
+
+\paragraph{Exemples}
+
+\begin{multicols}{1}
+    \begin{itemize}
+        \item Fonction qui calcule les coordonnées d'un vecteur
+
+                \begin{minipage}{0.9\linewidth}
+                    \begin{minted}[bgcolor=base3,linenos]{python}
+def coord_vecteur(xA, xB, yA, yB):
+    x = xB - xA
+    y = yB - yA
+    return x, y
+
+print(coord_vecteur(1, 2, 3, 4))
+xAB, yAB = coord_vecteur(12, 34, 23, 15)
+
+                    \end{minted}
+                \end{minipage}
+
+        \columnbreak
+
+        \item Fonction qui teste si un mot de passe est valide
+
+            \begin{center}
+                \begin{minipage}{0.9\linewidth}
+                    \begin{minted}[bgcolor=base3,linenos]{python}
+mdp = "NSI"
+def pass_est_valid(password):
+    if password == mpd:
+        return True
+
+    print("Mot de passe invalide")
+    return False
+
+acces = pass_est_valid("plop")
+acces2 = pass_est_valid("NSI")
+print(acces)
+print(accesé)
+                    \end{minted}
+                \end{minipage}
+            \end{center}
+    \end{itemize}
+\end{multicols}
+
+\bigskip
+
+\begin{itemize}
+    \item Fonction qui décore du texte
+
+        \begin{center}
+            \begin{minipage}{0.6\linewidth}
+                \begin{minted}[bgcolor=base3,linenos]{python}
+def decor_pyramide(texte, symbole):
+    chapeau = ""
+    for i in range(len(texte)):
+        chapeau = chapeau + symbole*(i+1) + "\n"
+
+    bas = ""
+    for i in range(len(texte)):
+        chapeau = chapeau + symbole*(len(texte)-i) + "\n"
+
+    return chapeau + "\n" + texte + "\n" + bas
+
+decoration = decor_pyramide("NSI", "#")
+print(decoration)
+print(chapeau)
+                \end{minted}
+            \end{minipage}
+        \end{center}
+\end{itemize}
+
+\end{document}

1NSI/04_Fonctions_specifications_et_tests/1E_fonctions_de_decorations.ipynb

@@ -0,0 +1,471 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "e51b69a2",
+   "metadata": {},
+   "source": [
+    "# Fonctions python pour décorer du texte\n",
+    "\n",
+    "Dans ce TP, vous allez voir plus en précision la manipulation des chaines de caractère en python et surtout apprendre à manipuler une nouveau concept `les fonctions` en python.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3b934b68",
+   "metadata": {},
+   "source": [
+    "## Décorer du texte: manipulation des str (strings)\n",
+    "\n",
+    "Vous avez déjà vu que les opérations en python n'avait pas le même effets en fonction de type de données sur lesquels elles opéraient.\n",
+    "\n",
+    "1. Pour tous les cas suivants, faire des tests pour décrire l'effet des opérations suivantes\n",
+    "\n",
+    "Ci-dessous vous trouverez quelques chaines de caractères pour faire vos tests. N'hésitez pas à en ajouter d'autres qui vous semblent appropriés."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "5779596e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chaine1 = \"Bonjour \"\n",
+    "chaine2 = \"42\"\n",
+    "chaine3 = \"10.23\"\n",
+    "chaine4 = \"#\"\n",
+    "chaine5 = \"Bonjour\\nComment vas-tu?\\nBien et toi?\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f5ca828f",
+   "metadata": {},
+   "source": [
+    "a) L'opération `+` sur deux chaines de caractères"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "181cceef",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# à compléter"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5907fa80",
+   "metadata": {},
+   "source": [
+    "Description"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1cad7007",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b0d5fa55",
+   "metadata": {},
+   "source": [
+    "b) L'opération `*` entre une chaine de caractères et un entier"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "21c1972e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# à compléter"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9b1b85df",
+   "metadata": {},
+   "source": [
+    "Description"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fc031ece",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b55bf1d9",
+   "metadata": {},
+   "source": [
+    "c) Les opérations `-`, `/` sur deux chaines de caractères"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4184cd65",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "531763ec",
+   "metadata": {},
+   "source": [
+    "d) La fonction `len(...)` sur une chaine de caractère"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "399fd2a6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# à compléter"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "38eb7527",
+   "metadata": {},
+   "source": [
+    "Description"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5112faa0",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "52d39bc2",
+   "metadata": {},
+   "source": [
+    "2. Compléter le programme suivante pour qu'il affiche le texte contenu dans la variable `texte` entouré de 4 symboles `*` avant et apprès."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "886e910c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "texte = \"Menu du repas de midi\"\n",
+    "# à compléter"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "41cd3376",
+   "metadata": {},
+   "source": [
+    "3. Compléter le programme suivant pour qu'il affiche le texte contenu dans la variable `texte` souligné avec le symbole `-` sur toute la longueure"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d3d0808e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "texte = \"Titre de mon roman\"\n",
+    "# à compléter\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "000c2e59",
+   "metadata": {},
+   "source": [
+    "4. Comment fait-on pour ajouter un saut de ligne dans une chaine de caractère?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "66a9c657",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c8a1df85",
+   "metadata": {},
+   "source": [
+    "## Les fonctions\n",
+    "\n",
+    "Quand on écrit des programmes, nous avons souvent besoin de réutiliser des morceaux de code à plusieurs endroits. Afin d'éviter un copié collé, il plus interessant d'utiliser une `fonction` qui contiendra les instructions répétées.\n",
+    "\n",
+    "Le code sera alors factorisé (une partie servira à plusieurs endroit), plus clair à lire et plus simple à utiliser.\n",
+    "\n",
+    "Ci-dessous, vous trouverez une fonction qui entoure un texte avec 4 symboles avant et après."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "81a9ed1d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def entoure4(texte, symbole):\n",
+    "    avant = symbole * 4\n",
+    "    apres = symbole * 4\n",
+    "    return avant + texte + apres"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "23ede0b2",
+   "metadata": {},
+   "source": [
+    "Quand vous avez validé ce code, a priori rien ne s'est passé. Mais en réalité, vous avez ajouter une nouvelle \"capacité\" au language python sous le mot clé `entoure4`.\n",
+    "\n",
+    "Vous pouvez alors l'utiliser de la manière suivante"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "5c256888",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "~~~~Bonjour~~~~\n",
+      "--------blablabla--------\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(entoure4(\"Bonjour\", \"~\"))\n",
+    "print(entoure4(\"blablabla\", \"--\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "37acfeea",
+   "metadata": {},
+   "source": [
+    "1. Utiliser la fonction `entoure4` pour entourer le texte \"NSI\" avec des \"<3\"."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bd3c1dbc",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7e45aeb1",
+   "metadata": {},
+   "source": [
+    "2. Décrire les mots clés et la structure pour définir une fonction."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "722f901b",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "23bb82d0",
+   "metadata": {},
+   "source": [
+    "3. Ecrire puis tester une fonction qui va ajouter 5 symboles avant un texte."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "79b19741",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c2826872",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f8a6cfb0",
+   "metadata": {},
+   "source": [
+    "4. Ecrire puis tester une fonction qui va souligné un texte avec le sympbole `-`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ede2aa48",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b39a53e1",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "993d2f51",
+   "metadata": {},
+   "source": [
+    "5. Ecrire une fonction qui prend en argument un texte et un symbole puis qui retourne le texte souligné du symbole"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e75a3098",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d72c78a0",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "758505a5",
+   "metadata": {},
+   "source": [
+    "6. Ecrire une fonction qui prend en argument un texte, un symbole et une nombre puis qui retourne le texte entouré du nombre de symboles avant et après.\n",
+    "\n",
+    "Exemple:\n",
+    "\n",
+    "Arguments: texte=\"NSI\", symbole=\"#\", nombre=5\n",
+    "\n",
+    "Retourne: \"#####NSI#####\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "81927856",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3f1ec576",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dad10cc7",
+   "metadata": {},
+   "source": [
+    "7. Ecrire une fonction qui prend en argument un texte et un symbole puis qui retrourne le texte **encadré** par le symbole."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "714ca4b6",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2fb4c208",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d21d1fc5",
+   "metadata": {},
+   "source": [
+    "8. Ecrire une fonction qui prend en argument un texte et un symbole puis qui retourne le texte avec une pyramide croissante de symboles avant et une décroissante après.\n",
+    "\n",
+    "Exemple:\n",
+    "\n",
+    "arguments: texte=\"NSI\" symbole=\"#\"\n",
+    "\n",
+    "valeur retournée:\n",
+    "   \n",
+    "    #\n",
+    "    ##\n",
+    "    ###\n",
+    "    NSI\n",
+    "    ###\n",
+    "    ##\n",
+    "    #"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "732ce915",
+   "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/04_Fonctions_specifications_et_tests/2B_specifiction_test.tex

@@ -0,0 +1,93 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+\usepackage{minted}
+
+\author{Benjamin Bertrand}
+\title{Fonctions spécifications et tests - Cours}
+\date{décembre 2022}
+
+\pagestyle{empty}
+
+\begin{document}
+
+\maketitle
+
+\setcounter{section}{1}
+\section{Documenter}
+
+Programmer c'est écrire du code pour que la machine le comprenne mais aussi et surtout pour que d'autres personnes le comprenne et soit en mesure de l'utiliser ou le modifier. C'est pour cela qu'il est primordiale de \textbf{documenter} les fonctions.
+
+\begin{definition}[ Les docstrings ]
+
+    Une \textbf{docstring} (chaine de documentation) est la manière choisi pour documenter les fonctions en Python. Elles se placent en dessous de la signature de la fonction (ligne avec \mintinline{python}{def}) et sont entourés de \mintinline{python}{""" ... """}.
+
+    \begin{center}
+        \begin{minipage}{0.5\linewidth}
+            \begin{minted}[bgcolor=base3,linenos]{python}
+def nom_de_la_fonction(argument1, argument2, ...):
+    """ Explication du fonctionnement de la fonction """
+    instruction 1
+    instruction 2
+    instruction 3
+    ...
+    return valeur
+            \end{minted}
+        \end{minipage}
+    \end{center}
+
+    Pour accéder à la docstring, on utilise l'attribut \mintinline{python}{__doc__} ou la fonction \mintinline{python}{help} en mode interactif.
+    \begin{center}
+        \begin{minipage}{0.5\linewidth}
+            \begin{minted}[bgcolor=base3,linenos]{python}
+>>> from math import sqrt
+>>> print(sqrt.__doc__)
+Return the square root of x.
+            \end{minted}
+        \end{minipage}
+    \end{center}
+\end{definition}
+
+
+\section{Tester}
+
+Écrire une fonction qui marche c'est bien mais écrire une fonction qui fait ce qu'on attend d'elle c'est mieux. Pour s'assurer qu'une fonction a comportement attendu, il faut écrire des \textbf{tests} en utilisant le mot clé \mintinline{python}{assert}.
+\begin{center}
+    \begin{minipage}{0.5\linewidth}
+        \begin{minted}[bgcolor=base3,linenos]{python}
+assert condition
+        \end{minted}
+    \end{minipage}
+\end{center}
+
+Si la condition est vérifiée rien ne se passera. Par contre, si elle est fausse, une erreur sera remontée.
+
+
+\paragraph{Exemple}
+\begin{center}
+    \begin{minipage}{0.5\linewidth}
+        \begin{minted}[bgcolor=base3,linenos]{python}
+def mention(note):
+    """ Renvoie la mention qui correspond à la note"""
+    if note >= 16:
+        return "TB"
+    elif note >= 14:
+        return "B"
+    elif note >= 12:
+        return "AB"
+    elif note >= 9:
+        return "A"
+    else:
+        return "R"
+
+assert mention(13) == "AB"
+assert mention(18) == "TB"
+assert mention(9.5) == "R"
+        \end{minted}
+    \end{minipage}
+\end{center}
+Les deux premiers tests passent. Par contre, le dernier rate car nous avons fait une erreur dans la programmation de la fonction.
+
+\paragraph{Remarques:} Écrire les tests avant de coder la fonction est considéré comme une bonne pratique.
+
+
+\end{document}

1NSI/04_Fonctions_specifications_et_tests/2E_fonction_documentations.ipynb

@@ -0,0 +1,358 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "ebadd52b",
+   "metadata": {},
+   "source": [
+    "# Fonctions et documentations\n",
+    "\n",
+    "Dans le TP précédent, vous avez écrit des fonctions qui marchent. C'est un bon début, mais il est important pour soit et pour les autres de documenter et de spécifier son code pour le rendre plus explicite et éviter les bugs.\n",
+    "\n",
+    "Voici une fonction correctement documentée"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "4f5978cc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def entoure(texte:str, symbole:str, nombre:int)->str:\n",
+    "    \"\"\" Entoure le texte avec le symbole (nombre de fois)\n",
+    "    \n",
+    "    :param texte(str): texte à entourer\n",
+    "    :param symbole(str): symbole pour entourer\n",
+    "    :param nombre(int): nombre de répétition du symbole (avant et après)\n",
+    "    :return (str): le texte entouré\n",
+    "    \n",
+    "    :example:\n",
+    "    >>> entoure(\"NSI\", \"~\", 3)\n",
+    "    ~~~NSI~~~\n",
+    "    >>> entoure(\"Plop\", \"-\", 1)\n",
+    "    -Plop-\n",
+    "    \"\"\"\n",
+    "    symbole_repete = nombre*symbole\n",
+    "    return symbole_repete + texte + symbole_repete"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1ce40493",
+   "metadata": {},
+   "source": [
+    "1. Repérer les nouveaux élèments et la syntaxe associée qui permettent de documenter la fonction."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3a50223f",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3115b6ce",
+   "metadata": {},
+   "source": [
+    "## Carré\n",
+    "\n",
+    "Programmer une fonction qui prend en argument un nombre et qui retourne son carré.\n",
+    "\n",
+    "Fonction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "363b80f7",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "988eec99",
+   "metadata": {},
+   "source": [
+    "Tests"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7331c1eb",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "53bd8be0",
+   "metadata": {},
+   "source": [
+    "## Max à 2\n",
+    "\n",
+    "Programmer une fonction qui prend en argument deux nombres puis qui renvoie le plus grand.\n",
+    "\n",
+    "Fonction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "77541d90",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ffece552",
+   "metadata": {},
+   "source": [
+    "Tests"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "79f0e4d4",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5171aad2",
+   "metadata": {},
+   "source": [
+    "## Max à 3\n",
+    "\n",
+    "Programmer une fonction qui prend en argument 3 nombres et qui renvoie le plus grand.\n",
+    "\n",
+    "Fonctions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2812d74e",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "981bd705",
+   "metadata": {},
+   "source": [
+    "Tests"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f124ff62",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6d76f12c",
+   "metadata": {},
+   "source": [
+    "Essayer de programmer cette fonction en réutilisant la fonction max à 2 de la question précédente"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1dd297be",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bd596431",
+   "metadata": {},
+   "source": [
+    "## Question réponse\n",
+    "\n",
+    "Programmer une fonction qui prend en argument une question et une réponse qui pose la question à l'utilisateur puis qui renvoie True si la réponse est juste ou False sinon.\n",
+    "\n",
+    "Fonction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1446ed52",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "101dfbfb",
+   "metadata": {},
+   "source": [
+    "Tests"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9190ce3b",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "104c2a6c",
+   "metadata": {},
+   "source": [
+    "## Mention\n",
+    "\n",
+    "Dans cette partie, vous devez programmer une fonction qui prend en argument une note (entre 0 et 20) puis qui retourne la mention associée suivant la règle:\n",
+    "\n",
+    "- R si la note < 10\n",
+    "- A si 10 <= note < 12\n",
+    "- AB si 12 <= note < 14\n",
+    "- B si 14 <= note < 16\n",
+    "- TB si 16 <= note\n",
+    "\n",
+    "Fonction\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6757393e",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c09ad023",
+   "metadata": {},
+   "source": [
+    "Tests"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e064533a",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ef55d84d",
+   "metadata": {},
+   "source": [
+    "### Questionnaire\n",
+    "\n",
+    "Ecrire un programme qui pose 10 questions, fait gagner 2points par question juste puis qui donne une mention à l'utilisateur. La mention devra être encadré avec le symbole \"o\"\n",
+    "\n",
+    "Il n'est pas attendu que vous mettiez tout ce programme dans une seul fonction. Par contre, vous devrez réutiliser le plus possible de fonctions déjà programmée précédement et celle ci-dessous"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "12e09ca3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def encadre(texte:str, symbole:str)->str:\n",
+    "    \"\"\"  Encadre le texte avec le symbole\n",
+    "    \n",
+    "    :param texte(str): texte à encadrer\n",
+    "    :param symbole(str): symbole pour encadrer\n",
+    "    :return(str): le texte encadré\n",
+    "    \n",
+    "    \n",
+    "    :example:\n",
+    "    >>> encadre(\"A\", \"~\")\n",
+    "    ~~~\n",
+    "    ~A~\n",
+    "    ~~~\n",
+    "    >>> encadre(\"ZE\", \"-\")\n",
+    "    ----\n",
+    "    -ZE-\n",
+    "    ----\n",
+    "    \n",
+    "    \"\"\"\n",
+    "    texte_encadre = entoure(texte, symbole, 1)\n",
+    "    longueur_boite = len(texte_encadre)\n",
+    "    haut_bas = longueur_boite * symbole\n",
+    "    return haut_bas + \"\\n\" + texte_encadre + \"\\n\" + haut_bas"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "7afc6232",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "----\n",
+      "-ZE-\n",
+      "----\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(encadre(\"ZE\", \"-\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4976f3cd",
+   "metadata": {},
+   "source": [
+    "Votre programme"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "25466c67",
+   "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/04_Fonctions_specifications_et_tests/3E_Tester_des_fonctions.ipynb

@@ -0,0 +1,482 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "9b151783",
+   "metadata": {},
+   "source": [
+    "# Tests et fonctions\n",
+    "\n",
+    "Jusqu'à présent, pour tester des fonctions, vous exécutiez la fonction et vous vérifiez que le résultat était celui attendu. Pour s'assurer que la fonction marche bien comme comme on l'entend, il faut écrire des **tests**.\n",
+    "\n",
+    "Pour cela, on utilise le mot clé: `assert` (affirmer en français).\n",
+    "\n",
+    "Par exemple, on peut écrire le test suivant"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a56fd205",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert 1+2 == 3"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2202397b",
+   "metadata": {},
+   "source": [
+    "Rien ne se passe, c'est normal, le test est validé.\n",
+    "\n",
+    "Par contre, le test"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b2d4859e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert 1+1 == 3"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "968bfafa",
+   "metadata": {},
+   "source": [
+    "ne passe pas(ouf).\n",
+    "\n",
+    "Même s'il est difficile de s'astreindre à cette rigueur, il est conseillé d'écrire les tests avant la fonction. Cela permet de se mettre au clair sur ce que l'on attend du fonctionnement de la fonction.\n",
+    "\n",
+    "Par exemple, on souhaite ecrire une fonction qui prend en paramètre un score entre 0 et 25 et qui renvoie la qualité de la prestation en fonction du tableau suivant\n",
+    "\n",
+    "![regles](./fig/regle_hanabi.png)\n",
+    "\n",
+    "On décide que la fonction s'appellera `prestation` et que l'on ne retournera que le début du texte.\n",
+    "\n",
+    "On peut alors écrire les tests suivants"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5749cbaf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert prestation(4) == \"H\"\n",
+    "assert prestation(7) == \"M\"\n",
+    "assert prestation(12) == \"H\"\n",
+    "assert prestation(17) == \"Exc\"\n",
+    "assert prestation(22) == \"Ext\"\n",
+    "assert prestation(25) == \"L\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1c20db23",
+   "metadata": {},
+   "source": [
+    "Pour le moment, ces tests ne *passent* pas. C'est normal, nous n'avons pas encore écrit la fonction.\n",
+    "\n",
+    "A vous de la faire (enlevé le mot clé `pass` avant de compléter la fonction)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "20c39faf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def prestation():\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cfddb3de",
+   "metadata": {},
+   "source": [
+    "On souhaite ajouter les deux tests suivants pour éviter de chercher un qualificatif inéxistant."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0c9f5415",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert prestation(0) == \"Erreur\"\n",
+    "assert prestation(27) == \"Erreur\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "550c8156",
+   "metadata": {},
+   "source": [
+    "Modifier la fonction `prestation` pour que ces tests passent.\n",
+    "\n",
+    "Enfin dans la pratique, on regroupe tous les tests dans une ou plusieurs fonctions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0716e117",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def test_prestation():\n",
+    "    assert prestation(4) == \"H\"\n",
+    "    assert prestation(7) == \"M\"\n",
+    "    assert prestation(12) == \"H\"\n",
+    "    assert prestation(17) == \"Exc\"\n",
+    "    assert prestation(22) == \"Ext\"\n",
+    "    assert prestation(25) == \"L\"\n",
+    "    assert prestation(0) == \"Erreur\"\n",
+    "    assert prestation(27) == \"Erreur\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4d3cb26b",
+   "metadata": {},
+   "source": [
+    "Et on fait passer les tests en exécutant."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cab73efc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_prestation()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e06e55cb",
+   "metadata": {},
+   "source": [
+    "Les tests sont passés quand rien ne se passe."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "698ae343",
+   "metadata": {},
+   "source": [
+    "## Fonctions de calendrier\n",
+    "\n",
+    "Dans la suite, vous allez écrire des fonctions pour manipuler les dates du calendier.\n",
+    "\n",
+    "Pour les programmer, vous aurez besoin de savoir si un nombre est divisible par d'un autre. Pour cela, on utilise l'opérateur `%` qui donne le reste de la division eublidienne."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "92a23517",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "3 % 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b0ea399d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "10 % 5"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f62d21cb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "9 % 5"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f30669d9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "17 % 5"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "665d03a2",
+   "metadata": {},
+   "source": [
+    "Ainsi pour savoir si un nombre est divisible par un autre, il faut que le reste de la division euclidienne soit égal à 0.\n",
+    "\n",
+    "Vérifier si 123456789 est divisible par 3 (on veut avoir True ou False comme réponse - pas besoin d'écrire une fonction pour cela)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e966d0cb",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "642178d9",
+   "metadata": {},
+   "source": [
+    "Vérifier si 123456789 est divisible par 7"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2d9fbbd9",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e87024c4",
+   "metadata": {},
+   "source": [
+    "Vérifier si 123456789 est divisible par 3803"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "111ef141",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "37748954",
+   "metadata": {},
+   "source": [
+    "### Années bissextiles\n",
+    "\n",
+    "On rappelle qu'une année est dites **bissextile** si elle est divisible par 4. Les siècles ne sont pas pas bissextiles sauf les multiples de 400.\n",
+    "\n",
+    "Vous allez devoir écrire une fonction `est_bissextile` qui prend en argument une année et qui renvoie `True` si elle bissextile et `False` sinon.\n",
+    "\n",
+    "Tests de la fonction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "08130e6f",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4e367d29",
+   "metadata": {},
+   "source": [
+    "La fonction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c7b0673f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def est_bissextile():\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "43ccc643",
+   "metadata": {},
+   "source": [
+    "## Nombre de jours dans le mois\n",
+    "\n",
+    "Vous devez écrire une fonction `nb_jours_mois` qui prend en argument le numéro du mois (1 pour janvier, 7 pour juillet...) et une année et qui renvoie le nombre de jours que contient le mois.\n",
+    "\n",
+    "Tests"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "68d24122",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "30bb7765",
+   "metadata": {},
+   "source": [
+    "La fonction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b5111f24",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def nb_jours_mois():\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9894ecf2",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "22c263a7",
+   "metadata": {},
+   "source": [
+    "### Nombre de jours depuis de début de l'année\n",
+    "\n",
+    "\n",
+    "Vous devez écrire une fonction `nb_jours_debut_annee` qui prend en argument une date décomposé en jour, mois et année et qui renvoie le nombre de jours depuis le début de l'année jusqu'à cette date.\n",
+    "\n",
+    "Test"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1443e43c",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ffff8b65",
+   "metadata": {},
+   "source": [
+    "La fonction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "76908583",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def nb_jours_debut_annee(jour, mois, annee):\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bf369afd",
+   "metadata": {},
+   "source": [
+    "### Jour de la semaine\n",
+    "\n",
+    "On code les jours de la semaine de la manière suivante: \n",
+    "\n",
+    "    0 -> Lundi, 1 -> Mardi ... 6 -> Dimanche\n",
+    "\n",
+    "Vous devez écrire une fonction `jour_semaine` qui prend en argument une date (décomposée comme précédement) et le code du premier jour de l'année correspondante et qui renvoie le code de la date indiquée.\n",
+    "\n",
+    "Voici quelques tests"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "e903bc1a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def test_jour_semaine():\n",
+    "    assert jour_semaine(14, 7, 2022, 5) == 3    \n",
+    "    assert jour_semaine(1, 3, 1933, 6) == 2\n",
+    "    assert jour_semaine(25, 12, 2004, 3) == 5"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9909f403",
+   "metadata": {},
+   "source": [
+    "La fonction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "feb24c9c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def jour_semaine(jour, mois, annee, jour0):\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "587f5f62",
+   "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/04_Fonctions_specifications_et_tests/index.rst

@@ -0,0 +1,70 @@
+Fonctions spécifications et tests
+#################################
+
+:date: 2022-12-02
+:modified: 2023-01-08
+:authors: Benjamin Bertrand
+:tags: Programmation
+:category: 1NSI
+:summary: Découverte des fonctions en python, de la spécification et des tests.
+
+
+Éléments du programme
+=====================
+
+.. list-table:: Fonction, spécification et tests
+    :header-rows: 1
+
+    * - Contenus
+      - Capacités attendues
+      - Commentaires
+
+    * - Spécification
+      - Prototyper une fonction. Décrire les préconditions sur les arguments. Décrire des postconditions sur les résultats.
+      - Des assertions peuvent être utilisées pour garantir des préconditions ou des postconditions.
+
+    * - Mise au point de programmes
+      - Utiliser des jeux de tests.
+      - L’importance de la qualité et du nombre des tests est mise en évidence. Le succès d’un jeu de tests ne garantit pas la correction d’un programme.
+
+Progression
+===========
+
+Étape 1: Création de fonctions décoratives
+------------------------------------------
+
+Activité capytale pour apprendre à programmer des fonctions en décorant du texte.
+
+- `Fonctions décoratives (html) <./1E_fonctions_de_decorations.html>`_
+- `Fonctions décoratives (notebook) <./1E_fonctions_de_decorations.ipynb>`_
+
+Bilan: structure d'une fonction, arguments, valeur retournée, spécifications
+
+.. image:: ./1B_fonctions.pdf
+    :height: 200px
+    :alt: Cours sur les fonctions
+
+
+Étape 2: Coder des fonctions et les documenter
+----------------------------------------------
+
+Fonctions plus classiques à programmer et à documenter.
+
+- `Fonctions et documentation (html) <./2E_fonction_documentations.html>`_
+- `Fonctions et documentation (notebook) <./2E_fonction_documentations.ipynb>`_
+
+Bilan: documenter et spécifier une fonction
+
+.. image:: ./2B_specifiction_test.pdf
+    :height: 200px
+    :alt: Documenter et spécifier une fonction
+
+
+
+Étape 3: Tester une fonction
+----------------------------
+
+Écrire des tests avant d'écrire une fonction. Utilisation d'assert.
+
+- `Fonctions et tests (html) <./3E_Tester_des_fonctions.html>`_
+- `Fonctions et tests (notebook) <./3E_Tester_des_fonctions.ipynb>`_

1NSI/05_Interaction_client-serveur/1B_http.tex

@@ -0,0 +1,88 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+\usepackage{minted}
+
+\author{Benjamin Bertrand}
+\title{Interaction client/serveur - Cours}
+\date{janvier 2023}
+
+\pagestyle{empty}
+
+\begin{document}
+
+\maketitle
+
+\section{Protocole HTTP}
+
+\begin{definition}[HTTP]
+    \texttt{HTTP} est un protocole qui permet de récupérer des ressources telles que des documents HTML, les feuilles CSS, les images... Il est à la base de tout échange de données sur le Web.
+
+    C'est un protocole de type client-serveur, ce qui signifie que les \textbf{requêtes} sont initiées par le client (qui est généralement un navigateur web) et attendent une \textbf{réponse} du serveur.
+\end{definition}
+
+\paragraph{Remarques:} pour obtenir une page web complète, il faut la plupart du temps faire plusieurs \textbf{requêtes} HTTP vers plusieurs serveurs.
+
+\begin{center}
+    \includegraphics[scale=0.2]{./fig/fetching_a_page}
+\end{center}
+
+\section{Requêtes HTTP}
+
+\begin{propriete}[Requête]
+    Une requête est l'un des deux types de message que l'on peut s'échanger dans le protocole HTTP.
+
+    Elle est constituée des éléments suivants
+    \begin{multicols}{3}
+        \begin{itemize}
+            \item Une méthode
+            \item un chemin
+            \item la version du protocole
+            \item d'une entête
+            \item d'un corps
+        \end{itemize}
+    \end{multicols}
+
+
+\end{propriete}
+
+Le protocole HTTP propose différentes méthodes pour faire des requêtes:
+
+\begin{definition}[requêtes GET]
+
+    Les requêtes GET permettent de demander l'accès à des ressources au serveur.
+
+
+\end{definition}
+
+\paragraph{Utilisation d'une requête GET}
+\begin{itemize}
+    \item En tapant \colorbox{highlightbg}{http://monsite.fr/fichier}, le navigateur réalise la requête suivante :
+        \begin{center}
+            \colorbox{highlightbg}{
+                \begin{minipage}{0.5\linewidth}
+                    GET /fichier HTTP/2 \\ \\
+                    Host: monsite.fr \\
+                    User-Agent: Mozilla/5.0 ... \\
+                    Accept-Language: fr,fr-FR
+                \end{minipage}
+            }
+        \end{center}
+
+    \item Il est possible de passer des paramètres à une requête GET en les ajoutant après un ? dans l'URL.
+
+        En tapant \colorbox{highlightbg}{http://monsite.fr/fichier?age=12\&nom=bob}, le navigateur réalise la requête suivante :
+        \begin{center}
+            \colorbox{highlightbg}{
+                \begin{minipage}{0.5\linewidth}
+                    GET /fichier?age=12\&name=jkl HTTP/2 \\ \\
+                    Host: monsite.fr \\
+                    User-Agent: Mozilla/5.0 ... \\
+                    Accept-Language: fr,fr-FR
+                \end{minipage}
+            }
+        \end{center}
+
+        Comme ces paramètres sont écrits directement dans l'URL, il n'est pas conseillé de l'utiliser pour transmettre des informations confidentielles ou nombreuses.
+\end{itemize}
+
+\end{document}

1NSI/05_Interaction_client-serveur/2B_post_formulaire.tex

@@ -0,0 +1,103 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+\usepackage{minted}
+
+\author{Benjamin Bertrand}
+\title{Interaction client/serveur - Cours}
+\date{janvier 2023}
+
+\pagestyle{empty}
+
+\begin{document}
+
+\maketitle
+
+\begin{definition}[requêtes POST]
+
+    Les requêtes POST permettent d'envoyer des informations au serveur. Ces informations ne sont pas transmises via l'URL, mais dans le corps de la requête. Elles peuvent donc être sécurisées.
+
+\end{definition}
+
+\paragraph{Construction d'une requête POST}
+Le \textbf{formulaire} HTML est l'élément qui permet de construire des requêtes POST.
+
+Exemple de formulaire
+
+
+\begin{minipage}{0.8\linewidth}
+    \inputminted[bgcolor=base3,linenos]{html}{./scripts/formulaire.html}
+\end{minipage}
+
+Ce formulaire enverra le nom (de type texte) et si l'utilisateur est majeur (type booléen) par la méthode POST vers le fichier bonjour. Soit la requête suivante
+
+        \begin{center}
+            \colorbox{highlightbg}{
+                \begin{minipage}{0.5\linewidth}
+                    GET /bonjour HTTP/2 \\
+
+                    Host: monsite.fr \\
+                    User-Agent: Mozilla/5.0 ... \\
+                    Accept-Language: fr,fr-FR \\
+
+                    nom=azert\&majeur=on
+                \end{minipage}
+            }
+        \end{center}
+
+Type de input disponibles:
+
+\afaire{compléter la liste}
+
+\vspace{2cm}
+
+\section{Réponse du serveur}
+
+\begin{definition}[Réponse du serveur]
+    C'est l'autre type de message que l'on peut s'échanger dans le protocole HTTP.
+
+    Il est constitué des éléments suivants :
+
+    \begin{multicols}{2}
+        \begin{itemize}
+            \item La version du protocole
+            \item le code d'état (status code)
+            \item du message d'état
+            \item d'une entête
+        \end{itemize}
+    \end{multicols}
+
+
+\end{definition}
+
+Exemple d'une réponse
+\begin{center}
+    \colorbox{highlightbg}{
+        \begin{minipage}{0.5\linewidth}
+            HTTP/1.1 200 OK \\
+
+            Date: Sat, 09 Oct 2010 14:28:02 GMT \\
+            Server: Apache \\
+            Last-Modified: Tue, 01 Dec 2009 20:18:22 GMT \\
+            Content-Type: text/html \\
+            ... \\
+
+            <!DOCTYPE html...
+
+        \end{minipage}
+    }
+\end{center}
+
+\begin{propriete}[Code status]
+    Les codes status d'un serveur est un nombre à 3 chiffres auquel on associe une message.
+
+    \begin{itemize}
+        \item Code en 2..: réponse fructueuse (tout s'est bien passée)
+        \item Code en 3..: la requête a été redirigée
+        \item Code en 4..: le client a fait une erreur de requête
+        \item Code en 5..: le serveur est en erreur
+    \end{itemize}
+
+\end{propriete}
+
+
+\end{document}

1NSI/05_Interaction_client-serveur/exercises.tex

@@ -0,0 +1,222 @@
+\begin{exercise}[subtitle={Requêtes et réponses}, step={1}, origin={Ma tête}, topics={  Interaction client-serveur }, tags={ HTTP, Flask }]
+    \begin{enumerate}
+        \item Ouvrir le navigateur, allez chercher les outils de développement (\texttt{F12}) puis allez sur l'onglet \texttt{Réseau} (ou network).
+            \begin{enumerate}
+                \item Allez à l'adresse \url{raw.opytex.org}.. Faire apparaitre les colonnes \texttt{chemin} (ou path) et \texttt{url}.
+                \item En cliquant sur la requête, noter la méthode, le domaine (host), le fichier, l'adresse IP de la requête et l'état (ou status) de la réponse. \label{element}
+                \item Faire la même chose pour l'adresse \\ \url{https://raw.opytex.org/1NSI/05_Interaction_client-serveur/}.
+                \item La requête vers l'adresse \url{https://optez.org} engendre plusieurs requêtes noter les éléments (précisés à la question \ref{element}) pour chacune d'entre elles.
+            \end{enumerate}
+        \item Éléments théoriques - recherche documentaire
+            \begin{enumerate}
+                \item Expliquer le rôle que joue les méthodes vues dans les questions précédentes
+                \item Expliquer le rôle que joue les codes status vus dans les questions précédentes
+            \end{enumerate}
+    \end{enumerate}
+\end{exercise}
+
+
+\begin{exercise}[subtitle={Application web avec Bottle - requête GET}, step={2}, origin={Ma tête}, topics={  Interaction client-serveur }, tags={ HTTP, Flask }]
+    Dans cette partie, vous allez programmer une application web en utilisant la librairie python \texttt{bottle}. Vous trouverez la documentation (en anglais) à l'adresse suivante
+    \begin{center}
+        \url{https://bottlepy.org/docs/dev/tutorial.html}
+    \end{center}
+    \begin{enumerate}
+        \item \textbf{Mise en place de Bottle et vérifications}
+            \begin{enumerate}
+                \item Copier-coller le code suivant (tiré de la documentation) pour initialiser l'application.
+
+                    \begin{center}
+                        \begin{minipage}{0.9\linewidth}
+                            \inputminted[bgcolor=base3,linenos]{python}{./scripts/bottle_base.py}
+                        \end{minipage}
+                    \end{center}
+                    \label{bottle_base}
+
+                \item Exécuter votre programme puis rendez-vous avec le navigateur à l'adresse
+
+                    \url{http://localhost:8080/hello}
+
+                    Étudiez la requête (méthode, domaine, fichier et status).
+                \item Rendez-vous avec le navigateur à l'adresse \url{http://localhost:8080/plop}. Étudiez la requête (méthode, domaine, fichier et status).
+                \item Relier ce que vous avez noté aux questions précédentes avec le code exemple de Bottle.
+                \item Comment peut-on ajouter d'autres chemins à notre application?
+            \end{enumerate}
+
+        \item \textbf{Requêtes GET}
+
+            Pour toutes les questions suivantes, vous devrez tester votre travail en visitant la page associée et vous noterez l'URL.
+            \begin{enumerate}
+                \item Supprimer le chemin \texttt{/hello}.
+                \item Ajouter le chemin accessible à la racine de l'application (\texttt{/}) qui saluera les nouveaux venus.
+                \item Ajouter le chemin \texttt{/about} qui vous présentera (en une phrase).
+                \item Ajouter le chemin \texttt{/bottle} qui vous donnera le lien (cliquable) vers la documentation de Bottle.
+                \item (*) On peut créer des chemins dynamiques en suivant la syntaxe suivante
+
+                    \begin{center}
+                        \begin{minipage}{0.9\linewidth}
+                            \inputminted[bgcolor=base3,linenos]{python}{./scripts/bottle_route_dynamique.py}
+                        \end{minipage}
+                    \end{center}
+
+                    Ajouter ce chemin à votre application. Proposez plusieurs URL qui l'utilisent.
+
+                \item On peut aussi configurer des \texttt{query}
+
+                    \begin{center}
+                        \begin{minipage}{0.9\linewidth}
+                            \inputminted[bgcolor=base3,linenos]{python}{./scripts/bottle_query.py}
+                        \end{minipage}
+                    \end{center}
+
+                    Ajouter ce chemin à votre application sans oublier d'ajouter les nouveaux imports. En reprenant votre cours sur les URL, trouver l'URL qui permet d'avoir sur votre navigateur le message
+                    \begin{center}
+                         Bob a 5 ans.
+                    \end{center}
+
+                \item Pour le moment, le code renvoyé par notre application n'est pas du code HTML valide. Il est possible d'écrire des modèles (template en anglais) dans lesquels on va pouvoir injecter des variables python pour les rendre modulables.
+
+                    À côté du fichier de votre application, créer un fichier \texttt{utilisateur.html} dans lequel vous mettrait le code HTML suivant
+
+                    \begin{center}
+                        \begin{minipage}{0.9\linewidth}
+                            \inputminted[bgcolor=base3,linenos]{html}{./scripts/utilisateur.html}
+                        \end{minipage}
+                    \end{center}
+
+                    Ajoutez la fonction \mintinline{python}{template} dans les imports de bottle. Puis modifier le chemin \texttt{page\_utilisateur} pour avoir le contenu suivant
+
+                    \begin{center}
+                        \begin{minipage}{0.9\linewidth}
+                            \inputminted[bgcolor=base3,linenos]{python}{./scripts/bottle_template.py}
+                        \end{minipage}
+                    \end{center}
+
+                    Visitez plusieurs pages utilisateur et constatez les différences.
+
+                    Comment fait-on pour utiliser une variable python dans modèle?
+            \end{enumerate}
+
+
+    \end{enumerate}
+
+\end{exercise}
+
+\begin{exercise}[subtitle={Application web avec Bottle - requête POST}, step={2}, origin={Ma tête}, topics={  Interaction client-serveur }, tags={ HTTP, Flask }]
+    Les requêtes POST envoient des informations au serveur. Ces informations sont le plus souvent envoyé à partir d'une formulaire HTML.
+
+    On reprend le code de la question \ref{bottle_base} de l'exercice précédent.
+
+    \begin{enumerate}
+        \item Supprimer la route \texttt{hello} et ajouter la route suivante
+
+            \begin{center}
+                \begin{minipage}{0.9\linewidth}
+                    \inputminted[bgcolor=base3,linenos]{python}{./scripts/bottle_get_form.py}
+                \end{minipage}
+            \end{center}
+        \item Quelle URL doit-on entrer dans le navigateur pour accéder à ce formulaire? Envoyez un nom et étudier la requête.
+        \item On ajoute maintenant la route suivante du type POST pour réceptionner cette requête. Mais avant cela, vous devez ajouter la fonction \texttt{post} dans les imports.
+
+            \begin{center}
+                \begin{minipage}{0.9\linewidth}
+                    \inputminted[bgcolor=base3,linenos]{python}{./scripts/bottle_post_form.py}
+                \end{minipage}
+            \end{center}
+
+        \item Remplissez le formulaire, envoyez le et étudier les requêtes.
+        \item \textbf{Bilan sur les formulaires et les requêtes post}:
+            \begin{enumerate}
+                \item Identifier les nouvelles balises HTML utiles pour créer un formulaire.
+                \item Chercher sur internet d'autres type possible pour la balise \texttt{input}.
+                \item Comment \texttt{bottle} fait pour accéder au information du formulaire lors une requête POST?
+                \item Quelles sont les différences entre transmettre une information avec une requête POST et l'utilisation des query?
+            \end{enumerate}
+    \end{enumerate}
+\end{exercise}
+
+\begin{exercise}[subtitle={Application web avec Bottle - Accès authentifié}, step={2}, origin={Ma tête}, topics={  Interaction client-serveur }, tags={ HTTP, Flask }]
+    Vous devez écrire une application web qui a les routes suivantes :
+    \begin{itemize}
+        \item \textbf{la racine (/)}: contient un formulaire de connexion avec deux champs (utilisateur et mot de passe). L'envoie du formulaire se fait vers la route \texttt{/prive}
+        \item \textbf{/privé}: route avec deux comportements :
+            \begin{itemize}
+                \item Affiche "accès autorisé" sur le couple utilisateur et mot de passe correspond à l'utilisateur et au mot de passe enregistré dans le code l'application.
+                \item Affiche "accès non autorisé" sinon.
+            \end{itemize}
+    \end{itemize}
+\end{exercise}
+
+\begin{exercise}[subtitle={Projet Bottle - Années}, step={2}, origin={Ma tête}, topics={  Interaction client-serveur }, tags={ HTTP, Flask }]
+    Vous devez écrire une application web qui a les routes suivantes :
+    \begin{itemize}
+        \item \textbf{/ (la racine)}: contient plusieurs formulaires. Un qui permet de savoir si une année est bissextile et un autre qui compte le nombre de jours depuis le début de l'année.
+        \item \textbf{/bissextile}: qui affiche l'année et qui dit si l'année est bissextile ou non.
+        \item \textbf{/jours}: qui affiche la date et le nombre de jour depuis le début de l'année.
+    \end{itemize}
+    Bonus : du CSS à votre site (pensez à ajouter la route pour servir le fichier)
+\end{exercise}
+
+
+\begin{exercise}[subtitle={QCM}, step={2}, origin={Annales}, topics={  Interaction client-serveur }, tags={ HTTP, Flask }]
+    \begin{enumerate}
+        \item Parmi GET et POST, quelle méthode d'envoi de formulaire crypte les informations envoyées au serveurs?
+            \begin{tasks}(2)
+                \task les deux: GET et POST
+                \task GET seulement
+                \task POST seulement
+                \task aucune des deux
+            \end{tasks}
+        \item Parmi les réponses suivantes, que permet d'effectuer la méthode POST du protocole HTTP?
+            \begin{tasks}(2)
+                \task Définir le style d'une page
+                \task Pirater des données bancaire
+                \task Envoyer une page web vers le client
+                \task Envoyer les données saisies dans un formulaire HTML vers un serveur
+            \end{tasks}
+        \item Charles veut accéder à son forum favori. Il sais son adresse (URL) sur son navigateur Web, qui lui affiche une erreur 404.
+
+            Quelle cas de figure \textbf{n'explique pas} sa situation?
+            \begin{tasks}(2)
+                \task une mise à jour du serveur qui héberge le forum
+                \task une erreur de saisie de sa part
+                \task une panne de sa connexion internet
+                \task un changement de titre du forum qu'il veut consulter
+            \end{tasks}
+        \item Parmi les éléments suivants, lequel est un protocole?
+            \begin{tasks}(4)
+                \task GET
+                \task POST
+                \task HTTP
+                \task HTML
+            \end{tasks}
+        \item Dans une page HTML, que pet la balise \texttt{<form action="http://monsite.fr" method="POST">}?
+            \begin{tasks}
+                \task d'envoyer des données à l'URL \texttt{http://monsite.fr} sans les ajouter au corps de la requête HTTP
+                \task d'envoyer des données à l'URL \texttt{http://monsite.fr} et de  les ajouter au corps de la requête HTTP mais pas à l'URL
+                \task de télécharger une formulaire depuis l'URL \texttt{http://monsite.fr}
+                \task de récupérer des données depuis l'URL \texttt{http://monsite.fr}
+            \end{tasks}
+        \item Dans le contexte du Web, qu'est-ce qu'une transmission chiffrée?
+            \begin{tasks}
+                \task une transmission optimisée pour les grands nombres
+                \task une transmission sous forme binaire
+                \task une transmission d'information cryptée
+                \task une transmission facturée proportionnellement à la taille du message
+            \end{tasks}
+        \item Mehdi a écrit une page HTML contenant des éléments \texttt{input} de formulaire. Il place ces éléments de formulaire:
+            \begin{tasks}
+                \task entre la balise \texttt{<form>} et la balise \texttt{</form>}
+                \task entre la balise \texttt{<formulary>} et la balise \texttt{</formulary>}
+                \task entre la balise \texttt{<code>} et la balise \texttt{</code>}
+                \task entre la balise \texttt{<script>} et la balise \texttt{</script>}
+            \end{tasks}
+        \item Quelle utilisation faut-il avoir pour garantir qu'une transmission entre un client et un serveur sera-t-elle chiffrée?
+            \begin{tasks}(2)
+                \task lorsqu'on utilise le navigateur web Firefox
+                \task lorsqu'on utilise la méthode POST
+                \task lorsqu'on utilise le protocole HTTPS
+                \task lorsqu'on utilise HTML et CSS
+            \end{tasks}
+    \end{enumerate}
+\end{exercise}

1NSI/05_Interaction_client-serveur/index.rst

@@ -0,0 +1,64 @@
+Interaction client-serveur
+###########################
+
+:date: 2023-01-03
+:modified: 2023-01-22
+:authors: Benjamin Bertrand
+:tags: Http, Flask
+:category: 1NSI
+:summary: Les réponses et les requêtes du protocole HTTP et la construction d'un serveur web
+
+
+Éléments du programme
+=====================
+
+.. list-table:: Fonction, spécification et tests
+    :header-rows: 1
+
+    * - Contenus
+      - Capacités attendues
+      - Commentaires
+
+    * - Interaction client-serveur. Requêtes HTTP, réponses du serveur
+      - Distinguer ce qui est exécuté sur le client ou sur le serveur et dans quel ordre. Distinguer ce qui est mémorisé dans le client et retransmis au serveur. Reconnaître quand et pourquoi la transmission est chiffrée.
+      - Il s’agit de faire le lien avec ce qui a été vu en classe de seconde et d’expliquer comment on peut passer des paramètres à un site grâce au protocole HTTP.
+
+    * - Formulaire d’une page Web
+      - Analyser le fonctionnement d’un formulaire simple. Distinguer les transmissions de paramètres par les requêtes POST ou GET.
+      - Discuter les deux types de requêtes selon le type des valeurs
+
+
+Progression
+===========
+
+Plan de travail
+
+.. image:: ./plan_de_travail.pdf
+    :height: 200px
+    :alt: Plan de travail
+
+Etape 1: requetes
+=================
+
+Cours: rappels de ce qui a été déjà fait sur le web: client serveur, url, positionnement du protocole HTTP dans la stack web. Introduction des concepts requêtes/reponses.
+
+Exploration de l'onglet "Network" dans les outils de dev des navigateurs.
+
+Bilan:
+
+.. image:: ./1B_http.pdf
+    :height: 200px
+    :alt: Bilan sur le protocole HTTP et les requêtes GET
+
+.. image:: ./2B_post_formulaire.pdf
+    :height: 200px
+    :alt: Bilan sur les requêtes POST, les formulaires et les codes status du serveur
+
+Etape 2: construction d'un serveur
+==================================
+
+Pour faire les exercices utilisant Bottle, il faut placer `le fichier bottle.py <https://raw.githubusercontent.com/bottlepy/bottle/master/bottle.py>`_  à côté de votre script.
+
+
+Etape 3: QCM type
+=================

1NSI/05_Interaction_client-serveur/plan_de_travail.tex

@@ -0,0 +1,34 @@
+\documentclass[a4paper,12pt]{article}
+\usepackage{myXsim}
+\usepackage{minted}
+
+\author{Benjamin Bertrand}
+\title{ Interaction client-serveur - Plan de travail}
+\tribe{1NSI}
+\date{janvier 2023}
+
+\pagestyle{empty}
+
+\DeclareExerciseCollection{banque}
+\xsimsetup{
+}
+
+
+\begin{document}
+\maketitle
+
+% Résumé
+
+\bigskip
+
+Savoir-faire de la séquence
+\begin{itemize}
+    \item Distinguer ce qui est exécuté sur le client ou sur le serveur et dans quel ordre. Distinguer ce qui est mémorisé dans le client et retransmis au serveur. Reconnaître quand et pourquoi la transmission est chiffrée.
+    \item Analyser le fonctionnement d’un formulaire simple. Distinguer les transmissions de paramètres par les requêtes POST ou GET.
+\end{itemize}
+
+\input{exercises.tex}
+\printcollection{banque}
+
+
+\end{document}

1NSI/05_Interaction_client-serveur/scripts/bottle_base.py

@@ -0,0 +1,7 @@
+from bottle import get, run
+
+@get('/hello')
+def hello():
+    return "Hello World!"
+
+run(host='localhost', port=8080, debug=True)

1NSI/05_Interaction_client-serveur/scripts/bottle_get_form.py

@@ -0,0 +1,9 @@
+@get('/formulaire')
+def get_formulaire():
+    formulaire = """
+    <form method='post' action='bonjour'>
+    <input type='text' name='nom' placeholder='Votre nom ?'/>
+    <input type='submit' value='Bonjour bottle !'/>
+    </form>
+    """
+    return formulaire

1NSI/05_Interaction_client-serveur/scripts/bottle_post_form.py

@@ -0,0 +1,6 @@
+@post('/bonjour')
+def bonjour() :
+    nom = bottle.request.forms.get('nom')
+    body = "<p>Bonjour mon(a) che(è)r(e) " + nom + "</p>"
+
+    return body

1NSI/05_Interaction_client-serveur/scripts/bottle_query.py

@@ -0,0 +1,14 @@
+from bottle import request, get
+
+@get('/age')
+def age_de():
+
+    name = request.query.name
+    age = request.query.age
+
+    if int(age) > 1:
+        return name + " a " + age + " ans."
+    elif int(age) <= 0:
+        return "Mouai..."
+    else:
+        return name + " a " + age + " an."

1NSI/05_Interaction_client-serveur/scripts/bottle_route_dynamique.py

@@ -0,0 +1,3 @@
+@get("/page/<utilisateur>")
+def page_utilisateur(utilisateur):
+    return "Bonjour " + utilisateur + ", comment allez vous?"

1NSI/05_Interaction_client-serveur/scripts/bottle_template.py

@@ -0,0 +1,3 @@
+@get('/page/<utilisateur>')
+def page_utilisateur(utilisateur):
+    return template("utilisateur.html", utilisateur=utilisateur)

1NSI/05_Interaction_client-serveur/scripts/bottle_template_app.py

@@ -0,0 +1,7 @@
+from bottle import get, run, template
+
+@get('/page/<utilisateur>')
+def page_utilisateur(utilisateur):
+    return template("utilisateur.html", utilisateur=utilisateur)
+
+run(host='localhost', port=8080, debug=True)

1NSI/05_Interaction_client-serveur/scripts/formulaire.html

@@ -0,0 +1,7 @@
+<form method='post' action='bonjour'>
+
+    <input type='text' name='nom' placeholder='Votre nom ?'/>
+    <input type='checkbox' name='majeur' placeholder='Etes vous majeur?'/>
+
+    <input type='submit' value='Bonjour bottle !'/>
+</form>

1NSI/05_Interaction_client-serveur/scripts/modele_base.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang=fr>
+	<head>
+		<meta charset="UTF-8">
+		<meta name="Author" content="">
+        <title></title>
+	</head>
+
+	<body>
+        {{ body }}
+	</body>
+</html>

1NSI/05_Interaction_client-serveur/scripts/utilisateur.html

@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang=fr>
+	<head>
+		<meta charset="UTF-8">
+		<meta name="Author" content="">
+        <title>Page de {{ utilisateur }}</title>
+	</head>
+
+	<body>
+        <h1>{{ utilisateur }}</h1>
+        <p>
+            Cette page change en fonction de l'utilisateur
+            renseignée dans l'URL.
+        </p>
+        <p>Elle sait même faire des calculs 1+1 = {{ 1+1 }}</p>
+	</body>
+</html>

1NSI/06_Listes_et_tuples/1B_liste.tex

@@ -0,0 +1,84 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+\usepackage{minted}
+
+\author{Benjamin Bertrand}
+\title{Listes et tuples - Cours}
+\date{janvier 2023}
+
+\pagestyle{empty}
+
+\begin{document}
+
+\maketitle
+
+\section{Les tableaux}
+
+\begin{definition}[Listes]
+
+    Un tableau est une structure de données qui est un conteneur (qui contient des objets) et une séquence (c'est à dire qu'elle elle ordonnée). En python, un tableau est appelé \mintinline{python}{list}.
+
+\end{definition}
+
+Exemple:
+
+\begin{center}
+    \begin{minipage}{0.9\linewidth}
+        \inputminted[bgcolor=base3]{python}{./scripts/1B_list.py}
+    \end{minipage}
+\end{center}
+\afaire{Compléter les espaces avec le résultat de l'opération.}
+
+\begin{propriete}[Opérations sur les listes Python]
+    \begin{itemize}
+        \item \textbf{Ajouter un élément} avec la méthode \mintinline{python}{.append(...)}
+        \item \textbf{Supprimer un élément} avec la méthode \mintinline{python}{.remove(...)}
+        \item \textbf{Concaténer deux listes} avec l'opération \mintinline{python}{+}
+    \end{itemize}
+\end{propriete}
+
+\begin{center}
+    \begin{minipage}{0.9\linewidth}
+        \inputminted[bgcolor=base3]{python}{./scripts/1B_operation.py}
+    \end{minipage}
+\end{center}
+
+\afaire{Compléter les espaces avec le résultat de l'opération.}
+
+\begin{propriete}[Parcours d'une tableau]
+    \begin{multicols}{2}
+        \begin{itemize}
+            \item On peut parcourir un tableau avec une boucle for
+                \begin{center}
+                    \begin{minipage}{0.9\linewidth}
+                        \inputminted[bgcolor=base3]{python}{./scripts/1B_for.py}
+                    \end{minipage}
+                \end{center}
+            \columnbreak
+            \item Utiliser les listes de comprehension
+                \begin{center}
+                    \begin{minipage}{0.9\linewidth}
+                        \inputminted[bgcolor=base3]{python}{./scripts/1B_comprehension.py}
+                    \end{minipage}
+                \end{center}
+        \end{itemize}
+    \end{multicols}
+\end{propriete}
+
+\begin{definition}[Liste de listes]
+
+    Pour décrire des tableaux à deux dimensions, on peut faire des listes de listes. Ce sont des listes dont les éléments sont des listes de chose.
+
+        \begin{minipage}{0.4\linewidth}
+            \inputminted[bgcolor=base3]{python}{./scripts/1B_list_list.py}
+        \end{minipage}
+        \hfill
+        \begin{minipage}{0.4\linewidth}
+            \inputminted[bgcolor=base3]{python}{./scripts/1B_list_list_2.py}
+        \end{minipage}
+
+    Cela permet de représenter des plateaux de jeux, des images...
+
+\end{definition}
+
+\end{document}

1NSI/06_Listes_et_tuples/2B_tuple.tex

@@ -0,0 +1,36 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+\usepackage{minted}
+
+\author{Benjamin Bertrand}
+\title{Listes et tuples - Cours}
+\date{janvier 2023}
+
+\pagestyle{empty}
+
+\begin{document}
+
+\maketitle
+
+\setcounter{section}{1}
+\section{Les p-uplets}
+
+\begin{definition}[P-uplets - Tuples]
+
+    Un objet de type \mintinline{python}{tuple} (un p-uplet) est une suite ordonnée d’éléments qui peuvent être chacun de n’importe quel type.
+
+    Ce type d'objet est nom mutable c'est à dire qu'une fois créé, on ne peut plus le modifier.
+
+\end{definition}
+
+Dans la pratique, il s'utilise comme un objet de type \mintinline{python}{list}.
+
+\begin{center}
+    \begin{minipage}{0.9\linewidth}
+        \inputminted[bgcolor=base3]{python}{./scripts/2B_tuple.py}
+    \end{minipage}
+\end{center}
+
+
+
+\end{document}

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/Découverte des listes et des tuples.ipynb

@@ -0,0 +1,585 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "ed3c16da",
+   "metadata": {},
+   "source": [
+    "# Découverte des listes et des tuples\n",
+    "\n",
+    "## Mise en situation\n",
+    "\n",
+    "On souhaite écrire un programme qui fait une moyenne de notes.\n",
+    "\n",
+    "1. Écrire une fonction `moyenne3` qui prend en argument 3 notes et qui renvoie la moyenne de ces trois notes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "352fd339",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# tests\n",
+    "assert moyenne3(1, 2, 3) == 2\n",
+    "assert moyenne3(10, 0, 5) == 5"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ddd2db52",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# fonction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3e58998e",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "97396105",
+   "metadata": {},
+   "source": [
+    "2. Écrire une fonction `moyenne_question` qui prend en argument un nombre de notes puis renvoie la moyenne des notes entrée par l'utilisateur (avec input)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4dd1cb77",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# pas de tests à cause de l'utilisation du input"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "572a9917",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# fonction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "af965cbe",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91486d89",
+   "metadata": {},
+   "source": [
+    "3. On voudrait maintenant écrire une fonction qui prend en argument plusieurs notes (qu'on ne connait pas à l'avance) et qui renvoie la moyenne de ces notes. Quels sont les obstacles qui empêchent de réaliser une telle fonction?"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "id": "ac18a2ae",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "28501a12",
+   "metadata": {},
+   "source": [
+    "## Les listes\n",
+    "\n",
+    "Les `list` sont un autre type de variable (au même titre que les `int`, `float`...). Ils ont la particularité de stocker un nombre arbitraire de variables. En voici des exemples"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0c8dd096",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "liste1 = [1, 2, 3, 4, 5]\n",
+    "liste2 = [\"a\", \"c\" \"uio\", \"éé\"]\n",
+    "liste3 = [-1, 2.2, \"uio\", 10, 100, \"1000\"] "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "28c340b2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(liste1)\n",
+    "print(liste2)\n",
+    "print(liste3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9dd742c8",
+   "metadata": {},
+   "source": [
+    "### Accéder à un élément de liste\n",
+    "\n",
+    "Pour accéder à un élément particulier d'une liste, on utilise les crochets`[]`.\n",
+    "\n",
+    "1. Deviner ce qui va être afficher par les commandes ci-dessous avant de l'exécuter."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "87fc0d29",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(liste1[3])\n",
+    "print(liste2[2])\n",
+    "print(liste3[0])\n",
+    "print(liste1[-1])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "61cb8afe",
+   "metadata": {},
+   "source": [
+    "2. Écrire les commandes pour accéder au nombre 2 de la liste1, \"éé\" de la liste2 et \"uio\" de la liste3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f11b02a8",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cadb6818",
+   "metadata": {},
+   "source": [
+    "3. Que se passe-t-il quand on essayer d'accéder à une valeur qui n'existe pas?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "37903285",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "raw",
+   "id": "9a0e4586",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "da97681e",
+   "metadata": {},
+   "source": [
+    "4. On peut aussi modifier un élément d'une liste"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f594935a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "liste1[1] = \"azert\"\n",
+    "print(list1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bd595043",
+   "metadata": {},
+   "source": [
+    "5. Construire une liste avec les nombres pairs inférieur à 10. Puis modifier la pour que les multiples de 4 soient remplacés par \"a\"."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4677cbb0",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f08d4c53",
+   "metadata": {},
+   "source": [
+    "### Ajouter/supprimer des éléments\n",
+    "\n",
+    "Pour ajouter des éléments, on utilise la méthode `.append(...)`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ff4e90a0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "liste3 = [-1, 2.2, \"uio\", 10, 100, \"1000\"]\n",
+    "print(liste3)\n",
+    "liste3.append(\"nsi\")\n",
+    "print(liste3)\n",
+    "liste3.append(\"azert\")\n",
+    "print(liste3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8a0f012c",
+   "metadata": {},
+   "source": [
+    "1. Écrire une fonction `table` qui prend en argument un nombre `a` et une longueure `n` et qui renvoie les multiples de a de 0 à a*n."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "59a55bc2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Testes\n",
+    "assert table(2, 10) == [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20]\n",
+    "assert table(3, 5) == [0, 3, 6, 9, 12, 15]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "69fb46d6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Fonction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "04e04b5d",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "36258d27",
+   "metadata": {},
+   "source": [
+    "Pour enlever un élément, on utilise la méthode `.remove(...)`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "549a996d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[-1, 2.2, 'uio', 10, 100, 10]\n",
+      "[-1, 2.2, 10, 100, 10]\n",
+      "[-1, 2.2, 100, 10]\n"
+     ]
+    }
+   ],
+   "source": [
+    "liste3 = [-1, 2.2, \"uio\", 10, 100, 10]\n",
+    "print(liste3)\n",
+    "liste3.remove(\"uio\")\n",
+    "print(liste3)\n",
+    "liste3.remove(10)\n",
+    "print(liste3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0bc67d3c",
+   "metadata": {},
+   "source": [
+    "### Longueur d'une liste\n",
+    "\n",
+    "Pour mesurer la longueur d'une liste, on utilise la fonction `len(...)`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "9c809de2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "5\n",
+      "3\n",
+      "6\n"
+     ]
+    }
+   ],
+   "source": [
+    "liste1 = [1, 2, 3, 4, 5]\n",
+    "print(len(liste1))\n",
+    "liste2 = [\"a\", \"c\" \"uio\", \"éé\"]\n",
+    "print(len(liste2))\n",
+    "liste3 = [-1, 2.2, \"uio\", 10, 100, \"1000\"] \n",
+    "print(len(liste3))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "88060355",
+   "metadata": {},
+   "source": [
+    "1. Écrire une fonction `somme` qui prend en argument une liste de nombres et qui renvoie la somme des nombres"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "19510eb8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Tests\n",
+    "assert somme([1, 2, 3]) == 6\n",
+    "assert somme([1]) == 1\n",
+    "assert somme([1, 5, 10, 0, 4]) == 20\n",
+    "assert somme([1.2, 1, 1.5]) == 3.7"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "38c79fed",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Fonction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f4cd9cbf",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3e7e0a3a",
+   "metadata": {},
+   "source": [
+    "2. Écrire une fonction `moyenne` qui prend en argument une liste de nombres et qui renvoie la moyenne de ces nombres"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e83df22f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Tests\n",
+    "assert moyenne([1, 2, 3]) == 2\n",
+    "assert moyenne([1]) = 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "750b4e2f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Fonctions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "35efeef8",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9bff74a3",
+   "metadata": {},
+   "source": [
+    "### Boucle for sur une liste\n",
+    "\n",
+    "Il est possible de faire une boucle `for` sur les éléments d'une liste.\n",
+    "\n",
+    "Par exemple, la fonction `moyenne` précédement rédigée peut être réécrite de la manière suivante"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "c93f43d4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def moyenne(notes:list)->float:\n",
+    "    \"\"\"Calculer la moyenne des notes de la liste\"\"\"\n",
+    "    total = 0\n",
+    "    for note in notes:\n",
+    "        total = total + note\n",
+    "    return total / len(notes)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "53c180b6",
+   "metadata": {},
+   "source": [
+    "1. Ecrire une fonction `somme` qui prend en argument une liste de nombres et qui renvoie la somme de ces nombres."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f956b1ec",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4ec924e6",
+   "metadata": {},
+   "source": [
+    "2. Ecrire une fonction `multiplie` qui prend en argument un nombre et une liste de nombres et qui renvoie la liste des nombres multipliées par l'autre nombre."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c90251a7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#tests\n",
+    "assert multiplie(2, [1, 2, 3]) == [2, 4, 6]\n",
+    "assert multiplie(0, [1, 3, 6]) == [0, 0, 0]\n",
+    "assert multiplie(-1, [1, 10, 100, -1]) == [-1, -10, -100, 1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "81f3ebdf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Fonction"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bd7c1976",
+   "metadata": {},
+   "source": [
+    "3. Ecrire une fonction `filtre_impaire` qui prendre en argument une liste de nombres et qui renvoie une liste contenant uniquement les nombres impaires."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "b484693e",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'filtre_impaire' 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 [6]\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[43mfiltre_impaire\u001b[49m([\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m4\u001b[39m, \u001b[38;5;241m5\u001b[39m]) \u001b[38;5;241m==\u001b[39m [\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m5\u001b[39m]\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m filtre_impaire([\u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m4\u001b[39m]) \u001b[38;5;241m==\u001b[39m []\n\u001b[1;32m      4\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m filtre_impaire([]) \u001b[38;5;241m==\u001b[39m []\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'filtre_impaire' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "#tests\n",
+    "assert filtre_impaire([1, 2, 3, 4, 5]) == [1, 3, 5]\n",
+    "assert filtre_impaire([2, 4]) == []\n",
+    "assert filtre_impaire([]) == []"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "c43261b1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Fonctions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fc069c83",
+   "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/06_Listes_et_tuples/exercises.tex

@@ -0,0 +1,217 @@
+\begin{exercise}[subtitle={QCM}, step={2}, origin={Annales}, topics={Tuples et listes}, tags={tuple, liste}]
+    \begin{enumerate}
+        \item Quel est le type de l'expression \texttt{f(4)} si la fonction \texttt{f} est définie par
+
+            \begin{center}
+                \begin{minipage}{0.9\linewidth}
+                    \inputminted[bgcolor=base3]{python}{./scripts/QCM_f.py}
+                \end{minipage}
+            \end{center}
+
+
+            \begin{tasks}(4)
+                \task un entier
+                \task un flottant
+                \task une liste
+                \task un tuple
+            \end{tasks}
+
+        \item On dispose d'une liste définie par \mintinline{python}{L = [15, 17, 12, 23]}.
+
+            Quelle est la valeur de L après l'instruction \mintinline{python}{L[2] = 25}
+
+            \begin{tasks}(2)
+                \task \mintinline{python}{[15, 25, 12, 23]}
+                \task \mintinline{python}{[15, 17, 25, 12, 23]}
+                \task \mintinline{python}{[15, 25, 25, 23]}
+                \task \mintinline{python}{[15, 17, 12, 25, 23]}
+            \end{tasks}
+
+        \item Après l'affectation suivante :
+
+                \mintinline{python}{alphabet = [ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',] }
+
+            quelle est l'expression qui permet d'accéder à la lettre E?
+
+            \begin{tasks}(2)
+                \task \mintinline{python}{alphabet.E}
+                \task \mintinline{python}{alphabet['E']}
+                \task \mintinline{python}{alphabet[4]}
+                \task \mintinline{python}{alphabet[5]}
+            \end{tasks}
+
+        \item On considère le script suivant:
+
+            \begin{center}
+                \begin{minipage}{0.9\linewidth}
+                    \inputminted[bgcolor=base3]{python}{./scripts/QCM_t.py}
+                \end{minipage}
+            \end{center}
+
+            Quelle est la valeur de t à la fin de son exécution?
+
+            \begin{tasks}(4)
+                \task \mintinline{python}{[2, 13, 9, 2]}
+                \task \mintinline{python}{[2, 8, 14, 2]}
+                \task \mintinline{python}{[2, 13, 14, 2]}
+                \task \mintinline{python}{[2, 13, 9, 2]}
+            \end{tasks}
+
+
+        \item On considère la fonction suivante:
+
+            \begin{center}
+                \begin{minipage}{0.9\linewidth}
+                    \inputminted[bgcolor=base3]{python}{./scripts/QCM_somme.py}
+                \end{minipage}
+            \end{center}
+
+            Par quelle instruction faut-il remplacer les points de suspension pour que l'appel
+
+            \mintinline{python}{somme([10, 11, 12, 13, 14])} renvoie 60?
+
+            \begin{tasks}(2)
+                \task \mintinline{python}{s = tab[i]}
+                \task \mintinline{python}{s = s + tab[i]}
+                \task \mintinline{python}{tab[i] = tab[i] + s}
+                \task \mintinline{python}{s = s + i}
+            \end{tasks}
+
+        \item On exécute le script suivant:
+
+            \begin{center}
+                \begin{minipage}{0.9\linewidth}
+                    \inputminted[bgcolor=base3]{python}{./scripts/QCM_double.py}
+                \end{minipage}
+            \end{center}
+
+            Quelle est la valeur de m à la fin de son exécution?
+
+            \begin{tasks}(1)
+                \task \mintinline{python}{[ [0, 0, 0, 0, 0], [0, 1, 2, 3, 4], [0, 2, 4, 6, 8] ] }
+                \task \mintinline{python}{[ [0, 0, 0], [0, 1, 2], [0, 2, 4], [0, 3, 6], [0, 4, 8] ] }
+                \task \mintinline{python}{[ [1, 1, 1], [2, 4, 6], [3, 6, 9], [4, 8, 12], [5, 10, 15] ] }
+                \task \mintinline{python}{[ [1, 1, 1, 1, 1], [2, 4, 6, 8, 10], [3, 6, 9, 12, 15], [4, 8, 12, 16, 20], [5, 10, 15, 20, 25] ]}
+            \end{tasks}
+
+        \item L est une liste d'entiers. On définit la fonction suivante
+
+            \begin{center}
+                \begin{minipage}{0.9\linewidth}
+                    \inputminted[bgcolor=base3]{python}{./scripts/QCM_filtre.py}
+                \end{minipage}
+            \end{center}
+
+            Que calcule cette fonction?
+            \begin{tasks}(1)
+                \task le maximum de la liste L passée en argument
+                \task le minimum de la liste L passée en argument
+                \task le premier terme de la liste L passée en argument
+                \task le dernier terme de la liste L passée en argument
+            \end{tasks}
+
+        \item Quelle est la valeur de la variable r à la fin de l'exécution du script suivant?
+
+            \begin{center}
+                \begin{minipage}{0.9\linewidth}
+                    \inputminted[bgcolor=base3]{python}{./scripts/QCM_tuple.py}
+                \end{minipage}
+            \end{center}
+
+            \begin{tasks}(4)
+                \task -9
+                \task 2
+                \task 3
+                \task 6
+            \end{tasks}
+
+
+        \item On définit : \mintinline{python}{[10,9,8,7,6,5,4,3,2,1]}
+
+            Quelle est la valeur de \mintinline{python}{L[L[3]]}
+
+            \begin{tasks}(4)
+                \task 3
+                \task 4
+                \task 7
+                \task 8
+            \end{tasks}
+
+        \item On considère la liste de listes suivantes
+
+            \begin{center}
+                \begin{minipage}{0.9\linewidth}
+                    \inputminted[bgcolor=base3]{python}{./scripts/QCM_tictactoe.py}
+                \end{minipage}
+            \end{center}
+
+            Quelle instruction permet d'obtenir une diagonale de "X"?
+
+            \begin{tasks}(2)
+                \task \mintinline{python}{tictactoe[3] = "X"}
+                \task \mintinline{python}{tictactoe[4] = "X"}
+                \task \mintinline{python}{tictactoe[1][1] = "X"}
+                \task \mintinline{python}{tictactoe[2][2] = "X"}
+            \end{tasks}
+
+        \item On définit ainsi une liste M
+
+            \begin{center}
+                \mintinline{python}{M = [['A','B','C','D'], ['E','F','G','H'], ['I','J','K','L']] }
+            \end{center}
+            Quelle expression vaut la chaîne de caractères 'H'?
+
+            \begin{tasks}(4)
+                \task \mintinline{python}{M[1][3]}
+                \task \mintinline{python}{M[3][1]}
+                \task \mintinline{python}{M(7)}
+                \task \mintinline{python}{M(8)}
+            \end{tasks}
+
+
+
+    \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/06_Listes_et_tuples/index.rst

@@ -0,0 +1,28 @@
+Listes et tuples
+################
+
+:date: 2023-01-22
+:modified: 2023-01-22
+:authors: Benjamin Bertrand
+:tags: Listes, Python
+:category: 1NSI
+:summary: Découverte et manipulation de listes et de tuples
+
+
+Éléments du programme
+=====================
+
+Contenus
+--------
+
+Capacités attendues
+-------------------
+
+Commentaires
+------------
+
+Progression
+===========
+
+Étape 1:
+--------

1NSI/06_Listes_et_tuples/plan_de_travail.tex

@@ -0,0 +1,45 @@
+\documentclass[a4paper,12pt]{article}
+\usepackage{myXsim}
+\usepackage{minted}
+
+\author{Benjamin Bertrand}
+\title{Listes et tuples - Plan de travail}
+\tribe{1NSI}
+\date{janvier 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/06_Listes_et_tuples/scripts/1B_comprehension.py

@@ -0,0 +1,14 @@
+>>> carres = [i**2 for i in range(10)]
+>>> print(carres)
+
+
+>>> moitier_carres = [
+        carre / 2 for carre in carres
+        ]
+>>> print(moitier_carres)
+
+
+>>> impaire = [
+        i for i in range(10) if i % 2
+        ]
+>>> print(impaire)

1NSI/06_Listes_et_tuples/scripts/1B_for.py

@@ -0,0 +1,12 @@
+choses = ["a", 2, -3, 5]
+
+# Parcours sur l'index
+for index in range(len(choses)):
+    print(choses[index])
+
+
+
+
+# Parcours sur les éléments directement
+for element in choses:
+    print(element)

1NSI/06_Listes_et_tuples/scripts/1B_list.py

@@ -0,0 +1,15 @@
+>>> conteneur = [1, -2, 3.3, "ahah", "plop"]
+>>> len(conteneur)
+
+
+>>> conteneur[0]
+
+
+>>> conteneur[3]
+
+
+>>> conteneur[-1]
+
+
+>>> conteneur[0] = "début"
+>>> print(conteneur)

1NSI/06_Listes_et_tuples/scripts/1B_list_list.py

@@ -0,0 +1,5 @@
+>>> L = [
+        ["", "X", ""],
+        ["X", "", "X"],
+        ["", "X", ""]
+        ]

1NSI/06_Listes_et_tuples/scripts/1B_list_list_2.py

@@ -0,0 +1,4 @@
+>>> L[1]
+
+
+>>> L[0}[1]

1NSI/06_Listes_et_tuples/scripts/1B_operation.py

@@ -0,0 +1,10 @@
+>>> conteneur = [1, 2, 3, 5]
+>>> conteneur.append("a")
+>>> print(conteneur)
+
+
+>>> conteneur.remove(1)
+>>> print(conteneur)
+
+
+>>> conteneur + conteneur

1NSI/06_Listes_et_tuples/scripts/2B_tuple.py

@@ -0,0 +1,17 @@
+>>> conteneur = ( 1, -2, 3.3, "ahah", "plop" )
+>>> len(conteneur)
+
+
+>>> conteneur[0]
+
+
+>>> conteneur[3]
+
+
+>>> conteneur[-1]
+
+
+# les méthodes qui suivent ne marchent pas
+>>> conteneur[0] = "début"
+>>> conteneur.append(2)
+>>> conteneur.remove(1)

1NSI/06_Listes_et_tuples/scripts/QCM_double.py

@@ -0,0 +1,6 @@
+m = []
+for i in range(5):
+    n = []
+    for j in range(3):
+        n.append(i*j)
+        m.append(n)

1NSI/06_Listes_et_tuples/scripts/QCM_f.py

@@ -0,0 +1,2 @@
+def f(x):
+    return (x, x**2)

1NSI/06_Listes_et_tuples/scripts/QCM_filtre.py

@@ -0,0 +1,6 @@
+def f(L):
+    m = L[0]
+    for x in L:
+    if x > m:
+        m = x
+    return m

1NSI/06_Listes_et_tuples/scripts/QCM_somme.py

@@ -0,0 +1,5 @@
+def somme(tab):
+    s = 0
+    for i in range(len(tab)):
+        ......
+    return s

1NSI/06_Listes_et_tuples/scripts/QCM_t.py

@@ -0,0 +1,2 @@
+t = [2, 8, 9, 2]
+t[2] = t[2] + 5

1NSI/06_Listes_et_tuples/scripts/QCM_tictactoe.py

@@ -0,0 +1,3 @@
+tictactoe = [['X', 'o', 'o'],
+             ['o', 'o', 'o'],
+             ['o', 'o', 'X']]

1NSI/06_Listes_et_tuples/scripts/QCM_tuple.py

@@ -0,0 +1,2 @@
+t = (10,6,1,12,15)
+r = t[3] - t[1]

1NSI/06_Listes_et_tuples/solutions.tex

@@ -0,0 +1,28 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage{myXsim}
+
+\usetikzlibrary{shapes.geometric}
+
+\author{Benjamin Bertrand}
+\title{Listes et tuples - 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/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
+}