duranton.net

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.

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

2. Exercice :

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

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

Tests :

# Tests

Affichage :

Console:



    

      >>>
      
    

  










  
3. Exercice :


  

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

  


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


  
  


  
Tests :

  
# Tests




  
Affichage :

  


  
Console:

  

    


    

      >>>
      
    

  







  
4. Exercice :


  

    

    
Écris une fonction appelée somme_n_premiers_while qui prend un entier
       n en paramètre et utilise une boucle while
       pour calculer la somme des n premiers entiers, de 1 à
       n (inclus).


    
La fonction doit retourner cette somme :


    
    
      
  • Par exemple, pour n = 5, elle renverra 15,
          car 1 + 2 + 3 + 4 + 5 = 15.
    • 
    


    
Exemples :


    
    
      
  • somme_n_premiers_while(0) → 0
    • 
      
  • somme_n_premiers_while(5) → 15
    • 
      
  • somme_n_premiers_while(10) → 55
    • 
    

  


  
  
def somme_n_premiers_while(n):
    somme = 0
    nombre = 1
    while ........... :
  
  
  
  

n = 25
print(f"La somme de {n} premiers nombres entiers strictement positifs est ")
print(f"1 +  .... + {n} = {somme_n_premiers_while(n)}" )


  
  

 
  
Tests :

  
# Tests




  
Affichage :

  


  
Console:

  

    


    

      >>>
      
    

  











  
5. Exercice :


  

      

        
      

       Un robot monte un escalier. Il grimpe 3 marches par jour, 
       mais chaque nuit il glisse de 1 marche.


    
Écris une fonction appelée jours_pour_haut qui prend:

    
    
      
  • hauteur_visée  la hauteur de l’escalier en nombre de marches.
    • 
    


    
La fonction doit:

    
    
      
  1. Renvoyer 0 si la hauteur est égale à 0.
    2. 
      
  2. Initialiser un compteur de jours et une position actuelle à 0.
    3. 
      
  3. Chaque jour, le robot grimpe de 3 marches.
    4. 
      
  4. Vérifie s’il a atteint ou dépassé la hauteur visée : si oui, retourne le nombre de jours.
    5. 
      
  5. Sinon, il glisse de 1 marche et continue.
    6. 
    


    
Exemples:

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

  


  
def jours_pour_haut(hauteur_visée):
    if hauteur == 0:
        return ..
    compteur_jours = ..
    position_actuelle = ..
    while position_actuelle < hauteur_visée :
        compteur_jours = ..
        position_actuelle = ..    # Il grimpe de 3 marches
        if .. :   # s'il est arrivé à la hauteur visée ou juste au dessus.
          ..      #On renvoie le nombre de jours.
        else : 
          ..      #Il dégringole d'une marche


x = 40
print(f"Il a fallu {jours_pour_haut(x)} jours au robot pour monter les {x} marches.")


  

  
  
Tests :

  
# Tests




  
Affichage :

  


  
Console:

  

    


    

      >>>
      
    

  














  
6. Exercice :


  

    
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 :

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



  


  
def heures_doublement(N):
    ...
  


  

 
  
Tests :

  
# Tests




  
Affichage :

  


  
Console:

  

    


    

      >>>
      
    

  








  
7. Exercice :


  

    
     
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.


    
Ecrire 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 :

    
    
      
  1. En combien de jours peut-on la remplir de 1000 litres?
    2. 
      
  2. En combien de jours peut-on la remplir de 3000 litres?
    3. 
      
  3. En combien de jours peut-on la remplir de 5000 litres?
    4. 
      
  4. En combien de jours peut-on la remplir de 8000 litres?
    5. 
      
  5. Est-il réalisable de remplir la piscine avec 9000 litres d'eau? 
    6. 
      
  6. Est-il réalisable de remplir la piscine avec 9500 litres d'eau? 
    7. 
      
  7. Est-il réalisable de remplir la piscine avec 9700 litres d'eau? 
    8. 
      
  8. Est-il réalisable de remplir la piscine avec 9900 litres d'eau? 
    9. 
      
  9. Est-il réalisable de remplir la piscine avec 9950 litres d'eau? 
    10. 
      
  10. Est-il réalisable de remplir la piscine avec 10000 litres d'eau? 
    11. 

    

  


  
  
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.")


  
  


  
Tests :

  
# Tests




  
Affichage :

  


  
Console:

  

    


    

      >>>
      
    

  











  
8. Exercice :


  

    
     
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é.")


  
  


  
Tests :

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




  
Affichage :

  


  
Console:

  

    


    

      >>>
      
    

  








  
9. Exercice :


  

    
La factorielle d’un entier k, notée k!, est le produit de tous les entiers de 1 à k.  
    Par exemple :

    
    
      
  • \(1! = 1\)
    • 
      
  • \(2! = 2 \times 1 = 2\)
    • 
      
  • \(3! = 3 \times 2 \times 1 = 6\)
    • 
      
  • \(4! = 4 \times 3 \times 2 \times 1 = 24\)
    • 
    

    
On cherche le plus petit entier k tel que k! soit au moins égal à N.

    
Écrire une fonction etapes_factorielle(N) qui renvoie ce k.

    
La fonction doit :

    
    
      
  1. Initialiser k à 1 et fact à 1.
    2. 
      
  2. Tant que fact < N :
        
      
          
    • Incrémenter k de 1.
      • 
          
    • Multiplier fact par k.
      • 
        
    
      
    3. 
      
  3. Retourner la valeur de k.
    4. 
    



  


  
def etapes_factorielle(N):
      ...


  

 
  
Tests :

  
# Tests




  
Affichage :

  


  
Console:

  

    


    

      >>>