Les boucles "pour"

Itération

Une itération est une boucle qui permet de répéter plusieurs fois la même suite d’instructions. Elle est utilisée pour évaluer une somme, une suite récurrente, le calcul d’un plus grand commun diviseur par exemple. Elle sert aussi pour effectuer des traitements plus informatiques comme la lecture d’un fichier.

Il existe deux types d'itérations : la boucle pour (for) et la boucle Tant que (While)

Une boucle "pour" est utilisée pour répéter une action quand on connaît à l'avance le nombre de répétitions de l'action à exécuter lors de l'écriture d'un programme.

Avec une boucle "tant que", le nombre de répétitions est conditionné par l'évolution de l'état de certaines variables du programme.

Boucle "POUR"

L’itération de type boucle-pour en Python est un peu déroutante pour ceux qui la découvrent pour la première fois. L’exemple le plus courant est celui où on exécute une suite d’opérations pour i variant de 1 à n, comme dans :

for i in range(0, 101) :
	print(i)

Ce petit programme permet d'afficher tous les entiers naturels allant de 0 à 100

• L'indentation après la ligne for ... : est obligatoire (et automatique avec un éditeur adapté) : elle permet de délimiter la portée du for.
• a et b désignant deux entiers, range(a,b) est l'ensemble (ordonné) des entiers a, a+1, a+2, ..., b-1. C'est à dire l'ensemble des entiers k vérifiant a≤ k <b. On fera attention à l'apparente dissymétrie entre les deux bornes.

Exemple 1

L'algrorithme pour afficher la table de multiplication d'un nombre n :

n ← ?
Pour k allant de 1 à 10 :
	afficher k*n
Fin Pour

qui se traduit en langage Python par :

n = int(input("saisir la valeur de l'entier naturel n : "))
for k in range(1,11) :
	print("{} * {} = {}".format(k,n,k*n))

On obtient à l'affichage pour n = 9 :

1 * 9 =  9
2 * 9 =  18
3 * 9 =  27
4 * 9 =  36
5 * 9 =  45
6 * 9 =  54
7 * 9 =  63
8 * 9 =  72
9 * 9 =  81
10 * 9 =  90

Exemple 2

Calcul de la somme des premiers entiers naturels.

Calcul de la somme S=1+2+3+...+n des n premiers entiers positifs :

n=10 
s=0 # initialisation de la variable s qui contiendra la somme
for k in range(1,n+1) :
	s=s+k
print("La somme des entiers compris entre 1 et {} est égale à {}.".format(n,s) )

On obtient :

La somme des entiers compris entre 1 et 15 est égale à 55.

Notez bien l'indentation du code : le bloc dans le while contient une seule ligne s = s + k. Si on décale print("La somme ...) pour l'aligner avec s = s + k, cette instruction sera dans la boucle et ça changera tout.

Essayons de comprendre le rôle de l'indentation en faisant cette modification dans ce dernier programme :

n=10
s=0 # initialisation de la variable s qui contiendra la somme
for k in range(1,n+1) :
	s=s+k
	print("La somme des entiers compris entre 1 et {} est égale à {}.".format(n,s) )

On obtient cette fois :

La somme des entiers compris entre 1 et 10 est égale à 1.
La somme des entiers compris entre 1 et 10 est égale à 3.
La somme des entiers compris entre 1 et 10 est égale à 6.
La somme des entiers compris entre 1 et 10 est égale à 10.
La somme des entiers compris entre 1 et 10 est égale à 15.
La somme des entiers compris entre 1 et 10 est égale à 21.
La somme des entiers compris entre 1 et 10 est égale à 28.
La somme des entiers compris entre 1 et 10 est égale à 36.
La somme des entiers compris entre 1 et 10 est égale à 45.
La somme des entiers compris entre 1 et 10 est égale à 55.

Les messages obtenus lors de ce dernier affichage n'étant pas exacts, modifions notre programme (on remplace simplement n par k dans format(n,s)) :

n=10 
s=0 # initialisation de la variable s qui contiendra la somme
for k in range(1,n+1) :
	s=s+k
	print("La somme des entiers compris entre 1 et {} est égale à {}.".format(k,s) )

On obtient cette fois :

La somme des entiers compris entre 1 et 1 est égale à 1.
La somme des entiers compris entre 1 et 2 est égale à 3.
La somme des entiers compris entre 1 et 3 est égale à 6.
La somme des entiers compris entre 1 et 4 est égale à 10.
La somme des entiers compris entre 1 et 5 est égale à 15.
La somme des entiers compris entre 1 et 6 est égale à 21.
La somme des entiers compris entre 1 et 7 est égale à 28.
La somme des entiers compris entre 1 et 8 est égale à 36.
La somme des entiers compris entre 1 et 9 est égale à 45.
La somme des entiers compris entre 1 et 10 est égale à 55.

Boucle "TANT QUE"

Contrairement à la boucle for, la boucle while est intuitive. Elle permet de répéter une suite d'instructions tant qu'une condition particulière est remplie.

Une boucle sert à répéter une action. Rappelons brièvement la principale différence entre une boucle "pour" et une boucle "tant que" :

• Avec une boucle "pour", on connaît à l'avance le nombre de répétitions de l'action à exécuter.
• Avec une boucle "tant que", le nombre de répétitions est conditionné par l'évolution de l'état de certaines variables du programme.

L'algrorithme pour calculer le produit des entiers naturels non nuls inférieurs ou égaux à un entier n non nul :

n ← ?
k ← 2
P ← 1
tant que k ≤ n :
	P ← P*k
	k ← k+1
Fin tant que

qui se traduit en langage Python par :

n = int(input("Saisir la valeur de l'entier naturel non nul n : "))
k=2
P=1
while k ≤ n :
    P=P*k
    k = k+1
print("Le produit des entiers naturels non nuls inférieurs ou égaux à {} est {} : ".format(n,P))

On obtient à l'affichage pour n = 6 :

>>> 
Le produit des entiers naturels non nuls inférieurs ou égaux à 6 est 720 : 
>>>

Tout programme pouvant s'écrire avec une boucle for peut également s'écrire avec une boucle while. Dans un cas comme le précédent, il est toutefois clair qu'une boucle for est plus appropriée.

De même, l'indentation après la ligne while ... : est obligatoire (et automatique avec un éditeur adapté) : elle permet de délimiter la portée du while.

Un second exemple

Déterminer le plus petit entier naturel n tel que la somme S=1+2+3+...+n soit strictement supérieure à 10000.

L'algrorithme pour Déterminer le plus petit entier naturel n tel que la somme S=1+2+3+...+n soit strictement supérieure à 10000 est :

S ← 0
n ← 0
tant que S ≤ 10000 :
	n ← n+1
	S ← S + n
Fin tant que

qui se traduit en langage Python par :

s=0
n=0
while s ≤ 10000 :
	n+=1
	s+=n
print(n)

On obtient :

141

Un troisième exemple : PGCD de deux entiers naturels

Un exemple classique de l’utilisation de while est le calcul du PGCD (Plus Grand Diviseur Commun) de deux entiers naturels par l’algorithme d’Euclide. Cet algorithme consiste à remplacer le calcul de PGCD(a, b) par celui de PGCD(b, r) où r est le reste de la division euclidienne de a par b et ceci tant que r ≠ 0.

L'algrorithme pour calculer le PGCD de a et b est :

a ← ?
b ← ?
r ← a % b
tant que r ≠ 0
   a ← b
   b ← r
   r ← a%b
fin tant que

a = int(input("Saisir un entier naturel a : "))
b = int(input("Saisir un entier naturel b : "))
print("le PGCD de", a, " et ", b, " est ", end=" ")
r = a%b
while r!=0 :
    a = b
    b = r
    r= a%b
print(b)

On obtient à l'affichage pour a = 33 et b = 5 :

Saisir la valeur de l'entier naturel a : 33
Saisir la valeur de l'entier naturel b : 5
le PGCD de 33  et  5  est  1

Terminaison d'un programme avec tant que

Le programme que nous venons de voir peut être considéré comme étrange, voire dangereux. En effet, si la conjecture est fausse, alors le programme ne va jamais s’arrêter, on dit qu’il ne termine pas. Le problème de la terminaison des programmes est fondamental en programmation. Il faut toujours se demander si le programme qu’on écrit va terminer. D’un point de vue théorique, il est impossible de trouver un algorithme pour faire cela. D’un point de vue pratique, on doit examiner chaque boucle ou itération et prouver que chacune termine.

Voici quelques erreurs classiques, qui toutes simulent le mouvement perpétuel :

On s’attachera à prouver que les algorithmes que nous étudions terminent bien.

while True :
   	print(" allô ", end="")

Ce qui affiche :

allô allô allô … sans jamais s’arrêter.