Comment sortir des boucles multiples ?

Question

Etant donné le code suivant (qui ne fonctionne pas) :

while True:
    # Snip: print out current state
    while True:
        ok = get_input("Is this ok? (y/n)")
        if ok.lower() == "y": break 2 # This doesn't work :(
        if ok.lower() == "n": break

    # Do more processing with menus and stuff

Existe-t-il un moyen de faire fonctionner ce système ? Ou dois-je faire une vérification pour sortir de la boucle d'entrée, puis une autre vérification, plus limitée, dans la boucle extérieure pour sortir de l'ensemble si l'utilisateur est satisfait ?

Answer 1

Mon premier réflexe serait de refondre la boucle imbriquée en une fonction et d'utiliser la fonction return d'éclater.

Answer 2

Voici une autre approche qui est courte. L'inconvénient est que vous ne pouvez casser que la boucle extérieure, mais parfois c'est exactement ce que vous voulez.

for a in xrange(10):
    for b in xrange(20):
        if something(a, b):
            # Break the inner loop...
            break
    else:
        # Continue if the inner loop wasn't broken.
        continue
    # Inner loop was broken, break the outer.
    break

Ceci utilise la construction for / else expliquée à l'article : Pourquoi Python utilise-t-il "else" après les boucles for et while ?

Principaux enseignements : il n'y a qu'à semble comme si la boucle extérieure s'interrompait toujours. Mais si la boucle interne n'est pas interrompue, la boucle externe ne le sera pas non plus.

En continue est la magie de la déclaration. Elle se trouve dans la clause for-else. Par définition qui se produit s'il n'y a pas de rupture intérieure. Dans ce cas continue contourne parfaitement la rupture extérieure.

Answer 3

PEP 3136 propose une pause/continuation étiquetée. Guido l'a rejeté car "il est très rare qu'un code soit si compliqué qu'il nécessite cette fonctionnalité". Le PEP mentionne cependant quelques solutions de contournement (comme la technique de l'exception), tandis que Guido estime qu'un remaniement pour utiliser le retour sera plus simple dans la plupart des cas.

Answer 4

Tout d'abord, la logique ordinaire est utile.

Si, pour une raison ou une autre, les conditions de résiliation ne peuvent être définies, les exceptions constituent un plan de repli.

class GetOutOfLoop( Exception ):
    pass

try:
    done= False
    while not done:
        isok= False
        while not (done or isok):
            ok = get_input("Is this ok? (y/n)")
            if ok in ("y", "Y") or ok in ("n", "N") : 
                done= True # probably better
                raise GetOutOfLoop
        # other stuff
except GetOutOfLoop:
    pass

Pour cet exemple précis, une exception n'est peut-être pas nécessaire.

D'autre part, nous avons souvent des options "Y", "N" et "Q" dans les applications en mode caractère. Pour l'option "Q", nous voulons une sortie immédiate. C'est plus exceptionnel.

Answer 5

Je suis plutôt d'accord pour dire que le refactoring dans une fonction est généralement la meilleure approche pour ce genre de situation, mais pour ce qui est des cas où vous vraiment ont besoin de sortir des boucles imbriquées, voici une variante intéressante de l'approche de levée d'exception décrite par @S.Lott. Elle utilise la fonction with pour que la levée des exceptions soit un peu plus agréable. Définissez un nouveau gestionnaire de contexte (vous ne devez le faire qu'une seule fois) avec :

from contextlib import contextmanager
@contextmanager
def nested_break():
    class NestedBreakException(Exception):
        pass
    try:
        yield NestedBreakException
    except NestedBreakException:
        pass

Vous pouvez maintenant utiliser ce gestionnaire de contexte comme suit :

with nested_break() as mylabel:
    while True:
        print "current state"
        while True:
            ok = raw_input("Is this ok? (y/n)")
            if ok == "y" or ok == "Y": raise mylabel
            if ok == "n" or ok == "N": break
        print "more processing"

Avantages : (1) c'est un peu plus propre (pas de bloc try-except explicite), et (2) vous obtenez un bloc Exception sous-classe pour chaque utilisation de nested_break ; il n'est pas nécessaire de déclarer ses propres Exception à chaque fois.