Dans cette section, nous détaillons les mécanismes d’interprétation des boucles.
4.2.1 Principe d’interprétation
Le principe d’interprétation de la boucle while est le suivant : Dans :
while <condition logique>: <instruction 1>
...
<instruction n> <instruction n + 1> ...
1. On évalue tout d’abord la<condition logique>. De deux choses l’une : — 2a. Soit cette dernière est différente deFalse et alors :
— on interprète la séquence des instructions dans le corps de la boucle : <instruction 1>
...
<instruction n> — on retourne à l’étape 1.
— 2b. Soit la<condition logique> s’évalue en False et on sort de la boucle pour inter- préter l’instruction<instruction n+1> (et celles qui la suivent).
4.2.2 Simulation de boucle
Pour étudier l’interprétation des boucles nous introduisons la notion de simulation de boucle que nous allons illustrer sur la fonction somme_entiers.
La simulation de boucle conduit à la construction d’une table de simulation selon les principes suivants :
— on fixe une valeur pour chaque paramètre de la fonction qui joue un rôle dans la boucle que l’on veut simuler.
Poursomme_entiers il y a un unique paramètre qui est n. Il joue bien un rôle dans la fonction (il apparaît dans la condition de boucle). Nous allons fixern à la valeur 5 pour notre simulation.
— si des variables ne sont pas modifiées dans le corps de la boucle, mais jouent un rôle dans ce dernier, alors on fixe également une valeur.
Il n’y a pas de telle variable danssomme_entiers.
— on crée un tableau avec une première colonne tour de boucle (ou tour ), puis on ajoute une colonne par variable modifiée dans le corps de la boucle. L’ordre des colonnes correspond à l’ordre des affectations dans le corps.
Par exemple dans la fonctionsomme_entiers la variable s est modifiée avant la variable i, on obtient donc l’en-tête suivant pour notre table de simulation :
tour de boucle variables variable i
On réalise une simulation en remplissant maintenant les lignes de notre tableau : une ligne pour chaque tour de boucle.
— on remplit la première ligne du tableau en indiquantentrée dans la colonne tour de boucle et on donne pour chaque variable sa valeur avant d’effectuer le premier tour de boucle.
Poursomme_entiers la valeur initiale de s est 0 et la valeur de i est 1 avant le premier tour de boucle, on obtient donc :
tour de boucle variables variable i
entrée 0 1
— la seconde ligne et les suivantes indiquent le nombre de tours de boucle effectués (dans la colonnetour de boucle) ainsi que la valeur après ce tour de boucle pour les variables locales modifiées (dans les autres colonnes).
Pour somme_entiers la valeur de s après le premier tour est 1 et la valeur de i est 2. On obtient donc :
tour de boucle variables variable i
entrée 0 1
1er tour 1 2
La condition est bouclei <= n est toujours vraie après ce premier tour (on se rappelle que l’on a fixé la valeur den à 5 pour cette simulation).
A la fin du deuxième tour cela donne :
tour de boucle variables variable i
tour de boucle variables variable i
1er tour 1 2
2e tour 3 3
La condition est bouclei <= n est toujours vraie après le tour 2. On continue ainsi pour le tour 3, le tour 4 et le tour 5 :
tour de boucle variables variable i
entrée 0 1 1er tour 1 2 2e tour 3 3 3e tour 6 4 4e tour 10 5 5e tour 15 6
A l’issue de ce cinquième tour, la conditioni <= n n’est plus vérifiée car i vaut 6, la condition de boucle est donc invalidée et cela provoque donc la sortie de boucle.
— pour préciser que ce cinquième tour est le dernier, on rajoute la mention(sortie) dans la colonne tour de boucle. Cette ligne précise alors les valeurs finales de chaque variable, et la simulation est finie.
La simulation complète est donc la suivante :
tour de boucle variables variable i
entrée 0 1 1er tour 1 2 2e tour 3 3 3e tour 6 4 4e tour 10 5 5e tour (sortie) 15 6
À la fin de la simulation, la valeur des est donc 15 qui correspond bien à la somme des entiers de 1 à 5 (plus précisément de 1 à n pour n valant 5).
À retenir : le principe de construction des simulations de boucle sera souvent utilisé pour expliquer le déroulement des calculs répétitifs.
4.2.3 Tracer l’interprétation des boucles avec print
Construire une simulation de boucle permet de comprendre et de vérifier sur quelques exemples que les calculs effectués sont corrects (ou en tout cas semblent corrects, nous reviendrons sur cette nuance lors du prochain cours).
programmes sans systématiquement faire des simulations à la main. Pour cela, nous utilisons l’instructionprint pour tracer l’interprétation des programmes et en particulier les boucles. Voici comment reproduire notre simulation sursomme_entiers :
def somme_entiers(n):
""" int -> int
Hypothèse: n >= 1
retourne la somme des n premiers entiers naturels.""" # i : int
i = 1 # compteur # r : int
s = 0 # somme
print("=====================")
print("s en entrée vaut ", s)
print("i en entrée vaut ", i) while i <= n:
s = s + i i = i + 1
print("---")
print("s après le tour vaut ", s)
print("i après le tour vaut ", i)
print("---") print("sortie") print("=====================") return s >>> somme_entiers(5) ===================== s en entrée vaut 0 i en entrée vaut 1 --- s après le tour vaut 1
i après le tour vaut 2
--- s après le tour vaut 3
i après le tour vaut 3
--- s après le tour vaut 6
i après le tour vaut 4
--- s après le tour vaut 10
i après le tour vaut 5
--- s après le tour vaut 15
i après le tour vaut 6
--- sortie
=====================
15
Important : dans ce cours, nous n’utiliseronsprint que pendant les travaux sur machine, et uniquement dans le but d’afficher des traces d’exécution.