Angesichts des folgenden Codes (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, diese Arbeit zu machen? Oder muss ich eine Prüfung durchführen, um aus der Eingangsschleife auszubrechen, und eine andere, eingeschränktere Prüfung in der äußeren Schleife, um alle zusammen auszubrechen, wenn der Benutzer zufrieden ist?

Mein erster Instinkt wäre, die verschachtelte Schleife in eine Funktion umzuwandeln und returnzum Ausbrechen zu verwenden.

Hier ist ein weiterer Ansatz, der kurz ist. Der Nachteil ist, dass Sie nur die äußere Schleife brechen können, aber manchmal ist es genau das, was Sie wollen.

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

Dies verwendet das for / else-Konstrukt, das unter erklärt wird: Warum verwendet Python 'else' nach for- und while-Schleifen?

Schlüsselerkenntnis: Es scheint nur so, als ob die äußere Schleife immer bricht. Aber wenn die innere Schleife nicht bricht, wird auch die äußere Schleife nicht brechen.

Die continueAussage ist die Magie hier. Es steht in der For-else-Klausel. Per Definition passiert das, wenn es keine innere Unterbrechung gibt. In dieser Situation wird continueder äußere Bruch sauber umgangen.

PEP 3136 schlägt die Bezeichnung break / continue vor. Guido lehnte es ab, weil "Code, der so kompliziert ist, dass er diese Funktion benötigt, sehr selten ist". Das PEP erwähnt jedoch einige Problemumgehungen (wie die Ausnahmetechnik), während Guido der Ansicht ist, dass die Umgestaltung zur Verwendung der Rückgabe in den meisten Fällen einfacher sein wird.

Erstens ist gewöhnliche Logik hilfreich.

Wenn die Kündigungsbedingungen aus irgendeinem Grund nicht geklärt werden können, handelt es sich bei Ausnahmen um einen Fallback-Plan.

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

Für dieses spezielle Beispiel ist möglicherweise keine Ausnahme erforderlich.

Andererseits haben wir in Zeichenmodusanwendungen häufig die Optionen "Y", "N" und "Q". Für die Option "Q" möchten wir einen sofortigen Ausstieg. Das ist außergewöhnlicher.

Ich stimme eher zu, dass das Refactoring in eine Funktion normalerweise der beste Ansatz für diese Art von Situation ist. Wenn Sie jedoch wirklich aus verschachtelten Schleifen ausbrechen müssen, finden Sie hier eine interessante Variante des von @ S.Lott beschriebenen Ansatzes zum Auslösen von Ausnahmen. Es verwendet Pythons withAnweisung, um das Auslösen von Ausnahmen ein bisschen schöner zu machen. Definieren Sie einen neuen Kontextmanager (Sie müssen dies nur einmal tun) mit:

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

Jetzt können Sie diesen Kontextmanager wie folgt verwenden:

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"

Vorteile: (1) Es ist etwas sauberer (kein expliziter Try-außer-Block) und (2) Sie erhalten eine benutzerdefinierte ExceptionUnterklasse für jede Verwendung von nested_break; Sie müssen nicht Exceptionjedes Mal Ihre eigene Unterklasse deklarieren .

Zunächst können Sie auch in Betracht ziehen, den Prozess zum Abrufen und Validieren der Eingabe zu einer Funktion zu machen. Innerhalb dieser Funktion können Sie den Wert einfach zurückgeben, wenn er korrekt ist, und wenn nicht , in der while- Schleife weiterdrehen. Dies vermeidet im Wesentlichen das von Ihnen gelöste Problem und kann normalerweise im allgemeineren Fall angewendet werden (Ausbrechen mehrerer Schleifen). Wenn Sie diese Struktur unbedingt in Ihrem Code behalten müssen und sich wirklich nicht mit Buchhaltungs-Booleschen Werten befassen möchten ...

Sie können goto auch folgendermaßen verwenden (mit einem April Fools-Modul von hier ):

#import the stuff
from goto import goto, label

while True:
    #snip: print out current state
    while True:
        ok = get_input("Is this ok? (y/n)")
        if ok == "y" or ok == "Y": goto .breakall
        if ok == "n" or ok == "N": break
    #do more processing with menus and stuff
label .breakall

Ich weiß, ich weiß, "du sollst nicht goto verwenden" und all das, aber es funktioniert gut in seltsamen Fällen wie diesen.

Führen Sie eine neue Variable ein, die Sie als "Loop Breaker" verwenden. Weisen Sie ihm zuerst etwas zu (False, 0 usw.) und ändern Sie dann innerhalb der äußeren Schleife, bevor Sie davon abbrechen, den Wert in etwas anderes (True, 1, ...). Sobald die Schleife beendet ist, überprüfen Sie die 'übergeordnete' Schleife auf diesen Wert. Lassen Sie mich demonstrieren:

breaker = False #our mighty loop exiter!
while True:
    while True:
        if conditionMet:
            #insert code here...
            breaker = True 
            break
    if breaker: # the interesting part!
        break   # <--- !

Wenn Sie eine Endlosschleife haben, ist dies der einzige Ausweg. Bei anderen Schleifen ist die Ausführung sehr viel schneller. Dies funktioniert auch, wenn Sie viele verschachtelte Schleifen haben. Sie können alle oder nur einige beenden. Endlose Möglichkeiten! Hoffe das hat geholfen!

Verwenden Sie eine "simulierte goto-Anweisung" mit der integrierten StopIteration-Ausnahme , um aus mehreren verschachtelten Schleifen auszubrechen, ohne sie in eine Funktion umzuwandeln :

try:
    for outer in range(100):
        for inner in range(100):
            if break_early():
                raise StopIteration

except StopIteration: pass

In dieser Diskussion wird die Verwendung von goto-Anweisungen zum Aufbrechen verschachtelter Schleifen beschrieben.

keeplooping=True
while keeplooping:
    #Do Stuff
    while keeplooping:
          #do some other stuff
          if finisheddoingstuff(): keeplooping=False

oder etwas ähnliches. Sie können eine Variable in der inneren Schleife festlegen und sie unmittelbar nach dem Beenden der inneren Schleife in der äußeren Schleife überprüfen und gegebenenfalls unterbrechen. Ich mag die GOTO-Methode, vorausgesetzt, es macht Ihnen nichts aus, ein Aprilscherz-Modul zu verwenden - es ist nicht pythonisch, aber es macht Sinn.

Dies ist nicht der schönste Weg, aber meiner Meinung nach ist es der beste Weg.

def loop():
    while True:
    #snip: print out current state
        while True:
            ok = get_input("Is this ok? (y/n)")
            if ok == "y" or ok == "Y": return
            if ok == "n" or ok == "N": break
        #do more processing with menus and stuff

Ich bin mir ziemlich sicher, dass Sie auch hier etwas mit Rekursion herausfinden können, aber ich weiß nicht, ob das eine gute Option für Sie ist.

Und warum nicht weiter schleifen, wenn zwei Bedingungen erfüllt sind? Ich denke, das ist ein pythonischerer Weg:

dejaVu = True

while dejaVu:
    while True:
        ok = raw_input("Is this ok? (y/n)")
        if ok == "y" or ok == "Y" or ok == "n" or ok == "N":
            dejaVu = False
            break

Ist es nicht?

Alles Gute.

Berücksichtigen Sie Ihre Schleifenlogik in einem Iterator, der die Schleifenvariablen liefert und nach Abschluss zurückgibt. Hier ist eine einfache Methode, die Bilder in Zeilen / Spalten anordnet, bis keine Bilder mehr vorhanden sind oder keine Stellen mehr vorhanden sind, an denen sie abgelegt werden können:

def it(rows, cols, images):
    i = 0
    for r in xrange(rows):
        for c in xrange(cols):
            if i >= len(images):
                return
            yield r, c, images[i]
            i += 1 

for r, c, image in it(rows=4, cols=4, images=['a.jpg', 'b.jpg', 'c.jpg']):
    ... do something with r, c, image ...

Dies hat den Vorteil, dass die komplizierte Schleifenlogik und die Verarbeitung ...

In diesem Fall ist, wie auch von anderen betont, die funktionale Zerlegung der richtige Weg. Code in Python 3:

def user_confirms():
    while True:
        answer = input("Is this OK? (y/n) ").strip().lower()
        if answer in "yn":
            return answer == "y"

def main():
    while True:
        # do stuff
        if user_confirms():
            break

In der Python- while ... elseStruktur gibt es einen versteckten Trick, mit dem die doppelte Unterbrechung ohne große Codeänderungen / -ergänzungen simuliert werden kann. Wenn die whileBedingung falsch ist, wird der elseBlock im Wesentlichen ausgelöst. Weder Ausnahmen continuenoch breakden elseBlock auslösen . Weitere Informationen finden Sie unter Antworten auf " Else-Klausel in Python while-Anweisung " oder in Python doc on while (v2.7) .

while True:
    #snip: print out current state
    ok = ""
    while ok != "y" and ok != "n":
        ok = get_input("Is this ok? (y/n)")
        if ok == "n" or ok == "N":
            break    # Breaks out of inner loop, skipping else

    else:
        break        # Breaks out of outer loop

    #do more processing with menus and stuff

Der einzige Nachteil ist, dass Sie die Doppelbruchbedingung in die whileBedingung verschieben müssen (oder eine Flagvariable hinzufügen müssen). Variationen davon gibt es auch für die forSchleife, bei der der elseBlock nach Abschluss der Schleife ausgelöst wird.

Eine andere Möglichkeit, Ihre Iteration auf eine einstufige Schleife zu reduzieren, besteht in der Verwendung von Generatoren, wie auch in der Python-Referenz angegeben

for i, j in ((i, j) for i in A for j in B):
    print(i , j)
    if (some_condition):
        break

Sie können es für die Schleife auf eine beliebige Anzahl von Ebenen skalieren

Der Nachteil ist, dass Sie nicht mehr nur ein einziges Level durchbrechen können. Alles oder Nichts.

Ein weiterer Nachteil ist, dass es mit einer while-Schleife nicht funktioniert. Ich wollte diese Antwort ursprünglich auf Python posten - `break` aus allen Schleifen, aber leider ist das als Duplikat dieser geschlossen

Mein Grund, hierher zu kommen, ist, dass ich eine äußere und eine innere Schleife hatte:

for x in array:
  for y in dont_use_these_values:
    if x.value==y:
      array.remove(x)  # fixed, was array.pop(x) in my original answer
      continue

  do some other stuff with x

Wie Sie sehen können, geht es nicht zum nächsten x, sondern zum nächsten y.

Um dies zu lösen, musste ich das Array stattdessen zweimal durchlaufen:

for x in array:
  for y in dont_use_these_values:
    if x.value==y:
      array.remove(x)  # fixed, was array.pop(x) in my original answer
      continue

for x in array:
  do some other stuff with x

Ich weiß, dass dies ein spezieller Fall von OPs Frage war, aber ich poste ihn in der Hoffnung, dass er jemandem hilft, über sein Problem anders nachzudenken und die Dinge einfach zu halten.

Versuchen Sie es mit einem unendlichen Generator.

from itertools import repeat
inputs = (get_input("Is this ok? (y/n)") for _ in repeat(None))
response = (i.lower()=="y" for i in inputs if i.lower() in ("y", "n"))

while True:
    #snip: print out current state
    if next(response):
        break
    #do more processing with menus and stuff

Mit einer Funktion:

def myloop():
    for i in range(1,6,1):  # 1st loop
        print('i:',i)
        for j in range(1,11,2):  # 2nd loop
            print('   i, j:' ,i, j)
            for k in range(1,21,4):  # 3rd loop
                print('      i,j,k:', i,j,k)
                if i%3==0 and j%3==0 and k%3==0:
                    return  # getting out of all loops

myloop()

Versuchen Sie, die obigen Codes auszuführen, indem Sie auch die auskommentieren return.

Ohne Verwendung einer Funktion:

done = False
for i in range(1,6,1):  # 1st loop
    print('i:', i)
    for j in range(1,11,2):  # 2nd loop
        print('   i, j:' ,i, j)
        for k in range(1,21,4):  # 3rd loop
            print('      i,j,k:', i,j,k)
            if i%3==0 and j%3==0 and k%3==0:
                done = True
                break  # breaking from 3rd loop
        if done: break # breaking from 2nd loop
    if done: break     # breaking from 1st loop

Führen Sie nun die obigen Codes wie bisher aus und versuchen Sie dann, jede Zeile, die jeweils eine Zeile enthält, breakvon unten auskommentieren.

Eine einfache Möglichkeit, mehrere Schleifen in eine einzige, zerbrechliche Schleife umzuwandeln, ist die Verwendung numpy.ndindex

for i in range(n):
  for j in range(n):
    val = x[i, j]
    break # still inside the outer loop!

for i, j in np.ndindex(n, n):
  val = x[i, j]
  break # you left the only loop there was!

Sie müssen in Ihre Objekte indizieren, anstatt die Werte explizit durchlaufen zu können, aber zumindest in einfachen Fällen scheint es ungefähr 2-20 Mal einfacher zu sein als die meisten der vorgeschlagenen Antworten.

# this version uses a level counter to choose how far to break out

break_levels = 0
while True:
    # snip: print out current state
    while True:
        ok = get_input("Is this ok? (y/n)")
        if ok == "y" or ok == "Y":
            break_levels = 1        # how far nested, excluding this break
            break
        if ok == "n" or ok == "N":
            break                   # normal break
    if break_levels:
        break_levels -= 1
        break                       # pop another level
if break_levels:
    break_levels -= 1
    break

# ...and so on

Wahrscheinlich reicht ein kleiner Trick wie unten, wenn Sie es nicht vorziehen, in die Funktion umzugestalten

1 break_level-Variable hinzugefügt, um die while-Schleifenbedingung zu steuern

break_level = 0
# while break_level < 3: # if we have another level of nested loop here
while break_level < 2:
    #snip: print out current state
    while break_level < 1:
        ok = get_input("Is this ok? (y/n)")
        if ok == "y" or ok == "Y": break_level = 2 # break 2 level
        if ok == "n" or ok == "N": break_level = 1 # break 1 level

Sie können eine Variable definieren (z. B. break_statement ), sie dann in einen anderen Wert ändern, wenn eine Zwei-Unterbrechungsbedingung auftritt, und sie in der if-Anweisung verwenden, um auch von der zweiten Schleife abzubrechen.

while True:
    break_statement=0
    while True:
        ok = raw_input("Is this ok? (y/n)")
        if ok == "n" or ok == "N": 
            break
        if ok == "y" or ok == "Y": 
            break_statement=1
            break
    if break_statement==1:
        break

Ich möchte Sie daran erinnern, dass Funktionen in Python direkt in der Mitte des Codes erstellt werden können und transparent auf die umgebenden Variablen zum Lesen und mit nonlocaloder globalDeklaration zum Schreiben zugreifen können .

Sie können also eine Funktion als "zerbrechliche Kontrollstruktur" verwenden und einen Ort definieren, an den Sie zurückkehren möchten:

def is_prime(number):

    foo = bar = number

    def return_here():
        nonlocal foo, bar
        init_bar = bar
        while foo > 0:
            bar = init_bar
            while bar >= foo:
                if foo*bar == number:
                    return
                bar -= 1
            foo -= 1

    return_here()

    if foo == 1:
        print(number, 'is prime')
    else:
        print(number, '=', bar, '*', foo)

>>> is_prime(67)
67 is prime
>>> is_prime(117)
117 = 13 * 9
>>> is_prime(16)
16 = 4 * 4

Lösungen auf 2 Arten

Mit einem Beispiel: Sind diese beiden Matrizen gleich / gleich?
Matrix1 und Matrix2 haben die gleiche Größe, n, 2 dimensionale Matrizen.

Erste Lösung , ohne Funktion

same_matrices = True
inner_loop_broken_once = False
n = len(matrix1)

for i in range(n):
    for j in range(n):

        if matrix1[i][j] != matrix2[i][j]:
            same_matrices = False
            inner_loop_broken_once = True
            break

    if inner_loop_broken_once:
        break

Zweite Lösung , mit einer Funktion
Dies ist die letzte Lösung für meinen Fall

def are_two_matrices_the_same (matrix1, matrix2):
    n = len(matrix1)
    for i in range(n):
        for j in range(n):
            if matrix1[i][j] != matrix2[i][j]:
                return False
    return True

Einen schönen Tag noch!

# this version breaks up to a certain label

break_label = None
while True:
    # snip: print out current state
    while True:
        ok = get_input("Is this ok? (y/n)")
        if ok == "y" or ok == "Y":
            break_label = "outer"   # specify label to break to
            break
        if ok == "n" or ok == "N":
            break
    if break_label:
        if break_label != "inner":
            break                   # propagate up
        break_label = None          # we have arrived!
if break_label:
    if break_label != "outer":
        break                       # propagate up
    break_label = None              # we have arrived!

#do more processing with menus and stuff

Hoffentlich hilft das:

x = True
y = True
while x == True:
    while y == True:
         ok = get_input("Is this ok? (y/n)") 
         if ok == "y" or ok == "Y":
             x,y = False,False #breaks from both loops
         if ok == "n" or ok == "N": 
             break #breaks from just one

Hier ist eine Implementierung, die zu funktionieren scheint:

break_ = False
for i in range(10):
    if break_:
        break
    for j in range(10):
        if j == 3:
            break_ = True
            break
        else:
            print(i, j)

Der einzige Nachteil ist, dass Sie break_vor den Schleifen definieren müssen .

Es gibt keine Möglichkeit, dies auf Sprachniveau zu tun. Einige Sprachen haben ein Problem, andere haben eine Pause, die ein Argument erfordert, Python nicht.

Die besten Optionen sind:

1. Setzen Sie ein Flag, das von der äußeren Schleife überprüft wird, oder setzen Sie die Bedingung für die äußeren Schleifen.

2. Fügen Sie die Schleife in eine Funktion ein und brechen Sie mit return alle Schleifen gleichzeitig aus.

3. Formulieren Sie Ihre Logik neu.

Der Kredit geht an Vivek Nagarajan, Programmierer seit 1987

Funktion verwenden

def doMywork(data):
    for i in data:
       for e in i:
         return 

Flag verwenden

is_break = False
for i in data:
   if is_break:
      break # outer loop break
   for e in i:
      is_break = True
      break # inner loop break

Ähnlich wie zuvor, 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   # <--- !

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

Obwohl es in Konstrukten mit mehreren Schleifen keine Bezeichnung mit dem Namen "Breaking of Loop" gibt, können wir benutzerdefinierte Ausnahmen verwenden , um in eine bestimmte Schleife unserer Wahl einzubrechen . Betrachten Sie das folgende Beispiel, in dem wir alle Zahlen mit bis zu 4 Ziffern im Basis-6-Nummerierungssystem drucken:

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 drucken, erhalten wir niemals einen Wert, dessen Einheitsplatz bei 4 liegt. In diesem Fall brechen wir keine Schleife ab, BreakLoop(4)die ausgelöst und in derselben Schleife abgefangen wird. In ähnlicher Weise brechen wir immer dann, wenn zehn Plätze 3 haben, mit in die dritte Schleife einBreakLoop(3) . Immer wenn hundert BreakLoop(2)Stellen 5 haben, brechen wir mit in die zweite Schleife ein, und wenn die tausend Stellen 2 haben, brechen wir mit in die erste Schleife einBreakLoop(1) .

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