15 minutes de Python
Boucle while : répéter intelligemment des instructions sous condition
Rappels fondamentaux
En langage Python, une boucle while sert à répéter un bloc d’instructions
tant qu’une condition logique est vraie. On ne fixe pas à l’avance le nombre
d’itérations : c’est la condition qui décide de l’arrêt.
while condition:
# instructions répétées
# mise à jour des variables
La condition est ré-évaluée à chaque tour de boucle. Dès qu’elle devient fausse, on sort de la boucle. Il faut donc toujours prévoir une mise à jour des variables impliquées dans la condition, sinon on risque la boucle infinie.
Exemple
u = 1.0 # terme initial
q = 0.9 # raison < 1 : la suite converge vers 0
n = 0
# On cherche le premier rang n tel que u_n < 1e-3
while u >= 1e-3:
print("n =", n, "u_n =", u)
u = q * u
n += 1
print("Premier rang où u_n < 10^-3 :", n)
print("Valeur de u_n :", u)Explication
On commence avec la valeur initiale u = 1.0. À chaque passage dans la
boucle while, on met à jour la variable u en appliquant la
relation de récurrence u = q * u, puis on augmente le rang n.
Tant que u reste supérieur ou égal à 1e-3, la boucle continue
et la variable u reçoit donc successivement les valeurs \(1, q, q^2,
\ldots, q^n, \ldots\).
La condition d’arrêt est u >= 1e-3 ; l’écriture 1e-3 signifie
la même chose que \(10^{-3}\), ce qui est équivalent en Python, à
10**(-3).
Lorsque la condition devient fausse, c’est-à-dire lorsque \(u_n < 10^{-3}\),
la boucle s’arrête automatiquement. À ce moment-là, la variable n
contient le premier rang pour lequel le terme de la suite devient inférieur
à \(10^{-3}\).
Trois commandes utiles aujourd’hui
Clique sur une carte pour voir l’instruction utile.
a = float(input("x = "))
Cette instruction :
- affiche le message
x =à l’écran, - utilise
input()pour demander à l’utilisateur de saisir une valeur, - convertit cette valeur en réel (flottant pour Python) avec
float(), - stocke le résultat dans la variable
a.
Au final, a contient un réel saisi par l’utilisateur.
print("Résultat :", x)
Cette instruction :
- affiche du texte à l’écran, ici la chaîne de caractères
"Résultat :", - affiche ensuite la valeur contenue dans la variable
x, - sépare automatiquement les différents éléments par un espace,
- passe à la ligne après l’affichage.
Au final, l’utilisateur voit à l’écran le texte Résultat : suivi de la valeur de x.
np.log(x)
Calcule \( \ln(x) \) pour la valeur (ou le tableau de valeurs) \( x \), en renvoyant un nombre réel (si \( x > 0 \)).
Un exercice pour vérifier ta maîtrise
Pour trouver une valeur approchée de \( \sqrt{2} \) (c’est-à-dire de la solution positive de l’équation \( x^2 = 2 \)) à \( \varepsilon \) près, on peut utiliser la méthode dite de balayage : on part de \( x = 0 \) et on compare \( x^2 \) avec 2, puis on recommence en ajoutant \( \varepsilon \) une première fois, puis une deuxième fois, … et ainsi de suite jusqu’à avoir \( x^2 > 2 \).
Les deux dernières valeurs \( a \) et \( b \) prises par \( x \) fournissent alors un encadrement de la solution cherchée tel que \( b - a \leqslant \varepsilon \). On peut donc proposer \( a \) ou \( b \) comme valeur approchée.
Compléter le code suivant pour que le programme affiche une approximation de \( \sqrt{2} \) à \( \varepsilon \) près, la valeur de \( \varepsilon \) étant entrée par l’utilisateur.
x = 0.0
eps = float(input("Entrer epsilon : "))
while x**2 <= 2:
x = x + eps
print("x =", x)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.