Les boucles WHILE.

Introduction :

En Python, la boucle while permet de répéter une série d'instructions tant qu'une condition est vraie.

Elle est utile lorsqu’on ne sait pas à l’avance combien de fois on devra répéter le code.

nombre = 0

somme = 0

tant que nombre est différent de 10:

somme = somme + nombre

nombre = nombre + 2

Affiche somme

Exécution

nombre = non défini

somme = non défini

True

Affiche 20

1. La boucle while

La boucle while répète un bloc d'instructions tant qu’une condition est vraie. Elle est utile lorsqu’on ne sait pas d’avance combien de fois répéter : on s’arrête dès que la condition devient fausse.

1. Syntaxe

while condition:
    # bloc exécuté tant que vaut True

2. Exemple : décompte à rebours

n = 5
while n > 0:
    print(n)
    n -= 1            # on rapproche n de 0 pour arrêter la boucle
print("Décollage !")

Sortie : 5 4 3 2 1 Décollage !

3. Exemple : demander un mot de passe

secret = "python"
code = ""
while code != secret:
    code = input("Mot de passe : ")
print("Accès autorisé")

4. Attention aux boucles infinies !

Si la condition ne devient jamais fausse, la boucle tourne sans fin :
while True: crée volontairement une boucle infinie, qu’on interrompt généralement avec break ou Ctrl + C.

À retenir

while répète tant qu’une condition est vraie.
Pense à modifier une variable ou l’entrée utilisateur pour que la condition devienne fausse !
Gare aux boucles infinies : vérifie toujours qu’il existe un moyen de sortir de la boucle.
Indentation : 4 espaces pour le bloc de la boucle.

2. Exercice : lecture d'une boucle while avec égalité.

Exécuter le programme suivant puis donner une explication au dernier nombre affiché.

x = 0 while x != 100: print(x) x = x + 10

>>>

3. Exercice : ordre des instructions dans une boucle while.

Exécuter le programme suivant puis donner une explication au dernier nombre affiché.

x = 0 while x != 100: x = x + 10 print(x)

>>>

4. Exercice : premier terme dépassant une limite.

On s’intéresse à l’expression \(n^2 + 3n + 6\) pour des entiers \(n = 0, 1, 2, 3, …\) Plus \(n\) grandit, plus le résultat est grand.

Écris une fonction appelée premier_n_depasse qui prend :

limite un nombre à dépasser.

La fonction doit renvoyer le plus petit entier n (à partir de 0) pour lequel n² + 3n + 6 est strictement supérieur à limite.

Pour cela :

Initialiser n à 0.
Tant que n² + 3n + 6 ne dépasse pas la limite, augmenter n de 1.
Renvoyer n.

Exemples :

premier_n_depasse(5) → 0 (car 0² + 0 + 6 = 6 dépasse 5)
premier_n_depasse(6) → 1 (car 1 + 3 + 6 = 10 dépasse 6)
premier_n_depasse(10) → 2
premier_n_depasse(16) → 3

def premier_n_depasse(limite): n = .. while n**2 + 3*n + 6 <= limite : n = .. # On passe à l'entier suivant return .. limite = 100 print(f"Le plus petit n tel que n²+3n+6 dépasse {limite} est {premier_n_depasse(limite)}.")

>>>

5. Exercice : croissance d'une plante avec while.

Un jardinier plante une jeune pousse. On modélise sa hauteur (en cm) après \(n\) semaines par :

\(h(n) = 2n^2 + 5n + 10\)

Au départ (semaine 0), la pousse mesure donc \(h(0) = 10\) cm, puis elle grandit de plus en plus vite.

Écris une fonction appelée semaines_pour_hauteur qui prend :

hauteur_cible une hauteur à dépasser, en cm.

La fonction doit renvoyer le nombre de semaines à attendre pour que la plante dépasse (strictement) la hauteur_cible.

Pour cela :

Initialiser n à 0.
Tant que \(2n^2 + 5n + 10\) ne dépasse pas la hauteur_cible, augmenter n de 1.
Renvoyer n.

Exemples :

semaines_pour_hauteur(10) → 1 (semaine 0 : 10 cm, pas encore dépassé ; semaine 1 : 17 cm)
semaines_pour_hauteur(20) → 2 (semaine 2 : 28 cm)
semaines_pour_hauteur(50) → 4 (semaine 4 : 62 cm)
semaines_pour_hauteur(100) → 6 (semaine 6 : 112 cm)

def semaines_pour_hauteur(hauteur_cible): ... hauteur_cible = 100 print(f"La plante dépasse {hauteur_cible} cm au bout de {semaines_pour_hauteur(hauteur_cible)} semaines.")

>>>

6. Exercice : nombre de vues d'une vidéo.

Une vidéo est mise en ligne. On modélise son nombre total de vues après \(n\) jours par :

\(v(n) = 3n^2 + 10n + 50\)

Le jour de la publication (jour 0), elle compte déjà \(v(0) = 50\) vues, puis elle est partagée de plus en plus.

Écris une fonction appelée jours_pour_vues qui prend :

objectif_vues un nombre de vues à dépasser.

La fonction doit renvoyer le nombre de jours à attendre pour que la vidéo dépasse (strictement) l’objectif_vues.

Pour cela :

Initialiser n à 0.
Tant que \(3n^2 + 10n + 50\) ne dépasse pas l’objectif_vues, augmenter n de 1.
Renvoyer n.

Exemples :

jours_pour_vues(50) → 1 (jour 0 : 50 vues, pas encore dépassé ; jour 1 : 63 vues)
jours_pour_vues(100) → 3 (jour 3 : 107 vues)
jours_pour_vues(200) → 6 (jour 6 : 218 vues)
jours_pour_vues(300) → 8 (jour 8 : 322 vues)

def jours_pour_vues(objectif_vues): ... objectif_vues = 300 print(f"La vidéo dépasse {objectif_vues} vues au bout de {jours_pour_vues(objectif_vues)} jours.")

>>>

7. Exercice : épargne hebdomadaire pour atteindre un objectif.

Léa met de l’argent dans sa tirelire. Elle commence à 0 € et ajoute 5 € chaque semaine.

Écris une fonction appelée semaines_pour_objectif qui prend :

objectif la somme à atteindre, en euros.

La fonction doit :

Initialiser un compteur de semaines et une somme d’argent à 0.
Tant que l’argent n’a pas atteint l’objectif :

Léa ajoute 5 € ;
on ajoute 1 au nombre de semaines.

Renvoyer le nombre de semaines.

Exemples :

semaines_pour_objectif(0) → 0
semaines_pour_objectif(5) → 1
semaines_pour_objectif(12) → 3
semaines_pour_objectif(20) → 4

def semaines_pour_objectif(objectif): semaines = .. argent = .. while argent < objectif : argent = .. # Elle ajoute 5 € semaines = .. # Une semaine de plus return .. objectif = 100 print(f"Il faut {semaines_pour_objectif(objectif)} semaines pour atteindre {objectif} €.")

>>>

8. Exercice : escalade d'un escalier.

Un robot monte un escalier. Il grimpe 3 marches par jour.

Écris une fonction appelée jours_pour_haut qui prend :

hauteur_visee la hauteur de l’escalier en nombre de marches.

La fonction doit :

Initialiser un compteur de jours et une position actuelle à 0.
Tant que le robot n’a pas atteint la hauteur_visee :

il grimpe de 3 marches ;
on ajoute 1 au nombre de jours.

Renvoyer le nombre de jours.

Exemples :

jours_pour_haut(0) → 0
jours_pour_haut(2) → 1
jours_pour_haut(5) → 2
jours_pour_haut(10) → 4

def jours_pour_haut(hauteur_visee): jours = .. position = .. while position < hauteur_visee : position = .. # Il grimpe de 3 marches jours = .. # Un jour de plus return .. x = 40 print(f"Il a fallu {jours_pour_haut(x)} jours au robot pour monter les {x} marches.")

>>>

9. Exercice : temps nécessaire pour doubler une population.

Dans une réserve naturelle, une colonie de lapins compte 100 individus au départ. Chaque mois, sa population augmente d'un certain pourcentage appelé taux de croissance.

Les biologistes souhaitent savoir au bout de combien de mois la population aura au moins doublé, c'est-à-dire atteint 200 individus.

Écrire une fonction mois_pour_doubler(taux) qui prend en paramètre le taux de croissance mensuel (en pourcentage) et qui renvoie le nombre de mois nécessaires pour que la population ait au moins doublé.

On ne connaît pas à l'avance le nombre de mois : on répète tant que la population n'a pas doublé. C'est exactement pour cela que la boucle while est adaptée.

Exemples :

mois_pour_doubler(100) → 1 (la population double chaque mois)
mois_pour_doubler(50) → 2
mois_pour_doubler(25) → 4
mois_pour_doubler(10) → 8

def mois_pour_doubler(taux): population = 100 # population de départ mois = 0 coeff_multiplicateur = 1 + ... while ... : # tant que la population n'a pas doublé population = population * ... mois = ... # un mois de plus return ... t = 10 print(f"Avec un taux de {t} % par mois, la population double en {mois_pour_doubler(t)} mois.")

>>>

10. Exercice : doublement d'une population bactérienne.

Une culture bactérienne compte 1 bactérie au départ. Chaque heure, la population double.

Écrire une fonction heures_doublement(N) qui calcule et renvoie le nombre d’heures nécessaires pour atteindre au moins N bactéries.

La fonction doit :

Si N vaut 1 ou moins, retourner 0 (déjà atteint).
Initialiser un compteur heures à 0 et une variable population à 1.
Tant que population est strictement inférieur à N :
- Multiplier population par 2.
- Incrémenter heures de 1.
Retourner la valeur de heures.

def heures_doublement(N): ...

>>>

11. Exercice : remplissage d'une piscine avec évaporation.

Une immense piscine est vide et contient 0 L d’eau.

Chaque jour, 5% de l'eau s'évapore mais on peut la remplir de 500 L d’eau à l'aide d'un tuyau.

On se pose la question de savoir en combien de jours elle peut atteindre une certaine quantité d'eau.

On ne dépassera jamais une année c'est-à-dire 365 jours. On considèrera alors qu'il est non réalisable de mettre cette quantité d'eau dans la piscine.

Écrire la fonction nb_de_jours(quantité_voulue) qui prend un nombre entier correspondant à une quantité d'eau souhaitée à l'intérieur de la piscine et qui renvoie le nombre de jours nécessaire pour la remplir.

Puis répondre aux questions suivantes :

En combien de jours peut-on la remplir de 1000 litres ?
En combien de jours peut-on la remplir de 3000 litres ?
En combien de jours peut-on la remplir de 5000 litres ?
En combien de jours peut-on la remplir de 8000 litres ?
Est-il réalisable de remplir la piscine avec 9000 litres d'eau ?
Est-il réalisable de remplir la piscine avec 9500 litres d'eau ?
Est-il réalisable de remplir la piscine avec 9700 litres d'eau ?
Est-il réalisable de remplir la piscine avec 9900 litres d'eau ?
Est-il réalisable de remplir la piscine avec 9950 litres d'eau ?
Est-il réalisable de remplir la piscine avec 10000 litres d'eau ?

def nb_de_jours(quantité_voulue): jour = 0 quantité_versée = 0 while jour < 365 and quantité_versée < .... : quantité_versée = ... # perte de 5% jour = ... quantité_versée = ... # ajout des 500 litres. return ... x = 1000 print(f"Pour remplir {x} litres, il est nécessaire de remplir la piscine pendant {nb_de_jours(x)} jours.")

>>>

12. Exercice : simulation de lancers de dé.

On souhaite modéliser un lancer de dé à l'aide de la commande random.randint(1, 6) de la bibliothèque random

Le but est de simuler plusieurs lancers d'un dé à la suite et déterminer combien de fois il a fallu lancer le dé pour obtenir un certain nombre de 6.

Pour cela, programmer la fonction simulation(nb_6_voulu) qui va simuler les lancers de dés et qui retourne le nombre de fois où il a fallu lancer le dé pour obtenir un nombre nb_6_voulu de 6.

Par exemple, si l'exécution de simulation(30) retourne 150 cela veut dire que lors de cette simulation, il a fallu lancer 150 fois le dé pour obtenir 30 fois le nombre 6.

import random def simulation(nb_6_voulu): nb_6_obtenu = ... nb_lancer = ... while nb_6_obtenu < .... : nb_lancer = ... dé = random.randint(... , ...) if ... : nb_6_obtenu = ... return ... x = 100 print(f"Pour obtenir {x} fois le nombre 6, il a fallu lancer {simulation(x)} fois le dé.")

# Pas de tests ici puisque le résultat est aléatoire.

>>>

Les boucles WHILE.

Introduction :

1. La boucle while

1. Syntaxe

2. Exemple : décompte à rebours

3. Exemple : demander un mot de passe

4. Attention aux boucles infinies !

À retenir

2. Exercice : lecture d'une boucle while avec égalité.

3. Exercice : ordre des instructions dans une boucle while.

4. Exercice : premier terme dépassant une limite.

5. Exercice : croissance d'une plante avec while.

6. Exercice : nombre de vues d'une vidéo.

7. Exercice : épargne hebdomadaire pour atteindre un objectif.

8. Exercice : escalade d'un escalier.

9. Exercice : temps nécessaire pour doubler une population.

10. Exercice : doublement d'une population bactérienne.

11. Exercice : remplissage d'une piscine avec évaporation.

12. Exercice : simulation de lancers de dé.

2. Exemple : décompte à rebours

3. Exemple : demander un mot de passe

4. Attention aux boucles infinies !