C’est le cours python numéro 9 de la série des cours d’initiation à python.

L’instruction break

Nous avons vu que dans un certain temps, Python exécute la boucle et chaque fois qu’il atteint la fin, il revérifie la condition de contrôle et finit par quitter la boucle. Parfois la condition pour sortir du while est trop compliquée, d’autres fois il serait préférable de sortir de la boucle non pas au bout de celle-ci mais à une ligne intermédiaire. C’est possible avec l’instruction break.

Lorsque, au cours d’une boucle, Python rencontre l’instruction break, toutes les lignes de l’interruption à la fin de la boucle sont ignorées et le programme quitte la boucle en continuant avec la première instruction suivante.

La rupture est souvent utilisée lorsque l’on doit faire une recherche sur un ensemble d’éléments. Supposons que nous ayons un ensemble de plusieurs boîtes, dont l’une contient 100 euros. Potentiellement il faut tous les examiner : on ouvre le premier, puis le second… et quand on trouve la bonne boite on s’arrête car on n’a pas besoin d’examiner le reste. Voici un exemple.

NOUVEAU PROGRAMME : divisibility.py

Ce programme recherche un diviseur d’un nombre entier saisi par l’utilisateur. Il demande d’abord à l’utilisateur d’entrer le nombre n, puis entre dans une boucle while qui utilise un compteur k. A partir de 2, le programme vérifie (avec l’opérateur %) le reste de toutes les divisions n : k. Si l’un d’eux donne le reste 0, n est divisible par k et le programme sort de la boucle avec le break. Si au contraire il ne trouve pas de diviseurs, il sort (avec la condition while) lorsque k est supérieur à n // 2 (si k est supérieur à la moitié de n la division donnera certainement 1 avec le reste).

n = int (input ("Ecrire un nombre")) # vérifie si ce nombre est premier
k = 2 # compteur : commence à partir de 2 ...
tant que k <= n // 2 : # ... et arrive à n // 2
     si n% k == 0 : # si c'est vrai, n est divisible par k
         print (n, "est divisible par", k)
         break # a trouvé un diviseur, on sort de la boucle
     k + = 1 # sinon on incrémente le compteur

Parfois, à la fin de la boucle, il est nécessaire que le programme “sache” s’il est sorti à cause d’une rupture ou parce que la condition de contrôle s’est avérée fausse. Pour cette raison, il est possible d’insérer une instruction else immédiatement après le while (au même niveau d’indentation) : elle est exécutée si la condition est fausse (et donc la boucle a été quittée non pas à cause de la rupture) alors qu’elle est ignorée si le sortait avec la pause.

Attention! Il est toujours possible d’insérer un else à la fin du while, mais cela ne sert à rien s’il n’y a pas de break à l’intérieur, car le else serait toujours exécuté à la fin de la boucle (car la condition est devenue fausse). Il fonctionnerait même si vous n’entriez pas du tout dans le cycle.

NOUVEAU PROGRAMME : test_while_else.py

a = 0
while a < 10:
    print ("a =", a)
    a = a + 1
else:               #l'else viene SEMPRE eseguito
    print ("Ho eseguito l'else")

Modifiez le programme précédent en mettant a = 1000 dans la première ligne.

Une solution drastique qui est parfois adoptée lorsque les conditions de sortie sont très compliquées est celle-ci (ajoutez ces lignes à la fin du programme) :

a = 0
while True : #c'est toujours vrai ! ici tu ne sors jamais !
                     # parfois on utilise aussi while 1 :
     print ("Je fais des calculs tellement compliqués")
     si a == 10 :
         break # sort réellement de la boucle ici
     a + = 1

Instruction continue

Cette instruction provoque immédiatement l’itération suivante : elle saute toute la partie de continuer jusqu’à la fin de la boucle. C’est en fait une instruction non essentielle (vous pourriez obtenir le même effet avec un if ou un else), mais cela permet souvent de rendre le programme plus lisible. L’utiliser ou non est une question de goût du programmeur : généralement, il est utilisé si nous voulons sauter une itération dans la boucle.

NOUVEAU PROGRAMME : prova_continue.py

Ce programme écrit les carrés et les cubes des nombres de 1 à 100, moins un nombre choisi par nous :

salta = int(input("Quel numéro dois-je sauter ? "))
i = 0
while i < 100:
    i += 1
    if i == saut:
        continue
    print("i =", i)
    print("Le carré de i est ", i ** 2)
    print("Le cube de i est ", i ** 3)
print ("finir")

Dans ce cas, il est clair que nous pourrions obtenir le même comportement avec un else, mais supposons que la boucle while soit composée d’un grand nombre de lignes : nous devrions toutes les indenter deux fois. Cela rend le programme plus facile à écrire.

Question : pourquoi ai-je incrémenté le compteur au début ? Que se passerait-il si je l’incrémentais en fin de cycle comme je l’ai toujours fait jusqu’à présent ?

NOUVEAU PROGRAMME answers.py

Un gros problème dans les programmes qui nécessitent de l’interactivité est le contrôle de l’entrée de l’utilisateur. Par exemple, considérez cet extrait de code :

risp = input("Envie de pizza ou de pâtes ?")
if risp == "pizza":
    print ("Vous avez commandé la pizza")
else:
    print ("Vous avez commande les pâtes")

Ici, le contrôle est très faible car le programme suppose que vous tapez “pizza” ou “pasta”. Que se passerait-il si vous répondiez “qwertyuiop” à l’entrée ? (Pensez-y) …

Voyons maintenant un programme un peu plus sophistiqué qui nous demande de répondre “s” ou “n” et répète sans cesse la question si nous écrivons quelque chose de différent : essayez de comprendre comment j’ai utilisé les différentes techniques décrites dans cette leçon :

# pas besoin d'initialisation car la montre ne contient aucune variable

tandis que Vrai :
     resp = input ("Voulez-vous une tasse de café ? (y / n)")
     si resp == "s" ou resp == "n":
         Pause
     print ("Entrée invalide")
imprimer ("Bonjour !")

La boucle est toujours exécutée (tandis que True :). Il n’est quitté avec la pause que lorsque la réponse est “s” ou “n”, sinon “Saisie invalide” est imprimée et le cycle recommence.

Attention! Cependant, ce programme devra supposer que notre entrée est un nombre. Si nous entrons dans une chaîne comme xyzw, elle plantera avec une ValueError. Pour contrôler ces situations, nous avons besoin d’instructions que nous ne connaissons pas encore.