Les boucles

Un petit problème....

Soit une situation où l'on voudrait afficher les multiples croissants de 2 jusqu'à 20 ( par exemple...).
Comment faudrait-il écrire un tel programme ?

valeur = 2
print( valeur ) # affiche 2
valeur = valeur + 2
print( valeur ) # affiche 4
valeur = valeur + 2
print( valeur ) # affiche 6
valeur = valeur + 2
print( valeur ) # affiche 8
valeur = valeur + 2
print( valeur ) # affiche 10
valeur = valeur + 2
print( valeur ) # affiche 12
valeur = valeur + 2
print( valeur ) # affiche 14
valeur = valeur + 2
print( valeur ) # affiche 16
valeur = valeur + 2
print( valeur ) # affiche 18
valeur = valeur + 2
print( valeur ) # affiche 20
					

Pas vraiment élégant, n'est-ce pas ? Il y a sûrement plus efficace que d'écrire 10 fois la même chose !

Très souvent, on a effectivement ainsi besoin de répéter plusieurs fois les mêmes séquences d'instructions
D'où l'existence de structures de boucles qui font partie, comme l'instruction if, des structures de contrôle de flux.

En Python, deux structures de boucle existent :

La boucle for ( boucle inconditionnelle )

Vous avez en fait déjà utilisé ce type de structure, mais sous une forme un peu différente, avec la boucle for ... in ... qui permet de parcourir un objet itérable comme une chaîne de caractères.

Structure

for compteur in range( intervalle de variation du compteur ) :
	Instruction(s) à exécuter dans la boucle
	..............
	..............
			

Principe

Cette boucle "tourne" en exécutant à chaque "tour" la (ou des) instruction(s) du bloc.

La variable compteur de boucle ( nommée ici compteur, mais on peut bien entendu utiliser n'importe quel nom..) permet de compter le nombre de "tours" de la boucle; elle est automatiquement incrémentée ( ou décrémentée ! ) d'une certaine valeur ( = le pas de la boucle ) à la fin de chaque "tour"; la boucle "tournera" alors tant que la valeur du compteur se trouve dans l'intervalle de variation indiqué.

Il existe plusieurs façons d'indiquer les bornes de cet intervalle :

for compteur in range( N ) :
					

⇨ intervalle de 0 jusqu’à N - 1 avec un pas de variation de 1 ( pour N = 10, le compteur varie donc de 0 à 9 par pas de 1, soit 10 "tours" )

for compteur in range( N1 , N2 ) :
					

⇨ intervalle de N₁ jusqu'à N₂ - 1 avec un pas de variation de 1 ( pour l'exemple précédent, on aurait : N₁ = 0 et N₂ = 10 )

for compteur in range( N1 , N2 , pas ) :
					

⇨ intervalle de N₁ jusqu'à N₂ - 1 avec un pas de variation quelconque

Exemples d'utilisation

for i in range( 4 ) :
			

for i in range( 3 , 10 ) :
			

for i in range( 10 , 2 , -2 ) :
			

L'exemple d'introduction du chapitre deviendrait alors :

valeur = 2
for i in range( 10 ) :
	print( valeur )
	valeur = valeur + 2
			

⇨ 4 lignes au lieu de 18 !!

Utilisation de la variable compteur à l'intérieur de la boucle

A l'intérieur de la boucle, on aura souvent besoin d'utiliser la valeur de la variable compteur pour réaliser certaines opérations.

Par exemple, pour afficher tous les multiples d'un certain nombre, on écrira une instruction qui, à chaque tour de boucle, multipliera ce nombre par la valeur du compteur, de façon à obtenir tous les multiples :

nombre = 2
for i in range(10):
	print(nombre, "x", i, "=", nombre*i)
			

Une boucle dans une boucle : les boucles imbriquées

On a aussi parfois besoin de la structure suivante :

for i in range(3):
	for j in range(4):
		print("i =", i, "j =", j)
			

En étudiant l'indentation, on constate la présence dans ce code :

• d'une première boucle de variable compteur i
• "à l'intérieur" de celle-ci ( 1^ère instruction en retrait ), une autre boucle de variable compteur j
• "à l'intérieur" de celle-ci ( 2^ème instruction en retrait ), une instruction print() qui affiche les valeurs de i et j

Étudiiez l’exécution de ce code :

	i = 0 j = 0
	i = 0 j = 1
	i = 0 j = 2
	i = 0 j = 3
	i = 1 j = 0
	i = 1 j = 1
	i = 1 j = 2
	i = 1 j = 3
	i = 2 j = 0
	i = 2 j = 1
	i = 2 j = 2
	i = 2 j = 3
			

Voila ce qu'il se passe :

1. la variable i prend la valeur i = 0
   • la variable j prend successivement les valeurs j = 0, 1, 2 et 3; pendant ce temps, i n'a pas changé de valeur et vaut toujours i = 0
   • à chaque tour de la boucle j, l'instruction print() s'éxécute : on obtient donc l'affichage des lignes 2 à 5 ci-dessus.
2. quand l'éxécution de la boucle j est terminée, on sort de celle-ci : on commence donc le deuxième tour de la boucle i, qui prend alors la valeur i = 1
   • j reprend alors à nouveau successivement les les valeurs j = 0, 1, 2 et 3 alors que i garde toujours sa valeur i = 1
   • on obtient l'affichage des lignes 6 à 9
3. et enfin, le dernier tour de la boucle i pour i = 2, et l'éxécution à nouveau de la boucle j, donne l'affichage des lignes 10 à 13.

→ la boucle j a donc été éxécutée autant de fois que de tours de la boucle i.

Cette structure particulière où "une boucle tourne dans une autre boucle" est appelée boucles imbriquées; elle n'est pas évidente à comprendre, étudiez-la bien : elle sert dans de nombreuses situations ( vous verrez un premier exemple ci-dessous ), notamment dès que l'on a à parcourir un objet en deux dimensions comme les pixels d'une image, ou une liste de listes ( vous verrez cela plus tard ).

La boucle while ( boucle conditionnelle )

Structure

while ( condition ) :
	Instruction(s)
	.......
			

Principe

La condition est une expression, plus ou moins complexe, à évaluer à l'aide d'opérateurs de comparaison.

Ce sont les mêmes que ceux rencontrées au chapitre précédent :

La (ou les) instruction(s) constituent le bloc qui sera exécuté à chaque "tour" de boucle ; elles sont donc indentées d'un même retrait par rapport à l'instruction "parente" ( ici, l'instruction while ) pour indiquer à Python qu'il s'agit du même bloc logique.

Exemple d'utilisation

i = 0
valeur = 2

while ( i < 10 ) :
	print( valeur )
	valeur = valeur + 2
	i +=1
			

Et alors : faut-il utiliser la boucle for ou la boucle while ???

Dans certains cas....les deux !!

On peut très bien par exemple réécrire les exemples précédents avec une boucle while au lieu du for :

for i  in range( 4 ) :

	Instruction 1

	Instruction 2

	......
						

i = 0  # définition du compteur de boucle

while ( i < 4 ) :

	Instruction 1

	Instruction 2

	......

	i = i + 1 # Incrémentation du compteur
						

for i  in range( 3 , 10 ) :

	Instruction 1

	Instruction 2

	......
						

i = 3

while ( i < 10 ) :

	Instruction 1

	Instruction 2

	......

	i += 1 # Autre façon d'écrire l'incrémentation
						

for i  in range( 10 , 2 , -2 ) :

	Instruction 1

	Instruction 2

	......
						

i = 10

while ( i > 2 ) :

	Instruction 1

	Instruction 2

	......

	i -= 2  # il s'agit ici d'une décrémentation

						

On constate cependant qu'avec la boucle while, le code est plus "lourd", d'autant plus qu'il faut soi-même gérer l'évolution du compteur ( ce qui est "automatique" avec une boucle for ), avec les risques de "boucle infinie" que cela entraîne...; l'utilisation de la boucle conditionnelle n'est donc pas judicieuse dans ces exemples...

Quel est son intérêt alors ? Et bien, le nombre de "tours" d'une boucle while n'est pas fixé à l'avance, au contraire de la boucle for, dont le nombre de tours est fixé à son début.

Dans quel cas cela est-il utile ? Par exemple, l'entrée d'un mot de passe par un utilisateur : tant que l'entrée n'est pas la bonne, on redemande le mot de passe...et cela peut durer un nombre de fois indeterminé à l'avance !!

motDePasse = 'sdhfj7$ff'

entree = ''  # initialisation de l'entrée utilisateur à "vide"

while ( entree != motDePasse ) :

	entree = input('Entrez le mot de passe :')

print('Accès autorisé')
			

Exercices

Boucles for

Combien de fois les boucles suivantes seront-elles exécutées ?

for i  in range( 6 ) :

	Instruction 1

	Instruction 2

	......
			

for i  in range( 5 , -1 , -1 ) :

	Instruction 1

	Instruction 2

	......
			

Boucle while

Combien de fois les boucles suivantes sont-elles exécutées ?

compteur = 1

while ( compteur < 8 ) :

	compteur+=1
			

compteur = 0

while ( compteur < 6 ) :

	compteur+=1
			

compteur = 15

while ( compteur < 15 ) :

	compteur+=1
			

Que peut-on dire de la boucle ci-dessous, destinée à afficher les puissances de 2 successives ?

compteur = 0

a = 1

while ( compteur < 10 ) :

	print ( a )

	a = a * 2
			

Corriger et réécrire ce programme plus judicieusement.

compteur = 0 # une seule variable pour tout faire...

while ( compteur < 10 ) :

	print ( 2 ** compteur )

	compteur += 1
					

QCM d'entraînement

Que s'affiche-t-il à la fin de l'exécution de chacun des scripts suivants ?

Applications

L'écho (exercice_A15.py)

Écrire une boucle qui affiche 20 fois le mot "Echo".

Écrire une boucle qui affiche la table de multiplication de 3 (exercice_A16.py)

				
	1 3 6 9 12 15 18 21 24 27 30
				
			

Une contrainte : utiliser la valeur du compteur elle-même pour effectuer le calcul des multiples.

print( affichage , end = ' ') # un espace entre les guillemets
				

print()
				

Compte à rebours (exercice_A17.py)

Écrire une boucle qui affiche un compte à rebours de 20 à 0 INCLUS

				
	20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
				
			

Écrire un programme qui affiche les unes à la suite des autres les tables de multiplication de 1,2,....,10. (exercice_A18.py)

				
	1 2 3 4 5 6 7 8 9 10
	2 4 6 8 10 12 14 16 18 20
	3 6 9 12 15 18 21 24 27 30
	4 8 12 16 20 24 28 32 36 40
	5 10 15 20 25 30 35 40 45 50
	6 12 18 24 30 36 42 48 54 60
	7 14 21 28 35 42 49 56 63 70
	8 16 24 32 40 48 56 64 72 80
	9 18 27 36 45 54 63 72 81 90
	10 20 30 40 50 60 70 80 90 100
				
			

Le calendrier (exercice_A19.py)

Écrire un programme qui permette d'afficher un calendrier pour un mois de 28 jours avec chaque semaine sur une ligne différente.

				
	1 2 3 4 5 6 7
	8 9 10 11 12 13 14
	15 16 17 18 19 20 21
	22 23 24 25 26 27 28
				
			

Le jeu du nombre à deviner ( Utilisation des boucles ET des conditions ) (exercice_A20.py)

Le but du jeu : le programme tire un nombre entier au hasard ( entre 1 et 100 par exemple ) ; le joueur doit essayer de deviner le nombre, et doit faire des propositions. Chaque proposition est évaluée, et le programme doit afficher " Trop grand", "Trop petit", ou "Gagné !" après chaque proposition.
Le programme doit "tourner" tant que le joueur n'a pas donné la bonne réponse...

	nombre = randint( borne1 , borne2 )
				

from random import randint
						

n = randint( 1 , 100 )
						

							nombre ← tirage au hasard entier entre 1 et 100
							entree ← 0

							tant que entree != nombre :
								entree ← entree utilisateur
								si entree > nombre
									alors afficher "Trop grand !"
								si entree < nombre
									alors afficher "Trop petit !"

								sinon
									afficher "Bravo !"
								fin si
							fin tant que