Le déroulement d'une boucle
Exécuter une boucle à la main, tour par tour
Dérouler une boucle, c'est faire à la main ce que fait Python : exécuter le corps de la boucle un tour à la fois, en notant après chaque tour la valeur de chaque variable.
On note tout dans une table de trace : une ligne par tour, une colonne par variable.
Voir pourquoi le programme affiche ce qu'il affiche.
Trouver la sortie d'un code sans l'exécuter (examens !).
Trouver le tour exact où une variable prend une mauvaise valeur.
Chaque colonne a un rôle précis :
| Tour | Variables | Condition testée | Sortie |
|---|---|---|---|
| numéro du tour : 1, 2, 3... | valeur de chaque variable après le tour | le test et son résultat, Vrai ou Faux | ce que print affiche pendant le tour |
while, on note aussi le dernier test, celui qui est faux et qui fait sortir.for, il n'y a pas de condition : la boucle s'arrête quand range n'a plus de valeurs.forCode
range(5) fournit 0, 1, 2, 3, 4 : cinq tours, et i ne vaut jamais 5.
Table de trace
| Tour | i | Sortie |
|---|---|---|
| 1 | 0 | 0 |
| 2 | 1 | 1 |
| 3 | 2 | 2 |
| 4 | 3 | 3 |
| 5 | 4 | 4 |
| fin | range(5) est épuisé |
for avec un calculCode
La borne de fin est exclue : range(1, 6) s'arrête à 5.
Table de trace
| Tour | i | carre | Sortie |
|---|---|---|---|
| 1 | 1 | 1 | 1 |
| 2 | 2 | 4 | 4 |
| 3 | 3 | 9 | 9 |
| 4 | 4 | 16 | 16 |
| 5 | 5 | 25 | 25 |
| fin | après 5 |
whileCode
La condition est testée 4 fois pour 3 tours : le dernier test, faux, fait sortir de la boucle.
Table de trace
| Tour | i | Condition testée | Sortie |
|---|---|---|---|
| 1 | 0 → 1 | 0 < 3 : Vrai | 0 |
| 2 | 1 → 2 | 1 < 3 : Vrai | 1 |
| 3 | 2 → 3 | 2 < 3 : Vrai | 2 |
| sortie | 3 | 3 < 3 : Faux | fin de la boucle |
Une variable qui grossit à chaque tour
Code (R05)
Table de trace
| Tour | i | somme | Condition testée |
|---|---|---|---|
| départ | 1 | 0 | |
| 1 | 2 | 1 | 1 <= 5 : Vrai |
| 2 | 3 | 3 | 2 <= 5 : Vrai |
| 3 | 4 | 6 | 3 <= 5 : Vrai |
| 4 | 5 | 10 | 4 <= 5 : Vrai |
| 5 | 6 | 15 | 5 <= 5 : Vrai |
| sortie | 6 | 15 | 6 <= 5 : Faux |
Sortie, avec la saisie 5
Code (R05, exercice 1)
ancien_resultat garde la valeur d'avant la multiplication, sinon on ne pourrait plus l'afficher.
Table de trace (saisie : 5)
| Tour | i | ancien_resultat | resultat | Sortie |
|---|---|---|---|---|
| départ | 1 | |||
| 1 | 1 | 1 | 1 | 1 x 1 = 1 |
| 2 | 2 | 1 | 2 | 1 x 2 = 2 |
| 3 | 3 | 2 | 6 | 2 x 3 = 6 |
| 4 | 4 | 6 | 24 | 6 x 4 = 24 |
| 5 | 5 | 24 | 120 | 24 x 5 = 120 |
Code (R05, exercice 2)
Table de trace (saisie : 5)
| i | ftemp | f0 | f1 | resultat |
|---|---|---|---|---|
| départ | 0 | 1 | "" | |
| 0 | 0 | 1 | 1 | "0 " |
| 1 | 1 | 1 | 2 | "0 1 " |
| 2 | 1 | 2 | 3 | "0 1 1 " |
| 3 | 2 | 3 | 5 | "0 1 1 2 " |
| 4 | 3 | 5 | 8 | "0 1 1 2 3 " |
| 5 | 5 | 8 | 13 | "0 1 1 2 3 5 " |
Sortie : 0 1 1 2 3 5
Pourquoi ftemp ? Déroulons la boucle sans lui :
Dès le premier tour, f1 vaut le double de f0 : on obtient les puissances de 2, pas Fibonacci. ftemp met l'ancienne valeur de côté avant qu'elle soit écrasée.
| i | f0 | f1 | resultat |
|---|---|---|---|
| départ | 0 | 1 | "" |
| 0 | 1 | 2 | "0 " |
| 1 | 2 | 4 | "0 1 " |
| 2 | 4 | 8 | "0 1 2 " |
| 3 | 8 | 16 | "0 1 2 4 " |
| 4 | 16 | 32 | "0 1 2 4 8 " |
| 5 | 32 | 64 | "0 1 2 4 8 16 " |
Sortie : 0 1 2 4 8 16 au lieu de 0 1 1 2 3 5
Code (R05)
En déroulant, on le voit tout de suite : la ligne se répète à l'identique. Aucune variable de la condition ne change, donc le test ne deviendra jamais faux.
Table de trace
| Tour | i | Condition testée | Sortie |
|---|---|---|---|
| 1 | 0 | 0 < 15 : Vrai | 0 |
| 2 | 0 | 0 < 15 : Vrai | 0 |
| 3 | 0 | 0 < 15 : Vrai | 0 |
| 4 | 0 | 0 < 15 : Vrai | 0 |
| ... | toujours 0 | toujours Vrai | ... |
Remplir la table avant de dévoiler
Déroulez ce code dans une table de trace. Quelle sera la sortie ?
Code
Table de trace (avancer pour dévoiler)
| Tour | i | x | Sortie |
|---|---|---|---|
| départ | 1 | ||
| 1 | 0 | 2 | 2 |
| 2 | 1 | 4 | 4 |
| 3 | 2 | 8 | 8 |
| 4 | 3 | 16 | 16 |
Déroulez ce code. Combien de tours ? Quelle est la valeur de compte à la sortie ?
Code
4 tours, et compte sort à -2 : la condition compte > 0 ne cherche pas à tomber pile sur 0.
Table de trace (avancer pour dévoiler)
| Tour | compte | Condition testée | Sortie |
|---|---|---|---|
| 1 | 10 → 7 | 10 > 0 : Vrai | 10 |
| 2 | 7 → 4 | 7 > 0 : Vrai | 7 |
| 3 | 4 → 1 | 4 > 0 : Vrai | 4 |
| 4 | 1 → -2 | 1 > 0 : Vrai | 1 |
| sortie | -2 | -2 > 0 : Faux | fin de la boucle |
range est épuisé) et noter cette dernière ligne.Déroule d'abord à la main, puis compare avec les visualisateurs du site :
Tape ta boucle : la table de trace se remplit tour par tour, avec la condition réévaluée à chaque fois.
Factorielle, Fibonacci, accumulateurs : l'état de la mémoire après chaque ligne, en lecture automatique ou ligne par ligne.