break en Python : sortir d'une boucle avant la fin

Définition

Une boucle a une habitude tenace : elle va jusqu'au bout. Elle parcourt tout ce qu'on lui donne, même quand la réponse cherchée est apparue au troisième élément et que les neuf cent mille suivants ne servent plus à rien. Il manque un moyen de dire « c'est bon, j'ai trouvé, on arrête ».

C'est le rôle de break. Cette instruction interrompt immédiatement la boucle qui la contient : les éléments non encore parcourus sont abandonnés, et le programme reprend à la première ligne écrite après la boucle.

L'exemple le plus courant est la lecture d'un fichier qui s'arrête sur un marqueur de fin.

for ligne in fichier:
    if ligne.startswith("FIN"):
        break        # on quitte la boucle, le reste du fichier est ignoré
    traiter(ligne)

Deux choses changent pour celui qui écrit ce code. La première est le temps gagné : le programme cesse de travailler sur des données dont il n'a plus rien à faire. La seconde compte davantage sur la durée : la ligne dit à voix haute la condition qui met fin au parcours, au lieu de la laisser deviner dans une variable de contrôle testée dix lignes plus haut.

Il ne sort que d'une boucle à la fois

Vient ensuite la question que tout le monde rencontre au premier tableau à deux dimensions : que se passe-t-il quand les boucles sont imbriquées ? La réponse surprend souvent. break ne quitte que la boucle la plus proche, celle qui le contient directement, et rien d'autre.

for ligne in grille:
    for case in ligne:
        if case == cible:
            break        # sort de la boucle des cases, pas de celle des lignes
    # ... et le parcours repart sur la ligne suivante, comme si de rien n'était

La cible est trouvée, et pourtant le programme continue de balayer la grille entière. Le résultat final reste parfois juste malgré tout, ce qui rend le défaut encore plus difficile à repérer : il ne se manifeste que par une lenteur inexpliquée, ou par une variable écrasée un tour trop tard.

Pour sortir des deux boucles d'un coup, trois chemins existent, et ils ne se valent pas. Le plus lisible déplace la double boucle dans une fonction et en sort avec return, qui, lui, quitte tout d'un seul geste et rend au passage la valeur trouvée. Un drapeau booléen posé dans la boucle intérieure puis relu dans la boucle extérieure fonctionne aussi, au prix d'une variable de plus à suivre. Lever puis intercepter une exception marche également, mais cela revient à détourner un mécanisme d'erreur pour piloter un parcours parfaitement normal : à garder pour les cas où les deux autres ne passent pas.

Sa relation avec le else de boucle

Une fois la sortie anticipée en place, une nouvelle question arrive : comment savoir, après coup, si la boucle s'est arrêtée parce qu'elle a trouvé, ou parce qu'elle a épuisé la liste sans rien trouver ? Le réflexe habituel consiste à poser un booléen avant la boucle et à le relire ensuite.

Python propose plus court. Une boucle peut porter un bloc else, et ce bloc ne s'exécute que si aucun break n'a été rencontré, autrement dit si le parcours est allé jusqu'au bout sans être interrompu.

for produit in catalogue:
    if produit.reference == reference:
        print("Disponible")
        break
else:
    print("Référence inconnue")   # atteint seulement si aucun break n'a eu lieu

Le couple forme le motif « chercher, et signaler si rien n'a été trouvé » sans la moindre variable intermédiaire. Il a un autre mérite : les deux issues du parcours se lisent l'une sous l'autre, au même endroit, au lieu d'être séparées par le corps de la boucle.

La boucle infinie contrôlée

Reste un cas où la condition d'arrêt ne peut pas être écrite en tête de boucle : celui où elle dépend de quelque chose qui n'existe pas encore au moment où la boucle démarre. Une saisie au clavier par input, par exemple. Impossible de savoir si la réponse est valable avant de l'avoir demandée.

D'où un motif qui repose entièrement sur break : la boucle while True, dont la condition est vraie pour toujours et qui ne s'arrête que par une sortie explicite écrite à l'intérieur.

while True:
    reponse = input("Continuer ? (o/n) ")
    if reponse in ("o", "n"):
        break                      # seule porte de sortie de la boucle
    print("Réponse non comprise")

Écrire la même chose avec une condition en tête obligerait à créer la variable avant la boucle et à lui donner une valeur artificielle, choisie uniquement pour que le premier tour ait lieu. Cette valeur ne veut rien dire, et elle finit par s'afficher à l'écran le jour où un message la reprend. La version avec break dit exactement ce qui se passe : on répète jusqu'à obtenir une réponse valable.

En échange, un risque apparaît. Si aucun chemin d'exécution ne rencontre le break, la boucle ne s'arrête jamais et le programme se fige, sans erreur ni message pour l'expliquer. Le réflexe à prendre en écrivant un while True est de vérifier tout de suite que chaque branche mène quelque part.

Questions fréquentes

Les deux interrompent quelque chose, mais pas la même chose. break quitte la boucle entièrement : ce qui restait à parcourir ne sera jamais vu. continue abandonne seulement le tour en cours et repart aussitôt sur l'élément suivant. Pour choisir, demandez-vous si les éléments restants ont encore un intérêt. S'ils en ont un, c'est continue ; sinon, c'est break.

Il y fonctionne, mais il n'agit pas sur lui. break vise toujours la boucle qui l'englobe, jamais le if dans lequel il est écrit : sortir d'un if n'aurait d'ailleurs aucun sens, un bloc conditionnel se termine tout seul à la fin de son indentation. Placé dans un if qui n'est lui-même dans aucune boucle, il déclenche une SyntaxError dès la lecture du fichier, avant même que la première ligne ne s'exécute.

C'est un vieux débat hérité d'autres langages, où la sortie unique tenait lieu de règle de style, et la réponse en Python est non. Sortir tôt évite un parcours inutile et rend l'intention plus lisible qu'une condition d'arrêt faite de trois tests collés. Le seul cas qui mérite qu'on s'arrête est celui d'une longue boucle truffée de sorties dispersées : le problème n'est plus le break, c'est la boucle, qui gagnerait à être découpée. La formation Python travaille ces arbitrages sur du code réel.