Les boucles Python – un guide complet

Les boucles Python permettent d’exécuter un bloc de code plusieurs fois selon une condition spécifique. Elles sont très utiles lorsque vous voulez parcourir une séquence un certain nombre de fois.

En fait, une boucle est une fonctionnalité couramment utilisée dans la programmation pour réaliser des tâches répétitives.

En programmation, il existe plusieurs types de boucles, qui servent à des fins différentes. Nous allons découvrir les deux boucles Python principales, for et while.
Bien qu’il soit possible de faire tout ce dont vous avez besoin, elles sont souvent utilisées dans des situations différentes.

La boucle Python while

Une boucle while qui veut dire tant que, est un concept de programmation qui, lorsqu’il est utilisé, exécute une instruction d’une manière répétitive, tant qu’une condition spécifique est vraie.

La boucle while vérifie la condition avant d’effectuer une itération. Comme le test est effectué au début de la boucle, il est généralement nécessaire d’ajouter quelques étapes avant la boucle pour vous assurer qu’elle s’exécute au moins une fois.

while [tant que la condition est vraie] :
    [exécuter ce bloc de code]

Dans votre IDLE, sélectionnez File -> New File, puis saisissez ce code.

# Initialiser une variable
nombre = 3 
# Début de la boucle 
while nombre > 0 :
    print("La boucle passe par le nombre", nombre)  
    print("Nous sommes dans la boucle parce que", nombre, 'est supérieur à 0')
    print('*' * 30)  
    # Décrémenter la variable nombre
    nombre = nombre - 1
print('\n')
print("La boucle s'arrête lorsque la variable nombre n'est plus supérieur à 0")

Enregistrez le fichier sous boucles.py, dans votre Bureau, puis exécutez votre code avec Run -> Run Module ou en appuyant sur F5. Le résultat s’affichera dans le Shell.

La boucle passe par le nombre 3 
Nous sommes dans la boucle parce que 3 est supérieur à 0 
******************************
La boucle passe par le nombre 2 
Nous sommes dans la boucle parce que 2 est supérieur à 0
******************************
La boucle passe par le nombre 1
Nous sommes dans la boucle parce que 1 est supérieur à 0
******************************

La boucle s’arrête lorsque la variable nombre n’est plus supérieur à 0

Si vous mettez tant que à la place de while, vous aurez un code très facile à comprendre.
Rappelez-vous, l’indentation détermine le début et la fin d’un bloc d’instructions.
1- Nous créons une variable nombre et nous lui affectons une valeur. C’est la variable d’initialisation.
2-Tant que nombre est supérieur à 0, afficher des messages spécifiques et répéter cette action jusqu’à ce que la condition nombre > 0 sera évaluée à False.
3-Lorsque la condition n’est plus évaluée à True, la boucle Python while quitte le bloc d’instructions et arrête de tourner.
4-Python exécute l’instruction suivante.

En fait, chaque passage de la boucle est appelé une itération. Par conséquent, dans la boucle précédente, il y avait 3 itérations.
De plus, la boucle Python modifie la valeur de la variable à chaque passage, jusqu’à ce qu’elle soit fausse en la décrémentant de -1.

Une boucle Python infinie avec break

Nous appelons la variable qui change de valeur à chaque fois que la boucle s’exécute, la variable d’itération. S’il n’y a pas de variable d’itération, vous aurez une boucle infinie.

Dans l’exemple précédent, supprimez la ligne nombre = nombre - 1, puis exécutez le code. Le résultat sera une boucle qui s’exécute indéfiniment, puisque votre variable nombre sera toujours affectée à la valeur 3.

Pour arrêter ce spectacle, appuyez sur Ctl + c (le curseur doit être dans la fenêtre du Shell).

Il est également possible d’utiliser les booléens pour créer une boucle infinie.

# Une boucle infinie affichant un 0
i = 0
while True:
    print(i)

De plus, il est possible d’arrêter cette boucle infinie dans votre IDLE en accédant à :
Shell -> Interupt Execution .

Maintenant, nous allons utiliser break pour arrêter la boucle infinie.

i = 0
while True:
    print(i)
    if i == 9:
       break
    else:
       i += 1

Notez que ce programme affichera les valeurs de 0 à 9. Cependant, lorsque la variable d’itération i sera égale à 9, la boucle while s’arrêtera.

Remarquez également qu’il est possible d’utiliser un else, comme dans les structures conditionnelles.

En réalité, le code précédent n’est qu’un exemple pour que vous compreniez le concept, puisque vous pouvez avoir le même résultat avec moins de lignes :

i = 0
while i < 10:
    print(i)
    i += 1

Donc, il est préférable d’utiliser une condition à la place d’une instruction brake.

continue pour modifier l’itération dans des boucles Python

Vous pouvez sauter une itération dans des boucles Python et revenir en haut à l’aide de l’instruction continue, afin d’exécuter l’itération suivante.

# Afficher les nombres de 1 à 10 et exclure le nombre 5
i = 0
while i < 10:
    i = i + 1
    if i == 5:
       print("Le nombre 5 n’est plus là")
       continue
    
    print(i)

Ce qui vous donne :

1
2
3
4
Le nombre 5 n’est plus là
6
7
8
9
10

La boucle Python for

Une boucle for exécute un code d’une manière répétitive sur une séquence, un certain nombre de fois. Contrairement à la boucle while, aucune condition n’est spécifiée.

# Pour chaque élément dans la séquence, exécuter un bloc d'instructions
for variable in sequence:
	instructions

À chaque itération variable prend la valeur de chaque élément à l’intérieur de la séquence. En fait, la boucle for s’exécute jusqu’à ce qu’elle atteigne le dernier élément de la séquence. Le bloc d’instructions de la boucle est séparé du reste du programme avec une indentation.

>>> for lettre in "python":
	print(lettre)

	
p
y
t
h
o
n

En outre, il est possible d’utiliser else, break et continue dans une boucle for.

La fonction enumerate () et les boucles Python

La fonction enumerate () est utilisée pour affecter un index à chaque élément de l’objet ou de la séquence itérable. Elle exécute une boucle sur les objets itérables tout en gardant une trace de l’élément actuel et renvoie l’objet sous une forme énumérable.

>>> lettres = "abc"

La fonction enumerate ()facilite le suivi du contenu d’un objet itérable. En effet, cette fonction fournie deux arguments.

enumerate(sequence, start=0)

start est un paramètre facultatif, il détermine l’index du premier élément. Rappelez-vous, l’indice commence de 0.

>>> for lettre in enumerate(lettres):
	print(lettre)

	
(0, 'a')
(1, 'b')
(2, 'c')

Pour changer l’index du premier élément, nous utiliserons le paramètre start :

>>> for lettre in enumerate(lettres, start=1):
	print(lettre)

	
(1, 'a')
(2, 'b')
(3, 'c')

La fonction range() et les boucles Python

Le fonction range() génère une séquence d’entiers en définissant le début et la fin d’un intervalle qui délimite un objet itérable.

>>> for i in range(1, 3):
	print(i)

	
1
2

Comme vous pouvez le constater dans l’exemple précédent, le dernier élément n’est pas pris en compte.

La fonction range() prend les formes suivantes :

range(stop)
range(start, stop, step)

Prenons des exemples :

>>> for i in range(3):
    print(i)

    
0
1
2

Lorsque trois arguments sont spécifiés, range() renvoie une séquence de nombres, incrémentée ou décrémentée de step (step, le nombre de pas), en commençant par start(start est le début) jusqu’à stop - 1.
Si step est positif, range() renvoie une séquence qui s’incrémente.

# Afficher les chiffres de 1 à (10-1) avec un saut de 2
>>> for i in range(1, 10, 2):
	print(i)

	
1
3
5
7
9

Un saut qui est de 2, ne veux pas dire sauter 2 chiffres (vous n’allez pas sauter le 2 et le 3). Considérez les chiffres comme des cases et vous êtes à l’intérieur de la case 1.
Si vous sautez d’un pas, vous serez à l’intérieur de la case 2.
Sautez d’un deuxième pas et vous serez dans la case 3.

Toutefois, si step est négatif, range() renvoie une séquence qui décrémente.

>>> for i in range(10, 0, -2):
	print(i)

	
10
8
6
4
2

Le comportement d’une variable dans une boucle Python

Dans une boucle for, l’objectif d’une variable est de stocker la valeur de chaque élément de la séquence à chaque itération de la boucle. Dans certaines situations, on utilise cette variable pour faire un calcul ou une autre tâche dans le bloc d’instructions de la boucle.

Écrivons un programme qui utilise une boucle for pour afficher les nombres de 1 à 10 à la puissance 2.

Dans IDLE, ouvrez votre fichier boucles.py en accédant à File -> Open, puis exécutez le code avec F5 (le curseur doit être dans la fenêtre du fichier) :

print("\t", "Nombre  | Puissance de 2")
print("\t", "------------------------")
for nombre in range(1, 11):
	print("\t","  ", nombre,"\t |"," ",nombre ** 2,"\t\t")
	print("\t", "------------------------")

Dans la première ligne, nous affichons l’entête de notre tableau. Vous vous souvenez certainement du caractère de tabulation "\t", on a vu ça dans les chaînes de caractères. Concernant le caractère pipe |, utilisez AltGr + 6 pour l’écrire.
" " est une chaîne de caractère vide et les ** est l’opérateur d’exponentiation, qu’on a vu dans les opérateurs Python.

La boucle for utilise la fonction range() pour avoir une séquence contenant les nombres de 1 à 10. Lors de la première itération, la variable nombre fera référence à 1, puis à la deuxième itération, nombre fera référence à 2.

Notez que le code qui se trouve à l’intérieur de l’indentation, s’exécute à chaque tour de la boucle for.

Astuce :
À présent vous allez redimensionner les fenêtres de votre fichier boucles.py et du Shell, afin de les mettre l’une à côté de l’autre. Pour redimensionner une fenêtre, positionnez le curseur de votre souris sur son bord. Lorsqu’une flèche s’affichera, cliquez, maintenez le clic, puis réduisez la fenêtre. En cliquant sur le haut de la fenêtre et en maintenant le clic, vous allez pouvoir la déplacez.
Lorsque vous aurez placé les deux fenêtres l’une à côté de l’autre, exécutez votre code pour voir le rendu en direct.

          Nombre | Puissance de 2
	 ------------------------
	    1 	 |   1 		
	 ------------------------
	    2 	 |   4 		
	 ------------------------
	    3 	 |   9 		
	 ------------------------
	    4 	 |   16 		
	 ------------------------
	    5 	 |   25 		
	 ------------------------
	    6 	 |   36 		
	 ------------------------
	    7 	 |   49 		
	 ------------------------
	    8 	 |   64 		
	 ------------------------
	    9 	 |   81 		
	 ------------------------
	    10 	 |   100 		
	 ------------------------

Compter les éléments d’une séquence avec les boucles Python

Pour compter le nombre d’éléments dans une séquence, nous utiliserons le code suivant :

chaîne = "les boucles python"
compteur = 0
for i in chaîne:
        compteur = compteur + 1
print('chaîne contient : ', compteur, "élément(s)")

Sachant qu’un espace est considéré comme un caractère, vous aurez :

chaîne contient :  18 élément(s)

Nous assignons à la variable compteur la valeur zéro avant le début de la boucle, puis nous écrivons une boucle for pour parcourir la chaîne de caractère chaîne. La variable d’itération i contrôle la boucle et exécute les instructions du bloc de la boucle une fois pour chacune des valeurs de la chaîne.
Dans le bloc d’instructions de la boucle, la valeur actuelle de la variable compteur est incrémentée de 1 à chaque itération dans la chaîne.
Par conséquent, lorsque la boucle parcoure toute la séquence, la valeur de la variable compteur sera le nombre total d’éléments.
Le nombre total est récupéré à la fin de la boucle.

Modifions le code précédent et vous allez mieux comprendre.

chaîne = "les boucles python"
compteur = 0
for i in chaîne:
        compteur = compteur + 1
        print('chaîne contient : ', compteur, "élément(s)")

Le code précédent va afficher le nombre d’éléments à chaque itération.
Cette ligne de code :

print('chaîne contient : ', compteur, "élément(s)")

Comme elle est à l’intérieur du bloc d’instructions for, va s’exécuter à chaque tour de boucle.

chaîne contient :  1 élément(s)
chaîne contient :  2 élément(s)
chaîne contient :  3 élément(s)
chaîne contient :  4 élément(s)
chaîne contient :  5 élément(s)
chaîne contient :  6 élément(s)
chaîne contient :  7 élément(s)
chaîne contient :  8 élément(s)
chaîne contient :  9 élément(s)
chaîne contient :  10 élément(s)
chaîne contient :  11 élément(s)
chaîne contient :  12 élément(s)
chaîne contient :  13 élément(s)
chaîne contient :  14 élément(s)
chaîne contient :  15 élément(s)
chaîne contient :  16 élément(s)
chaîne contient :  17 élément(s)
chaîne contient :  18 élément(s)

Donc, faites attention à l’indentation lorsque vous écrivez votre code.

Calculer la somme de plusieurs nombres avec la boucle for

Nous allons écrire un programme qui demande à l’utilisateur de saisir des nombres, pour lui afficher leur somme.

max = int(input("Saisissez combien de nombres voulez-vous additionner : ")) 
somme = 0
for nombre in range(max):
        nombre = int(input("Saisissez un nombre : "))
        somme =  somme + nombre
print("La somme des", max, "nombres est de : ", somme)

Ce qui donne comme résultat :

Saisissez combien de nombres voulez-vous additionner : 3
Saisissez un nombre : 5
Saisissez un nombre : 10
Saisissez un nombre : 20
La somme des 3 nombres est de :  35

1- Nous demandons à l’utilisateur combien de nombres va-t-il saisir.
2- Nous avons initialisé la variable somme en lui affectons une valeur de 0, pour qu’on puisse l’utiliser.
3- À chaque itération de la boucle for, on récupère un nombre de l’utilisateur et on le stocke dans la variable nombre.
4- Le programme fait le calcule après chaque itération et le stocke dans la variable somme.
5- Lorsque le programme sort de la boucle, on lui demande de nous afficher la variable somme.

Il est important de comprendre ce que fait l’instruction somme=somme+nombre.
Une fois cette instruction exécutée, la valeur assignée à la variable nombre est ajoutée à la dernière valeur de la variable somme.

Donc, l’interpréteur Python, récupère la valeur de l’expression qui se trouve à droite de l’opérateur =, qui est somme+nombre. Ensuite, cette valeur est affectée par l’opérateur = à la variable somme.

La valeur sentinelle avec la boucle while

Lorsque vous traitez une longue séquence de données avec une boucle, la meilleure solution serait d’utiliser la technique du sentinelle.

Supposons que vous voudrez créer un programme qui utilise une boucle pour parcourir une séquence que vous ignorez le nombre d’éléments. En fait, une valeur sentinelle indique la fin d’un ensemble de données, mais elle ne fait pas partie de ces données.

Si nous prenons l’exemple précédent, mais cette fois nous ne savons pas combien de nombres l’utilisateur voudrait additionner. Cependant, vous avez plusieurs utilisateurs, chacun va avoir un nombre différent de données. Donc, on est obligé de trouver une solution pour permettre d’arrêter le programme lorsque l’utilisateur aurait terminé.

En fait, nous allons permettre à l’utilisateur de décider d’arrêter le programme. Par conséquent, nous allons lui fournir une valeur qui va lui servir pour réaliser cette action.
Par exemple, lorsque l’utilisateur saisira un zéro, la somme sera affichée et il sortira automatiquement du programme.

print('Saisissez un nombre pour continuer, ou 0 pour terminer.')

nombre = int(input("Saisissez un nombre : "))
somme = 0

while nombre != 0:
        somme =  somme + nombre
        nombre = int(input("Saisissez un nombre : "))
        
print("La somme des nombres que vous avez saisis est de : ", somme)        

L’exécution de ce code vous donne :

Saisissez un nombre pour continuer, ou 0 pour terminer.
Saisissez un nombre : 3
Saisissez un nombre : 7
Saisissez un nombre : 99
Saisissez un nombre : 1
Saisissez un nombre : 0
La somme des nombres que vous avez saisis est de :  110

Comme vous pouvez le constater, le code sera exécuté, tant que vous n’avez pas saisis un 0.

La boucle while avec True et False

Si la condition est évaluée à True, la boucle s’exécutera. Par ailleurs, si elle est évaluée à False, elle ne s’exécutera plus.

Exécutez ces deux codes, n’oubliez pas Ctrl+ c, pour arrêter la boucle infinie.

while True:
    print("Ce code s’exécute tant que c’est True, et c'est le cas")
print("Ce code s’exécute lorsque c’est False")

Ce qui donne :

Ce code s’exécute tant que c’est True, et c’est le cas
Ce code s’exécute tant que c’est True, et c’est le cas
Ce code s’exécute tant que c’est True, et c’est le cas
........ 

Maintenant, nous allons mettre False au lieu de True.

while False:
    print("Ce code s’exécute tant que c’est True")
print("Ce code s’exécute tant que c’est False, et c’est le cas")

Ce qui donne :

Ce code s’exécute tant que c’est False, et c’est le cas

Donc, le bloc d’instructions de la boucle while ne s’exécute que si elle est évaluée à True. Et passe à l’instruction suivante, lorsqu’elle est évaluée à False.

Vous savez certainement qu’un ordinateur utilise des 0 et des 1 pour traiter les informations. De plus, le 1 correspond à True et le 0 à False. En fait, le 1 correspond à une charge électrique défini sur on, et le 0 correspond à off dans un langage machine.

Examinons à présent une des techniques utilisées avec les boucles while, basée sur le concept de on/off.

on = True
while on:
    print('La boucle est en mode on')
    on = False
print('La boucle est en mode off')

Puisque la condition est True, le bloc de code de la boucle s’exécute la première fois. Mais, dès qu’il arrive à la ligne qui modifie la condition à False, la boucle ne s’exécutera plus et passe à l’instruction suivante.

Ce qui donne :

La boucle est en mode on
La boucle est en mode off

La boucle s’exécute une première fois et dès qu’elle arrive à l’instruction False, elle arrête de tourner.

La variable on lorsqu’elle est utilisée avec True et False, fonctionne comme un interrupteur pour votre boucle while. Donc, dès que la boucle while rencontre False, elle arrête l’itération et le programme passe à l’instruction suivante.

La validation des données dans une boucle Python

Imaginez qu’un utilisateur, par erreur ou intentionnellement, saisisse une donnée non-valide. En fait, la validation des données des utilisateurs, est généralement effectuée avec une boucle qui se répète tant qu’une variable fait référence à de mauvaises données.

Si par exemple nous voulons demander à l’utilisateur de saisir un âge compris entre 25 et 40 ans.

age = int(input('Saisissez votre âge: '))

while age < 25 or age > 40:
    print("cet âge n’est pas valide")
    age = int(input('Saisissez votre âge: '))

print('Bienvenue dans le club !')

Si vous saisissez un âge inférieur à 25 ans ou supérieur à 40 ans, la boucle s’exécutera et le programme vous demandera de saisir à nouveau votre âge. Donc, le message de bienvenue ne s’affichera plus, tant que vous n’avez pas saisie une valeur valide.

Saisissez votre âge: 55
cet âge n’est pas valide
Saisissez votre âge: 0
cet âge n’est pas valide
Saisissez votre âge: 24
cet âge n’est pas valide
Saisissez votre âge: -33
cet âge n’est pas valide
Saisissez votre âge: 33
Bienvenue au club !

Les boucles Python imbriquées

Il est possible de créer des boucles Python imbriquées. En fait, une boucle peut contenir une ou plusieurs autres boucles.
La forme la plus courante de boucles imbriquées est une boucle for imbriquée dans une autre boucle for, mais vous pouvez également avoir n’importe quelle autre combinaisons de boucles imbriquées.

Prenons des exemple pas à pas :

# Vous vous souvenez de la fonction range() !
for i in range(3):  
    print('*') 

À chaque itération de la boucle, ce code affichera un astérisque.

*
*
*

Répétons le code précédent deux fois

for i in range(3):  
    print('*') 
print()           # Un saut de ligne
for i in range(3):  
    print('*')

Nous aurons 2 blocs d’astérisques.

*
*
*

*
*
*

Essayez le code ci dessous.

for i in range(2):
    for i in range(3):
        print('*') 
    print()           

*
*
*

*
*
*

Comme vous pouvez le constater, pour répéter une boucle un certain nombre de fois, vous n’avez qu’à l’imbriquer à l’intérieur d’une autre boucle qui déterminera le nombre de répétitions de la boucle interne. Le saut de ligne s’effectue après la fin de la boucle interne.

Essayons à présent d’afficher les astérisques sur la même ligne 4 fois. Pour cela, nous utiliserons l’argument end=" " avec la fonction print().

# Afficher 3 astérisques sur la même ligne, quatre fois
for i in range(4):
    for i in range(3):
        print('*', end=" ") 
    print()           # Un saut de ligne, enlevez-le pour voir

Ça vous donnera :

***
***
***
***

Vous pouvez considérer que ce modèle est composé de 4 lignes et de 3 colonnes, souvenez-vous bien de ce concept, parce qu’il vous facilitera grandement la tâche.

La boucle externe se répète 4 fois. À chaque itération de la boucle externe, la boucle interne se répète 3 fois.

Maintenant, nous allons modifier l’index j de la boucle interne à chaque itération et le définir selon l’index i de la boucle externe. À chaque itération le nombre d’astérisques à afficher prendra la valeur de i.

for i in range(7):
    for j in range(i):
        print('*', end=" ") 
    print()           

Le résultat sera le suivant :

*
**
***
****
*****
******

Explications

Vous avez certainement remarqué que la première ligne est vide. C’est parce que le premier élément du range est le 0.

# i = 0 et j = 0
for j in range(0):
    print('*', end=" ")

Vous aurez une ligne vide.

>>>

Vous pouvez modifier ce comportement en ajoutant 1 à l’index i dans la boucle interne :
for j in range(i+1).

Lorsque j prend un range(0,1), vous aurez 1 astérisque.

# i = 1 et j = 0, 1
for j in range(1):
    print('*', end=" ") 

* 
>>>

Lorsque j prendra un range(0,2), vous aurez 2 astérisque.

for j in range(2):
    print('*', end=" ")

* * 
>>> 

Le premier tour de la boucle externe => la boucle interne fait 1 tour => *.
Le deuxième tour de la boucle externe => la boucle interne fait 2 tour => **.
Le troisième tour de la boucle externe => la boucle interne fait 3 tour => ***.

À présent, vous avez assez de connaissances pour créer de petits programmes. Je vous conseille de réviser les tutoriels précédents avant de continuer.