SNT : publication des chapitres 2 et 3 de programmation

sequences/programmation/README.md

@@ -18,11 +18,11 @@ flowchart LR;
     D-->E[5. Les boucles];
     E-->F[6. Les fonctions];
     
-    click A "./programmation/GENERALITES.md" "Lien vers 1. Généralités" _self
-    click B "./programmation/SPYDER.md" "Lien vers 2. Prise en main de Python" _self
-    click C "./programmation/chapitre_1/" "Lien vers 3. Les variables" _self
-    click D "./programmation/chapitre_2/" "Lien vers 4. Les instructions conditionnelles" _self
-    click E "./programmation/chapitre_3/" "Lien vers 5. Les boucles" _self
+    click A "https://florianmathieu.prof/hub-docs/snt/sequences/programmation/GENERALITES/" "Lien vers 1. Généralités" _self
+    click B "https://florianmathieu.prof/hub-docs/snt/sequences/programmation/SPYDER/" "Lien vers 2. Prise en main de Python" _self
+    click C "https://florianmathieu.prof/hub-docs/snt/sequences/programmation/chapitre_1/" "Lien vers 3. Les variables" _self
+    click D "https://florianmathieu.prof/hub-docs/snt/sequences/programmation/chapitre_2/" "Lien vers 4. Les instructions conditionnelles" _self
+    click E "https://florianmathieu.prof/hub-docs/snt/sequences/programmation/chapitre_3/" "Lien vers 5. Les boucles" _self
 ```
 
 ## Attendus du Programme

sequences/programmation/chapitre_1/README.md

@@ -162,7 +162,7 @@ Indiquez le type des variables permettant de stocker (sur votre smartphone) les
 | le pourcentage affiché de batterie restante | |
 | les notes aux deux derniers devoirs de Mathématiques de l'année dernière | |
 
-## 4.2. Type entier (int)
+### 4.2. Type entier (int)
 
 Pour affecter (on dit aussi assigner) la valeur 17 à la variable nommée `age`
 
@@ -185,7 +185,7 @@ La fonction `type` renvoie le type de la variable :
 ```
 
 
-## 4.3. Type flottant (float)
+### 4.3. Type flottant (float)
 
 Pour affecter (on dit aussi assigner) la valeur 1,70 à la variable nommée `taille`
 
@@ -213,7 +213,7 @@ La notation scientifique est acceptée :
 170.0
 ```
 
-## 4.4. Type chaine de caractères (str)
+### 4.4. Type chaîne de caractères (str)
 
 Pour affecter (on dit aussi assigner) la valeur `lundi` à la variable nommée `jour`
 
@@ -304,7 +304,7 @@ Selon les résultats obtenus, que permet d'obtenir l'utilisation des crochets su
 
 Par convention, on appelle _indice_ les valeurs entre crochets.
 
-## 4.X Conversion de type
+### 4.5. Conversion de type
 
 Cependant, on ne peut pas ajouter n'importe quoi.
 
@@ -360,7 +360,7 @@ Dans le langage Python, il y a des règles à respecter pour nommmer les variabl
 1. Quels sont les noms de variables incorrects parmi ceux proposés ? Vous indiquerez pourquoi.
 
 | Noms de variable | Correct ou Incorrect | Pourquoi (si Incorrect) |
-| :--:| :--: | :-- | 
+| :--: | :--: | :-- |
 | `prix achat` | | |
 | `prix_achat` | | |
 | `note` | | | 
@@ -409,7 +409,7 @@ Exemple :
 La fonction `help` affiche l'aide, c'est-à-dire ce que fait la fonction
 
 ```python
->>> help(math.sqrt)
+>>> help(sqrt)
 Help on built-in function sqrt in module math:
 
 sqrt(x, /)
@@ -434,7 +434,7 @@ Bilan : La fonction `input` permet d'obtenir une valeur saisie par l'utilisateur
 
 ___N.B : La valeur saisie est toujours du <type 'str'>___
 
-## 6. Exercices
+## 8. Exercices
 
 ### Exercice 1
 

sequences/programmation/chapitre_2/README.md

@@ -0,0 +1,374 @@
+# TD - Les instructions conditionnelles
+
+> « _Si j'aurais su, j'aurais pas venu_ », réplique du Petit Gibus dans le film "La Guerre des boutons" d'Yves Robert.
+
+## 1. Définition
+
+> Une __instruction conditionnelle__ permet de faire des choix en fonction de la valeur d’une __condition__. On parle souvent d’une instruction _si-alors_, ou _if-else_ en anglais.
+
+En reprenant (et corrigeant) la citation du Petit Gibus, l'instruction conditionnelle devient « _Si j'avais su alors je ne serais pas venu_ ».
+
+> Une __condition__ est une instruction qui est soit vraie, soit fausse. On parle alors d’une _instruction booléenne_ ou _variable booléenne_.
+
+Par exemple, si une variable `note_francais` vaut 5 et qu’une variable `note_anglais` vaut 10 alors la condition `note_francais < note_anglais` est une condition qui est vraie, tandis que les conditions `note_francais > note_anglais` et `note_francais == note_anglais` sont fausses.
+
+## 2. Comparaisons de variables
+
+Les opérateurs de comparaisons sont :
+
+- `<` : inférieur
+- `<=` : inférieur ou égal
+- `>` : supérieur
+- `>=` : supérieur ou égal
+- `==` : est égal à
+- `!=` : est différent de
+
+Le résultat d'une comparaison est toujours un booléen
+
+- `True` si la comparaison est vraie
+- `False` si la comparaison est fausse
+
+Remarque : on ne peut comparer que des objets comparables
+
+⚠ ___ATTENTION___ : le test d'égalité entre deux variables se fait avec un double égal `==` (car le simple `=` permet d'affecter une valeur à une variable, cf. Activité 1).
+
+### 2.1 À faire
+
+1. Déterminer (sans les exécuter) chaque instruction ci-dessous :
+
+```python
+>>> a = 5
+>>> b = 18 
+>>> c = 12.3
+>>> mot1 = "Hello"
+>>> mot2 = "World"
+# 
+>>> print(a > b)
+#
+>>> print(b // a == 3)
+#
+>>> print(b % a == 3)
+#
+>>> print(a - b > 2)
+#
+>>> print(type(c) == float)
+#
+>>> print(mot1 != mot2)
+#
+>>> print(mot1 < mot2)
+#
+>>> print(mot1 > 2)
+```
+
+2. Vérifier les résultats attendus avec les résultats constatés
+
+Dans une suite d'instructions on est souvent amené à faire des choix.
+
+## 3. Cas : Si...Alors
+
+**Si** une ou plusieurs conditions sont réalisées **Alors** on exécute une ou plusieurs instructions
+
+La structure en Python : On __indente__ (une tabulation) les instructions qui doivent s'exécuter si la condition est vérifiée
+
+```
+if condition :
+    instruction1
+    instruction2
+```
+
+Exemple qui affiche si les variables `a` et `b` sont des entiers pairs
+
+```python
+a = 12
+if a % 2 == 0:
+    print(a, " est un entier pair")
+    
+b = 13
+if b % 2 == 0:
+    print(b," est un entier pair")
+```
+
+## 4. Cas : Si ...Alors...Sinon
+
+Dans cette structure, si la ou les conditions sont vraies, les instructions 1 et 2 sont exécutées. Sinon c'est l'instruction3 qui est exécutée.
+
+```
+    if condition:
+        instruction1
+        instruction2
+    else:
+        instruction3
+```
+
+Exemple :
+
+```python
+a = 12
+
+if a % 2 == 0:
+    print(a, " est un entier pair")
+else:
+    print(a," est un entier impair")
+```
+
+## 5. Cas : Si...Alors...Sinon Si
+
+Dans cette structure on teste plusieurs conditions
+
+```
+    if condition1:
+        instruction1
+    elif condition2:
+        instruction2
+        instruction3
+    elif condition3:
+        instruction4
+    else:
+        instruction5
+```
+
+Exemple :
+
+Imaginons les conditions de passage d'un piéton en fonction du feu de signalisation et du nombre de voitures passantes :
+
+```python
+if feu == 'VERT':
+    print('Piéton, vous pouvez passer')
+elif voitures == 0:  # le feu est rouge
+    print('Piéton, vous pouvez passer mais attention')
+else:  # le feu est rouge et il y a des voitures
+    print('Piéton, vous ne pouvez passer')
+```
+
+### À Faire
+
+Soit l'algorithme qui détermine la réponse de Yoda en fonction de la taille qui lui est communiquée :
+
+```txt
+  Demander la taille
+  Si la taille est supérieure à 1m80 alors
+	la réponse est 'Maître, vous vous prenez pour Chewbacca'
+  Sinon si la taille est supérieure à 1m20 alors
+    la réponse est 'Maitre, vous vous prenez pour Luc Skywalker'
+  Sinon si la taille est supérieure à 0.80m alors
+    la réponse est "Maitre, ce n'est pas la taille qui compte"
+  Sinon la réponse est 'Maitre, vous vous sous-estimez'
+```
+
+Compléter le code suivant pour qu'il implante l'algorithme ci-dessus :
+
+```python
+taille = input('Combien mesures-tu ?')
+...
+print(reponse)
+```
+
+
+```python
+
+```
+
+## Exercices
+
+### Exercice 1
+
+L’indice de masse corporelle (IMC) est le seul indice validé par l’Organisation mondiale de la santé pour évaluer la corpulence d’un individu et donc les éventuels risques pour la santé.
+
+La formule de calcul a été vu lors de l'activité 1 sur les variables.
+
+L'OMS fournit l'interprétation suivante de l'état de santé en fonction de l'IMC :
+
+| Indice de masse corporelle (IMC) | Interprétation (d'après l'OMS) | 
+| :--: | :--: |
+| moins de 18,5	| Insuffisance pondérale (maigreur) |
+| 18,5 à 25 |	Corpulence normale |
+| 25 à 30 | Surpoids |
+| 30 à 35 | Obésité modérée |
+| 35 à 40 | Obésité sévère |
+| plus de 40	| Obésité morbide ou massive |
+
+Voici une liste de caractéristiques de célébrités anonymisées (i.e le nom a été changé par décence). 
+
+| Célébrité | Taille (en cm) | Poids (en kg) |
+| :--: | :--: | :--: |
+| B | 169 | 56 |
+| E | 157 | 48 |
+| A | 175 | 90 |
+| M | 205 | 200 |
+| V | 163 | 42 |
+| P | 170 | 75 |
+| S | 191 | 113 |
+
+Écrire un programme qui permet d'afficher l'état de santé en fonction de l'IMC, selon l'OMS. Vous pouvez compléter le tableau en fonction de vos résultats.
+
+
+```python
+
+```
+
+### Exercice 2
+
+1. Écrire un programme qui demande 3 entiers de manières consécutives et affiche le minimum des 3 entiers
+2. Écrire un programme qui demande 3 entiers de manières consécutives et affiche le maximum des 3 entiers
+
+
+```python
+
+```
+
+### Exercice 3
+
+Écrire un programme pour vérifier si un nombre saisi par un utilisateur est divisible par 3 et 13 ou non,
+
+
+```python
+
+```
+
+### Exercice 4
+
+Écrire un programme pour vérifier si un caractère saisi par l'utilisateur est une voyelle ou une consonne.
+
+
+```python
+
+```
+
+### Exercice 5
+
+Écrire un programme pour entrer le numéro du jour de la semaine (1-7) et affiche le nom du jour de la semaine correspondant
+
+
+```python
+
+```
+
+### Exercice 6
+
+Modifier le code suivant pour qu'il y ait 4 couleurs différentes en fonction de la position(abscisse) de la souris
+
+**mouseX** renvoie l'abscisse de la souris (0 pour le coin supérieur gauche de la fenêtre)
+
+( 0 à 50 , 50 à 100, 100 à 150 et 150 à 200)
+
+```python
+from p5 import *
+
+def setup():
+    createCanvas(200,200) # crée une fenêtre de 200 x 200 pixels
+
+def draw():# cette fonction s'exécute  en boucle 60 fois par seconde...
+    # les conditions pour la couleur du fond d'écran
+    if mouseX > 0 and mouseX < 100: # teste la position (abscisse) de la souris sur la moité gauche (0 à 100)
+        background(255,120,0) # 
+    elif mouseX > 100 and mouseX < 200:# teste la position (abscisse) de la souris sur la moité droite (100 à 200)
+        background(0,255,120) #
+    else:
+        background(0,0,255) # fond bleu
+run()
+```
+
+
+```python
+
+```
+
+### Exercice 7
+
+Reprendre le code précédent(copier-coller) et en utilisant les instructions **mouseX** et **mouseY** (qui renvoie abscisse et ordonnée de la souris), faites en sorte qu'il y ait 4 couleurs différentes qui s'affichent suivant la position de la souris dans les quadrants:
+
+- 0 < mouseX <100 et 0 < mouseY < 100, la couleur affichée doit être le bleu
+- 100 < mouseX < 200 et 0 < mouseY < 100, la couleur affichée doit être le vert
+- 0 < mouseX < 100 et 100 < mouseY < 200, la couleur affichée doit être le rouge
+- 100 < mouseX < 200 et 100 < mouseY < 200, la couleur affichée doit être le jaune
+
+
+```python
+
+```
+
+### Exercice 8
+
+Dans le code suivant on affiche dans la fenêtre 4 cercles et la couleur de fond change si la souris survole l'un des cercles.
+
+- l'instruction **circle(50,50,40)** dessine un cercle de centre (50,50 ) et de diamètre 40.
+- l'instruction **dist(x1,y1,x2,y2)** calcule la distance entre les points de coordonnées (x1,y1) et (x2,y2).
+- **dist(mouseX,mouseY,50,50) < 20** teste si la souris est dans l'un des cercles.
+
+Compléter le code de façon que le fond change de couleur au survol des 4 cercles.
+
+```python
+from p5 import *
+
+def setup():
+    createCanvas(200,200) # crée une fenêtre de 200 x 200 pixels
+
+def draw():# cette fonction s'exécute  en boucle 60 fois par seconde...
+    if dist(mouseX,mouseY,50,50) < 20:
+        background(255,255,0)
+    # à modifier ici
+    else:
+        background(51,51,51)
+    # ne pas modifier...
+    fill(0,0,0)
+    circle(50,50,40)
+    circle(150,150,40)
+    circle(150,50,40)
+    circle(50,150,40)
+    
+run()
+```
+
+
+```python
+
+```
+
+### Exercice 9
+
+Le code ci-dessous montre "une balle" se déplaçant sur un axe horizontal dans une fenêtre en rebondissant sur les bords.
+
+Compléter le code de telle sorte que la balle se déplace aussi dans la verticale en rebondissant sur les bords inférieur et supérieur de la fenêtre.
+
+```python
+from p5 import *
+
+def setup():
+    global bx,by,vx,vy,r
+    r = 20
+    bx = 50
+    by = 50
+    vx = 4
+    vy = 5
+    createCanvas(400,200) # crée une fenêtre de 200 x 200 pixels
+
+def draw():# cette fonction s'exécute  en boucle 60 fois par seconde...
+    global bx,by,vx,vy,r
+    background(0,0,0)# fond noir
+    # mouvement du cercle sur l'axe horizontal
+    bx = bx + vx
+    # rebond sur les bords gauche et droit
+    if bx < r or bx > 400 - r:
+        vx = -vx
+    # dessin du cercle
+    fill(255,0,0)
+    circle(bx,by,2*r)    
+    
+run()
+```
+
+
+```python
+
+```
+
+### Exercice 10
+
+Reprendre le code précédent et faire en sorte que la "balle" change de couleur à chaque rebond
+
+Pour utiliser une couleur aléatoire, on pourra utiliser l'instruction: `fill(random(255),random(255),random(255))`
+
+
+```python
+
+```

sequences/programmation/chapitre_3/README.md

@@ -0,0 +1,253 @@
+# TD - Les boucles
+
+## 1. Définition
+
+Souvent, dans un programme, il est nécessaire de répéter un certain nombre de fois une (ou des) instruction(s). Pour cela, on utilise ce qu'on appelle des __boucles__.
+
+### 1.1. Exemple introductif
+
+Le nombre d'utilisateurs d'un nouveau réseau social _KILESTBIEN_ est égal à 500 000 en janvier 2020. Ce nombre augmente de 5 % par mois, donc est multiplié par 1.05 chaque mois. Si on veut connaître le nombre d'utilisateurs 10 mois plus tard, il faut effectuer 10 fois de suite le même calcul (une multiplication par 1.05).
+
+### 1.2. À Faire 
+
+Compléter le programme Python suivant afin d'obtenir le nombre d'utilisateurs du réseau _KILESTBIEN_ au bout de 10 mois.
+
+```python
+nb_utilisateurs = 500000
+nb_utilisateurs = nb_utilisateurs * 1.05
+???
+print(???)
+```
+
+
+```python
+
+```
+
+### 1.3. Problématique
+
+Des banquiers veulent investir 1 million d'euros dans _KILESTBIEN_, mais ont une exigence. Ils souhaitent que le nombre d'utilisateurs du réseau soit au moins de 3 millions dans 3 ans.
+
+Selon le taux de croissance du nombre d'utilisateurs de 5% par mois, vont-ils investir dans _KILESTBIEN_ ? Que faut-il modifier dans le programme précédent pour répondre à cette question ?
+
+## 2. Boucles bornées
+
+Au lieu d'écrire 10 ou 36 lignes identiques il est préférable d'écrire une seule fois cette ligne et d'indiquer de l'exécuter 10 ou 36 fois : pour cela, on utilise une __boucle bornée__. En Python, au lieu d'écrire le programme du 1. À Faire, il est possible d'écrire :
+
+```python
+nb_utilisateurs = 500000
+for i in range(10):
+    nb_utilisateurs = nb_utilisateurs * 1.05
+print(nb_utilisateurs)
+```
+
+### 2.1. Construction d'une boucle bornée
+
+Pour écrire une boucle bornée en Python on utilise le mot-clé `for`. Les boucles bornées sont par conséquent très souvent appelées *boucles for* (ou *boucles pour* en français).
+
+### 2.2. Utilisation de la fonction `range()`
+
+- La fonction `range` permet de générer un intervalle sous la forme d'une liste d'entiers. Par exemple, l'appel  `range(n)` génère $n$ entiers : $0, 1, 2, ..., n-1$. 
+- ⚠ Attention : comme le premier entier est 0, le n-ième est numéroté $n - 1$.
+- La variable notée `i` prendra successivement (à chaque tour de boucle) les valeurs générées par la fonction `range`. Ici, `i` prendra les valeurs 0 puis 1 puis 2, ..., puis $n - 1$.
+- Le bloc d'instructions à répéter doit être indenté (d'une tabulation) et sera donc ici exécuté $n$ fois.
+
+#### 2.2.1. À Faire
+
+On considère le programme Python suivant.
+
+```python
+a = 2
+for i in range(4):
+    a = a + 1
+    print(a)
+```
+
+1. Quel est le bloc d'instructions répété dans la boucle `for` ?
+2. Combien de fois est-il répété ?
+3. Combien de valeurs sont affichées au cours de l'exécution de ce programme ?
+4. Quelle est la valeur finale de la variable `a` ?
+
+#### 2.2.2. À Faire
+
+On considère le programme Python suivant :
+
+```python
+a = 1
+b = 5
+for i in range(3):
+    a = 2 * a
+    b = b + a
+print(b)
+```
+
+On va commencer par analyser le code pour le comprendre.
+
+1. Quel est le bloc d'instructions répété dans la boucle `for` ? Combien de fois est-il répété ?
+2. Expliquez pourquoi il n'y a qu'une seule valeur qui s'affiche dans la console si on exécute le code ?
+3. Recopiez et complétez le tableau ci-dessous avec les valeurs des variables `i`, `a` et `b` à chaque tour de boucle.
+
+| `i`  | `a`  |  `b`  |
+| :--: | :--: | :---: |
+|      |  1   |   5   |
+|  0   | ???  | ??? |
+| ???  | ???  |  ???  |
+| ???  | ???  |  ???  |
+
+4. Quelle est la valeur finale de la variable `b` ?
+5. Exécutez ensuite le code et vérifiez ce qu'il produit.
+
+
+```python
+
+```
+
+## 3. Exercices
+
+### Exercice 1 - La punition
+
+L'article 2.2 Les punitions scolaires d'une circulaire ministérielle du 13 Juillet 2000 rappelle qu' « _Il convient également de distinguer soigneusement les punitions relatives au comportement des élèves de l'évaluation de leur travail personnel. Ainsi n'est-il pas permis de baisser la note d'un devoir en raison du comportement d'un élève ou d'une absence injustifiée. Les __lignes et les zéros doivent également être proscrits__._»
+
+Votre professeur était élève bien avant cette circulaire et a souvent été puni avec pour sanction le fait de devoir copier 100 fois sur une feuille la phrase suivante : "_Je ne discuterai plus avec mon camarade de classe pendant les cours_."
+
+Écrire un programme Python qui permet de facilement transcire la punition.
+
+
+```python
+
+```
+
+### Exercice 2 - Table de Multiplication
+
+1. Recopiez le programme suivant :
+
+```python
+nombre = int(input("De quel nombre voulez-vous la table de multiplication ? "))
+
+for compteur in range(10):
+	print(nombre)
+```
+
+2. Modifiez ce programme pour qu'il affiche la table de multiplication du nombre demandé, de 0 à 10. Par exemple, si l'utilisateur donne la valeur 6, le programme devrait afficher : 0, 6, 12, 18, …, 60.
+
+
+```python
+
+```
+
+### Exercice 3 - Problème de l'échiquier de Sissa
+
+Selon [la légende](https://fr.wikipedia.org/wiki/Problème_de_l'échiquier_de_Sissa), pour remercier l'inventeur des échecs Sissa, le roi lui demanda de choisir sa récompense. Sissa demanda alors du riz : __un grain sur la première case, deux grains sur la seconde case, quatre grains sur la troisième case, huit grains sur la quatrième, et ainsi de suite jusqu'à la dernière case du jeu d'échec__. Le roi accepta.
+
+On se demande combien de grains seront posés sur la dernière case du plateau d'échecs (qui en compte 64).
+
+Pour résoudre ce problème, on peut utiliser le programme suivant :
+
+```python
+grains = 1
+
+for compteur in range(???):
+    grains = ???
+
+print("Nombre de grains sur la dernière case :", grains)
+```
+
+1. Compléter ce programme, et exécutez-le.
+2. Combien de grains de riz y aura-t-il sur la dernière case de l'échiquier ?
+
+
+```python
+
+```
+
+### Exercice 4 - Petite tortue qui dessine
+
+Le module `turtle` (*tortue*) permet de dessiner avec Python.
+
+Dans cet exercice on veut écrire un programme qui permet de dessiner des formes géométriques. Voici le code incomplet du programme.
+
+```python
+import turtle  # pour utiliser le module turtle
+
+"""Fonction qui dessine un carré de coté 100 pixels"""
+turtle.forward(100)  # pour avancer de 100 pixels
+turtle.left(90)  # pour tourner de 90° à gauche
+turtle.forward(100)
+turtle.left(90)
+# À Compléter
+
+turtle.done()  # pour afficher le dessin
+```
+1. Modifiez le programme afin que la tortue dessine un `carré`, en utilisant une boucle `for`.
+2. Modifiez le programme afin que la tortue dessine un `triangle`, en utilisant une boucle `for`.
+3. Modifiez le programme afin que la tortue dessine un `octogone`, en utilisant une boucle `for`.
+
+
+```python
+
+```
+
+## 4. Boucle bornée avec le mot-clé `in`
+
+Comme on l'a vu précédemment, il est possible de créer une boucle bornée en utilisant le mot-clé `in` associé au mot clé `range`. Cela permet de répéter les mêmes instructions sur un intervalle.
+
+Cette section va nous permettre de voir une autre utilisation de la boucle bornée. En effet, il est possible d'itérer sur tous les éléments de certaines variables en utilisant le mot clé `in` de la façon suivante :
+
+```python
+for element in variable:  # se traduit pas "pour chaque element de variable"
+    bloc_instructions
+```
+
+**Remarques** :
+
+- `variable` peut être une chaîne de caractères (type `str`) ou une liste (type `list`).
+- Dans ce cas, la variable `element` prend successivement chacune des valeurs de `variable`.
+
+### 4.1. À Faire
+
+1. Copier et exécuter le code suivant.
+```python
+a = "SNT"
+for lettre in a:
+	print(lettre)
+```
+2. Quel est le résultat obtenu ?
+
+
+```python
+
+```
+
+## 5. Compléments sur la fonction range
+
+Dans les paramètres de la fonction `range` il est également possible de préciser une première valeur (si on ne veut pas commencer à zéro) ainsi que le pas (si on ne veut pas que les itérations se fassent de 1 en 1).
+
+Après avoir regardé la [vidéo](https://www.youtube.com/watch?v=07IGOcpiE7o), répondez aux questions qui suivent. Vous vérifierez ensuite en utilisant un éditeur de code Python.
+
+1. Quelles sont les valeurs affichées dans la console lors de l'exécution de chacun des programmes ci-dessous ? *Attention, il faut répondre sans exécuter le code !*
+
+2. - Programme 1 :
+
+     ```python
+     for i in range(10):
+         print(i)
+     ```
+   - Programme 2 :
+
+     ```python
+     for k in range(2, 10):
+         print(k)
+     ```
+   - Programme 3 :
+
+     ```python
+     for ind in range(2, 10, 3):
+         print(ind)
+     ```
+
+3. Exécutez successivement les trois codes et vérifiez vos réponses à la question précédente.
+
+
+```python
+
+```