Wie kann man aus den Mehrfachschleifen ausbrechen?

Question

Bei folgendem Code (der nicht funktioniert):

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

Gibt es eine Möglichkeit, dies zu erreichen? Oder muss ich eine Prüfung durchführen, um aus der Eingabeschleife auszubrechen, und dann eine weitere, eingeschränktere Prüfung in der äußeren Schleife, um alles zusammen auszubrechen, wenn der Benutzer zufrieden ist?

Answer 1

Versuchen minimal Änderungen an der OP-Frage, fügte ich gerade eine Flagge vor dem Brechen der 1. for-Schleife und überprüfen Sie diese Flagge auf der äußeren Schleife, um zu sehen, wenn wir noch einmal zu bremsen müssen.

break_2 = False
while True:
    # Snip: print out current state
    if break_2: break
    while True:
        ok = get_input("Is this ok? (y/n)")
        if ok.lower() == "y": break_2 = True
        if break_2: break
        if ok.lower() == "n": break
    # Do more processing with menus and stuff

Answer 2

while True:
    # Snip: print out current state
    while True:
        ok = get_input("Is this ok? (y/n)")
        if ok.lower() == "y": 
            break_2 = True
        if ok.lower() == "n": 
            break
    if break_2:
        break

Answer 3

Ähnlich wie der vorherige, aber kompakter. (Boolesche Werte sind nur Zahlen)

breaker = False #our mighty loop exiter!
while True:
    while True:
        ok = get_input("Is this ok? (y/n)")
        breaker+= (ok.lower() == "y")
        break

    if breaker: # the interesting part!
        break   # <--- !

Answer 4

Da diese Frage zu einer Standardfrage für den Einstieg in eine bestimmte Schleife geworden ist, möchte ich meine Antwort anhand eines Beispiels geben Exception .

Obwohl es keine Kennzeichnung für die Unterbrechung einer Schleife in einem Konstrukt mit mehreren Schleifen gibt, können wir die folgende Methode verwenden Benutzerdefinierte Ausnahmen um in eine bestimmte Schleife unserer Wahl einzubrechen. Betrachten wir das folgende Beispiel, in dem wir alle Zahlen bis zu 4 Ziffern im Basis-6-Nummerierungssystem ausgeben wollen:

class BreakLoop(Exception):
    def __init__(self, counter):
        Exception.__init__(self, 'Exception 1')
        self.counter = counter

for counter1 in range(6):   # Make it 1000
    try:
        thousand = counter1 * 1000
        for counter2 in range(6):  # Make it 100
            try:
                hundred = counter2 * 100
                for counter3 in range(6): # Make it 10
                    try:
                        ten = counter3 * 10
                        for counter4 in range(6):
                            try:
                                unit = counter4
                                value = thousand + hundred + ten + unit
                                if unit == 4 :
                                    raise BreakLoop(4) # Don't break from loop
                                if ten == 30: 
                                    raise BreakLoop(3) # Break into loop 3
                                if hundred == 500:
                                    raise BreakLoop(2) # Break into loop 2
                                if thousand == 2000:
                                    raise BreakLoop(1) # Break into loop 1

                                print('{:04d}'.format(value))
                            except BreakLoop as bl:
                                if bl.counter != 4:
                                    raise bl
                    except BreakLoop as bl:
                        if bl.counter != 3:
                            raise bl
            except BreakLoop as bl:
                if bl.counter != 2:
                    raise bl
    except BreakLoop as bl:
        pass

Wenn wir die Ausgabe ausdrucken, werden wir nie einen Wert erhalten, dessen Einheitsstelle bei 4 liegt. In diesem Fall brechen wir nicht aus einer Schleife ab, da BreakLoop(4) wird ausgelöst und in derselben Schleife aufgefangen. Ähnlich verhält es sich mit der dritten Schleife, wenn die zehnte Stelle eine 3 hat. BreakLoop(3) . Immer wenn die hundertste Stelle 5 hat, gehen wir in die zweite Schleife über BreakLoop(2) und wenn die tausendste Stelle 2 hat, brechen wir in die erste Schleife mit BreakLoop(1) .

Kurz gesagt, lösen Sie Ihre Exception (eingebaut oder benutzerdefiniert) in den inneren Schleifen aus und fangen Sie sie in der Schleife ab, in der Sie die Kontrolle wieder aufnehmen wollen. Wenn Sie alle Schleifen unterbrechen wollen, fangen Sie die Exception außerhalb aller Schleifen ab. (Ich habe diesen Fall im Beispiel nicht gezeigt).

Answer 5

Ich löse das Problem, indem ich eine Variable definiere, auf die Bezug genommen wird, um festzustellen, ob man zur nächsten Ebene übergeht oder nicht. In diesem Beispiel wird diese Variable "shouldbreak" genannt.

Variable_That_Counts_To_Three=1
while 1==1:
    shouldbreak='no'
    Variable_That_Counts_To_Five=0
    while 2==2:
        Variable_That_Counts_To_Five+=1
        print(Variable_That_Counts_To_Five)
        if Variable_That_Counts_To_Five == 5:
            if Variable_That_Counts_To_Three == 3:
                shouldbreak='yes'
            break
    print('Three Counter = ' + str(Variable_That_Counts_To_Three))
    Variable_That_Counts_To_Three+=1
    if shouldbreak == 'yes':
        break

print('''
This breaks out of two loops!''')

Auf diese Weise können Sie genau bestimmen, wie das Programm brechen soll. Sie können wählen, wann Sie brechen wollen und wie viele Stufen Sie abwärts gehen wollen.