15 minutes de Python
Boucle while : répéter tant qu’une condition est vraie
La boucle while : répéter tant qu’une condition est vraie
Il arrive que l’on ait besoin de répéter plusieurs fois les mêmes instructions, mais sans connaître à l’avance le nombre exact de répétitions nécessaires.
Par exemple :
- répéter un calcul jusqu’à ce qu’une valeur devienne suffisamment petite,
- approcher la limite d’une suite,
- chercher le premier rang à partir duquel une propriété est vérifiée.
Dans ce type de situations, la boucle for n’est pas toujours adaptée.
On utilise alors une boucle while, qui permet de répéter des instructions
tant qu’une condition est vraie.
Syntaxe d’une boucle while
while condition:
instruction_1
instruction_2
instruction_3
Cette écriture signifie : tant que la condition est vraie, Python exécute toutes les instructions indentées.
L’indentation joue exactement le même rôle que pour la boucle for :
seules les lignes décalées vers la droite sont répétées.
Principe fondamental
Une boucle while repose toujours sur trois éléments essentiels :
- une initialisation avant la boucle,
- une condition testée avant chaque répétition,
- une mise à jour des variables à l’intérieur de la boucle.
Sans mise à jour, la condition peut rester toujours vraie : on crée alors une boucle infinie.
Exemple 1 : dépasser un seuil
x = 1
n = 0
while x < 100:
x = 2*x
n = n + 1
print(n, x)
Le programme double la valeur de x tant que x < 100.
La boucle s’arrête dès que cette condition devient fausse.
La valeur affichée de n est le nombre d’itérations nécessaires
pour dépasser 100.
Exemple 2 : approximation d’une limite
u = 1
n = 0
while u > 0.001:
u = 0.5*u
n = n + 1
print(n, u)
Le programme divise u par 2 tant que u est strictement supérieur à 0.001.
Il s’arrête lorsque u devient inférieur ou égal à ce seuil.
La valeur de n correspond alors au premier rang pour lequel la condition n’est plus vérifiée.
Différence essentielle avec la boucle for
-
La boucle
forest utilisée quand le nombre de répétitions est connu à l’avance. -
La boucle
whileest utilisée quand on ne sait pas à quel moment on va s’arrêter, mais seulement quelle condition doit être vérifiée pour continuer.
Exemple
u = 1
n = 0
while u < 100:
u = 2*u
n = n + 1
print("u =", u)
print("n =", n)
Explication
-
u = 1etn = 0: on initialise une valeur de départuet un compteurn. Le compteur servira à mémoriser le nombre de passages dans la boucle. -
while u < 100:: la condition de boucle estu < 100. Tant que cette condition est vraie, les instructions indentées sont exécutées. -
u = 2*u: à chaque tour de boucle, la valeur deuest doublée. On construit ainsi la suite définie par \(u_{n+1} = 2u_n\). -
n = n + 1: à chaque doublement, on incrémente le compteur. La variablenest donc exactement le nombre de fois où la boucle a été exécutée. -
Lorsque
udevient supérieur ou égal à100, la conditionu < 100devient fausse : la boucle s’arrête. -
À la fin du programme,
uest la première valeur de la suite supérieure ou égale à100, etnest le plus petit entier tel que \(2^n \ge 100\). Le programme affiche alors exactement ces deux valeurs.
Un exercice pour vérifier ta maîtrise
Compléter le script pour qu’il demande deux réels strictement positifs u et a avec a > 1, puis détermine le plus petit entier n tel que \(u\times a^n \ge 100\).
Le programme devra afficher ce plus petit entier n ainsi que la valeur correspondante de u.
u = float(input('u = '))
a = float(input('a = '))
n = 0
while u < 100:
u = a*u
n = n + 1
print('n =', n)
print('u =', u)
Explication
- On initialise une valeur
uet un compteurn. - La condition
u < 100est testée avant chaque itération. - Tant que
u < 100, on remplaceupara*uet on incrémenten. - Quand la boucle s’arrête,
nest le plus petit entier tel que \(u_0 a^n \ge 100\). - Le programme affiche exactement
net la valeur finale deu.
Et pour quelques minutes de plus…
Prendre en main la programmation, pas à pas.
Ces exercices sont conçus pour t’aider à maîtriser progressivement la programmation en Python, en partant de la lecture et de la compréhension du code, jusqu’à l’écriture autonome de scripts complets.
L’objectif n’est pas d’aller vite, mais de construire des automatismes solides, en comprenant ce que fait chaque instruction, puis en apprenant à les utiliser par toi-même.
L’ordre des exercices est volontaire : on lit, on comprend, on complète, puis on écrit seul. Prends le temps de chaque étape : c’est la clé pour progresser durablement.
Niveau 1 Analyser un code
Comprendre avant d’écrire.
Dans cette première série, tu observes et analyses des scripts Python déjà écrits.
L’objectif est de comprendre la logique du programme, le rôle des variables, des boucles
et des conditions, et d’être capable de prévoir ce que le code affiche ou calcule.
Niveau 2 Compléter un code
Écrire, mais avec un cadre.
Ici, tu passes à l’écriture sans partir de zéro.
Le squelette du programme est fourni : il te reste à compléter certaines instructions
pour que le code fonctionne correctement.
Ce format permet de se concentrer sur l’essentiel, sans se perdre dans la structure générale.
Niveau 3 Écrire un code complet
Passer à l’autonomie.
Dans cette dernière série, tu écris un programme complet à partir d’une consigne.
Tu dois organiser ton code, choisir les bonnes instructions et construire la logique globale du script.
C’est ici que tu mets en pratique tout ce que tu as appris dans les niveaux précédents.
Contenu réservé aux membres
Il faut être membre et connecté pour accéder aux exercices et aux corrigés.