Partie 6 · exercices 62 à 71
Répéter tant qu'une condition est vraie
Parfois, on ne sait pas à l'avance combien de fois il faudra répéter : il faut recommencer tant que quelque chose n'est pas réalisé. C'est le rôle de la boucle while.
n = 10
while n > 0:
print(n)
n = n - 1
print("Décollage !")Tant que la condition n > 0 est vraie, Python exécute le bloc décalé, puis revient tester la condition. Dès qu'elle est fausse, il passe à la suite.
Les trois éléments d'un while | Dans l'exemple |
|---|---|
| 1. Initialiser la variable testée | n = 10 |
| 2. Une condition de poursuite | while n > 0 : |
| 3. Une modification de la variable dans le bloc | n = n - 1 |
Vigilance : la boucle infinie
Si on oublie la modification (n = n - 1), la condition reste vraie pour toujours : le programme ne s'arrête jamais.
Dans EduPython, arrête-le avec Ctrl + F2 (ou ferme la fenêtre d'exécution).
mot_de_passe = ""
while mot_de_passe != "python":
mot_de_passe = input("Mot de passe : ")
print("Accès autorisé")On ne sait pas combien d'essais fera l'utilisateur : un for ne conviendrait pas.
| Je choisis… | quand… | Exemple |
|---|---|---|
for | je connais le nombre de répétitions | afficher une table de multiplication |
while | je répète jusqu'à ce qu'une condition soit réalisée | attendre une bonne réponse, atteindre un seuil |
Modifie compte_a_rebours.py pour qu'il demande le nombre de départ, puis affiche le compte à rebours jusqu'à 0 et « Décollage ! ».
Remplace n = 10 par une saisie avec int(input(...)).
💾 NOM_Prenom_ex62.py
Écris un programme qui demande l'âge de l'utilisateur et recommence tant que la réponse est impossible (négative ou supérieure à 120). Il termine par « Merci, tu as ... ans. ».
Le test se fait avec or : age < 0 or age > 120.
Pose la question une première fois avant la boucle, puis à nouveau dans la boucle.
💾 NOM_Prenom_ex63.py
L'ordinateur choisit un entier au hasard entre 1 et 100 avec randint. Le joueur propose des nombres ; l'ordinateur répond « Trop petit » ou « Trop grand » jusqu'à ce que le joueur trouve, puis affiche le nombre d'essais.
Initialise essai à 0 : ainsi il est forcément différent du nombre mystère et la boucle démarre.
Dans la boucle : demander, compter l'essai, puis if / elif pour les indications.
Question 2 : pense à couper l'intervalle possible en deux à chaque essai.
💾 NOM_Prenom_ex64.py
Écris un programme qui cherche la plus petite puissance de 2 supérieure à 1 000 000 et affiche son exposant et sa valeur.
Deux variables : puissance qui vaut 1 au départ et est doublée à chaque tour, et exposant qui compte les tours.
Condition de poursuite : puissance <= 1000000.
💾 NOM_Prenom_ex65.py
À l'exercice 58, 1000 € placés à 2 % par an.
Ici, on ne connaît pas le nombre d'années à l'avance : c'est un while avec la condition capital < 2000.
💾 NOM_Prenom_ex66.py
Pour un entier \(n\) positif, \(n \% 10\) est son chiffre des unités et \(n // 10\) est l'entier privé de ce chiffre.
Tant que n > 0 : ajoute n % 10 à la somme, remplace n par n // 10, compte un chiffre.
Fais le tableau à la main pour 2026 : les valeurs successives de n sont 2026, 202, 20, 2, 0.
💾 NOM_Prenom_ex67.py
Le PGCD de deux entiers est leur plus grand diviseur commun. L'algorithme d'Euclide le calcule ainsi : on remplace le couple \((a\,;b)\) par \((b\,;r)\), où \(r\) est le reste de la division de \(a\) par \(b\), jusqu'à ce que le reste soit nul. Le PGCD est le dernier diviseur non nul.
Question 1 : \(1071 = 462 \times 2 + 147\), puis divise 462 par 147…
Dans la boucle : r = a % b, puis a = b, puis b = r. Dans cet ordre !
La boucle continue tant que b != 0.
💾 NOM_Prenom_ex68.py
On part d'un entier \(u\). Tant que \(u\) n'est pas égal à 1 : si \(u\) est pair, on le remplace par \(\dfrac{u}{2}\) ; s'il est impair, on le remplace par \(3u + 1\).
Par exemple, en partant de 6 : 6, 3, 10, 5, 16, 8, 4, 2, 1. On atteint 1 en 8 étapes.
On conjecture que, quel que soit l'entier de départ, on finit toujours par atteindre 1. Personne ne l'a démontré !
Dans la boucle, un if u % 2 == 0: ... else: change la valeur de u, et on compte une étape.
u // 2 renvoie un entier ; u / 2 renverrait un décimal.
Pour le maximum : maxi = u au départ, puis if u > maxi: maxi = u dans la boucle.
💾 NOM_Prenom_ex69.py
Un ordinateur écrit les nombres en base 2, avec seulement des 0 et des 1. Pour convertir un entier en binaire, on divise par 2 tant que possible en notant les restes, puis on lit les restes de bas en haut.
Pour 13 : \(13 = 2 \times 6 + 1\), puis divise 6 par 2…
Construis un texte : binaire = "" au départ, puis dans la boucle binaire = str(n % 2) + binaire (le nouveau chiffre se place à gauche).
Continue tant que n > 0, en remplaçant n par n // 2.
💾 NOM_Prenom_ex70.py
On inverse les rôles de l'exercice 64 : tu penses à un entier entre 1 et 100, et l'ordinateur essaie de le deviner.
À chaque essai, l'ordinateur propose le milieu de l'intervalle encore possible, et tu réponds + (mon nombre est plus grand), - (plus petit) ou = (trouvé). Le programme affiche le nombre d'essais à la fin.
Deux variables bas et haut délimitent l'intervalle possible : au départ 1 et 100.
Le milieu est (bas + haut) // 2.
Si la réponse est +, bas devient milieu + 1 ; si c'est -, haut devient milieu - 1.
💾 NOM_Prenom_ex71.py
Ce que je sais faire
while avec ses trois éléments : initialisation, condition, modification.for (nombre de tours connu) et while (on répète jusqu'à réalisation d'une condition).