diff --git a/python/tp_intro_turtle/sujet.pdf b/python/tp_intro_turtle/sujet.pdf
index 808e2ff..f522edd 100644
Binary files a/python/tp_intro_turtle/sujet.pdf and b/python/tp_intro_turtle/sujet.pdf differ
diff --git a/python/tp_intro_turtle/sujet.tex b/python/tp_intro_turtle/sujet.tex
index f7e17ef..bb0c1d0 100644
--- a/python/tp_intro_turtle/sujet.tex
+++ b/python/tp_intro_turtle/sujet.tex
@@ -11,7 +11,7 @@ Durée : 1h
 
 % ---
 \section{La tortue de Python}
-Pour pouvoir utiliser la tortue de Python, nous allons écrire la ligne suivante tout en haut de notre fichier python :
+Pour activer la tortue de Python, nous allons écrire la ligne suivante tout en haut de notre fichier python ; veillez à la garder tout le long de l’exercice :
 \begin{minted}{python}
 from turtle import *
 \end{minted}
@@ -35,30 +35,26 @@ Pour tourner sur la gauche de 45° :
 left(45)
 \end{minted}
 
-Pour tourner sur la droite de 45° :
-\begin{minted}{python}
-right(45)
-\end{minted}
-
-
 \section{Triangles, carrés et plus si affinités}
 
-Voici un programme Python qui trace un triangle équilatéral de côté 50px
+Voici un programme Python qui trace deux traits de 100 pixels
 \begin{example}
     \begin{minted}{python}
 forward(50)
 left(120)
-forward(50)
-left(120)
 forward(50)
     \end{minted}
 \end{example}
 
 \begin{exercice}
-    Copiez collez ce programme dans votre éditeur python et exécutez le pour vérifier qu’il trace bien un triangle.\\
+    Copiez collez ce programme dans votre éditeur python et exécutez le pour vérifier qu’il trace bien deux traits.\\
     N’oubliez pas la première ligne (import) qui doit être en haut de chaque programme.
 \end{exercice}
 
+\begin{exercice}
+    Complétez ce programme pour qu’il affiche un triangle.
+\end{exercice}
+
 \begin{exercice}
     Modifiez ce programme Python pour qu’il dessine un carré (polygone régulier à 4 côtés).
 \end{exercice}
@@ -67,72 +63,77 @@ forward(50)
     Une fois que vous arrivez à tracer un carré à l’écran, adaptez le programme pour dessiner un octogone (polygone régulier à 8 côtés).
 \end{exercice}
 
+
+%
+\section{Répétons des instructions}
+\begin{example}
+    Vous aurez remarqué que pour tracer des polygones, on copie colle les instructions forward et left.
+    Pour éviter cette pratique inefficace, nous allons utiliser une boucle pour répéter des instructions.
+    Par exemple, le programme suivant trace un triangle en répétant trois fois les instructions forward et left.
+    \begin{minted}{python}
+for compteur in range(3):
+    forward(100)
+    left(120)
+    \end{minted}
+    \textbf{Pour que des actions soient répétées, il faut qu’elles soient sous la ligne « for » et qu’elles soient précédées de 4 espaces.}
+\end{example}
+\begin{exercice}
+    Recopiez ce programme et exécutez le. Vérifiez qu’il trace bien un triangle.
+\end{exercice}
+\begin{exercice}
+    Modifiez ce programme pour qu’il trace un carré, puis un hexagone. Quelles modifications faites vous ?
+\end{exercice}
+
+%
 \section{Des variables}
-Il commence à être fatigant de recopier toujours les mêmes chiffres.\\
-Nous allons utiliser deux variables qui nous permettent de stocker une valeur en mémoire pour la réutiliser plus tard.\\
-Ici, la variable $angle$ contiendra l’angle en degrés entre chaque côtés du polygone et la variable $longueur\_cote$ contiendra la longueur d’un côté en pixels.
+Nous allons essayer de modifier le programme pour qu’il soit capable de tracer n’importe quel polygone.
+Nous aurons besoin d’une variable, contenant le nombre de côtés du polygone.
+Le reste du programme tracera ce polygone.
 \begin{example}
-    Ce programme python trace un triangle équilatéral de côté 50px
+    Ce programme python trace un triangle équilatéral.
     \begin{minted}{python}
-# Dans un premier temps, on fixe les valeurs de nos variables
-angle = 120
-longueur_cote = 50
-# Dans un second temps, on les utilise pour notre programme
-forward(longueur_cote)
-left(angle)
-forward(longueur_cote)
-left(angle)
-forward(longueur_cote)
+nb_cotes = 3
+for compteur in range(nb_cotes):
+    forward(100)
+    left(360/nb_cotes)
     \end{minted}
-    Il est strictement équivalent au programe de l’exemple 1.
-    Mais il est maintenant possible de changer tous les angles d’un coup en modifiant la valeur de la variable $angle$ à la ligne 2 !\\
 \end{example}
 
 \begin{exercice}
-    À l’aide des deux variables de l’exemple précédent, tracez un polygone régulier à 16 côtés.
-    \\\textbf{Faites vérifier le programme par le professeur}\\
+    Recopiez ce programme et vérifiez qu’il trace bien un triangle.
 \end{exercice}
 
-\section{Des boucles}
+\begin{exercice}
+    Modifiez la valeur stockée dans la variable nb\_cotes (vous pouvez par exemple mettre 4, 6, 8 ou 180). Que se passe t’il ?
+\end{exercice}
+
+
+\section{Écrire un sous-programme}
+Pour tracer plusieurs polygone, il nous faudrait copier-coller notre programme.
+Le résultat serait difficile à lire et donc à comprendre…
+Nous allons créer une fonction (c’est un sous-programme) capable de tracer n’importe quel polygone.
+Nous pourrons alors exécuter ce sous-programme dès que besoin.
 \begin{example}
-    Une boucle sert à répéter une instruction un nombre précis de fois.
-    Par exemple, la boucle suivante sert à répéter l’action « avancer de 10 pixels » 180 fois :
     \begin{minted}{python}
-for compteur in range(180):
-    forward(10)
+def polygone(nb_cotes):
+    for compteur in range(nb_cotes):
+        forward(100)
+        left(360/nb_cotes)
+polygone(3)
+polygone(5)
     \end{minted}
-    \textbf{Pour qu’une action soit répétée, il faut qu’elle soit sous la ligne « for » et qu’elle soit précédée de 4 espaces.}
 \end{example}
+
 \begin{exercice}
-    Tracez maintenant un polygone régulier à 180 côtés.
-    Vous vous aiderez d’une boucle.
+    Recopiez ce programme et vérifier qu’il trace bien deux polygone. Vous pouvez maintenant en une seule ligne, tracer le polygone de votre choix.
 \end{exercice}
 
-
-\section{Polygones en folie}
-Nous allons ajouter une dernière variable à notre programme python. Elle se nome $nombre_cotes$ et représente le nombre de côtés du polygone que l’on veut tracer.
-\begin{exercice}
-    Écrivez un programme python qui est capable de tracer n’importe quel polygone ayant un nombre de côtés définis par la variable $nombre\_cotes$.
-    \\
-    \textbf{Faites vérifier le programme par le professeur}\\
-    Le programme commencera par ces lignes :
-    \begin{minted}{python}
-nombre_cotes = 6
-longueur_cote = 20
-    \end{minted}
-\end{exercice}
-
-% Le damier est assez dur à faire sans fonctions, il a occupé tous les élèves rapides que j’ai eu.
 \section{Damier (Bonus)}
 On peut colorier nos polygones à l’aide des fonctions « begin\_fill » et « end\_fill ».
 Voici l’exemple d’un triangle que l’on remplit :
 \begin{minted}{python}
 begin_fill()
-forward(50)
-left(120)
-forward(50)
-left(120)
-forward(50)
+polygone(4)
 end_fill()
 \end{minted}
 
@@ -142,12 +143,9 @@ end_fill()
     \\\textbf{Faites vérifier le programme par le professeur}
     \\Indices :
     \begin{itemize}
-        \item La première ligne du damier peut être vue comme la répétition d’un couple « case blanche + case noire ».
-        \item La seconde ligne du damier est la répétition d’un couple « Case noire + case blanche ».
-        \item On peut faire dans un premier temps une boucle qui dessine la première ligne.
-        \item On peut ensuite écrire les instructions permettant de se placer pour pouvoir dessiner la seconde ligne.
-        \item Dans un troisième temps on peut faire la boucle qui dessine la seconde ligne.
-        \item Finalement, on peut répéter les opérations précédentes 3 fois pour tracer tout le damier.
+        \item Écrivez une fonction carre() traçant un carré et carreN() traçant un carré noir. Vous pourrez ainsi construire le damier à l’aide de ces deux fonctions.
+        \item Écrivez une fonction ligne() qui trace une ligne de damier.
+        \item Essayez ensuite d’exécuter la fonction ligne() pour tracer le damier.
     \end{itemize}
 \end{exercice}