Ctrl+K

Boucle « tant que »

9. Boucle « tant que »#

Maintenant que nous connaissons les valeurs booléennes, nous pouvons introduire une boucle. Celle-ci nous permet de répéter l’exécution d’un bloc d’instructions.

9.1. La boucle while#

La boucle tant que est une structure de contrôle qui permet de répéter un ensemble d’instructions tant qu’une condition est vrai.

Voici un premier exemple, il permet de calculer la partie entière inférieure de la racine carrée d’un nombre saisi au clavier.

x = int(input("Saissez un entier. "))
i = 0
while (i+1)*(i+1) <= x:
   i += 1

print( "La racine carre entiere est : " + str(i) )

Voici la forme générale de cette boucle conditionnel.

while condition:
    instructions

On y trouve tout d’abord le mot clef while, la condition et enfin les : indiquant le bloc à suivre. Ce bloc, marqué par l’indentation, est l’ensemble des instructions exécutées tant que la condition est vraie.

Voici un autre exemple. La fonction read_value(n) demande à l’utilisateur une valeur tant que celle ci n’est pas comprise entre 0 et n inclus.

def read_value(n):
    print("Saisissez une valeur entre 0 et " + str(n) + " inclus")
    v = -1
    while v < 0 or v > n :
        v = int(input("Votre valeur ? "))
    return v

s = read_value(100)
print( "La valeur saisie est correcte.")
print( s )

9.2. Boucle infinie#

Il faut être vigilent avec les boucles car elles peuvent poser des soucis. Nous allons l’illustrer avec le calcul du logarithme en base 10 d’un nombre. Vous ne savez pas ce que c’est ? Pas de panique, c’est simplement le nombre de chiffres qui composent un nombre.

Une manière de déterminer le logarithme d’un nombre est de compter le nombre de fois qu’on peut le diviser par 10 (division entière). À force de diviser un nombre par 10, il va finir par valoir 0. Voici un exemple pour 127.

127 // 10 = 12 (division entière)
 12 // 10 =  1
  1 // 10 =  0
  0 -> on s'arrête après avoir fait 3 divisions, donc log(127) vaut 3

On peut implémenter cet algorithme pour obtenir la fonction suivante mais attention, elle ne fonctionne que pour des nombres entiers supérieurs ou égal à 0. Dans le cas où l’on utilise un nombre négatif, le programme entre dans une boucle infinie et ne termine plus. On le remarque car à gauche de notre script, l’étoile indique qu’un calcul est en cours (Entrée [*]). Il faut alors arêter le script en utilisant le bouton stop.

def log10(x):
    i = 0
    while x != 0 :
        x = x//10
        i += 1
    return i

x = int((input("Saisissez un nombre entier. ")))
l = log10(x)
print(l)

Voici une version corrigé de la fonction pour qu’elle puisse traiter les nombres négatifs sans erreur.

def log10(x):
    i = 0
    while x > 0 :
        x = x//10
        i += 1
    return i

x = int((input("Saisissez un nombre entier. ")))
l = log10(x)
print(l)

L’adaptation ci-dessus prend comme convention qu’un nombre négatif à un logarithme égal à 0. On pourrait préférer la version suivante dans laquelle le type de la valeur de retour n’est pas un entier mais None qui correspond à une absence de valeur.

def log10(x):
    if x < 0 :
        return None

    i = 0
    while x > 0 :
        x = x//10
        i += 1
    return i

x = int((input("Saisissez un nombre entier. ")))
l = log10(x)
print(l)

9.3. Quitter une boucle prématurément#

Il est possible de sortir d’une boucle sans que la condition ne devienne fausse. C’est le rôle de l’instruction break. Au moment de son exécution, la boucle en cours est intérompue. Son utilisation peut parfois simplifier le code.

L’exemple suivant nous permet d’illustrer son fonctionnement. La condition de cette boucle est toujours vrai mais l’exécution se termine malgré tout.

x = 1
while True :
     print( x )
     x += 1
     if x % 5 == 0 :
         break

print( "." )

9.4. Quelques clarifications#

Voici des éléments supplémentaires et des clarifications sur le comportement des fonctions.

9.5. Exercice#

Quelques petits exercices pour tester nos connaissances.

Écrire une fonction sum qui prend en paramètre un entier n (positif ou nul) et renvoie la somme des entiers de 1 à n autrement dit on cherche la valeur de 1+2+...+n. Attention aux boucles infinies.

def sum(n) :
    pass

Si votre fonction est correcte, alors l’exécution du code suivant ne devrait pas afficher de message.

if not sum(5) == 15 : print("Non ! La sum(5) devrait valoir 15")
if not sum(0) == 0 : print("Non ! La sum(0) devrait valoir 0")
if sum(3) == None : print("Non ! Votre fonction semble ne pas renvoyer de valeur.")

Si vous êtes satisfait de votre solution, ou si vous êtes réellement bloqué, vous pouvez afficher la solution ci-desssous. Rappellez-vous, si vous n’essayez pas, vous ne progresserez pas.

def sum(n)
    s = 0
    i = 1
    while i <= n:
        s += i
        i += 1
    return s

if not sum(5) == 15 : print("Non ! La sum(5) devrait valoir 15.")
if not sum(0) == 0 : print("Non ! La sum(0) devrait valoir 0.")
if sum(3) == None : print("Non ! Votre fonction semble ne pas renvoyer de valeur.")

Maintenant que vous avez les bases de la programmation impérative, nous allons réaliser un petit projet : le jeu du nombre secret.

Contenu