Dato il seguente codice (che non funziona):

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

C'è un modo per farlo funzionare? O devo fare un controllo per uscire dal ciclo di input, poi un altro, più limitato, controllare nel ciclo esterno per interrompere tutti insieme se l'utente è soddisfatto?

Il mio primo istinto sarebbe di trasformare il loop nidificato in una funzione e usarlo returnper scoppiare.

Ecco un altro approccio breve. Lo svantaggio è che puoi solo interrompere il circuito esterno, ma a volte è esattamente quello che vuoi.

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

Questo utilizza il costrutto for / else spiegato in: Perché Python usa 'else' dopo e per i cicli while?

Informazioni chiave: sembra solo che il ciclo esterno si interrompa sempre. Ma se il circuito interno non si interrompe, neanche il circuito esterno.

La continuedichiarazione è la magia qui. È nella clausola for-else. Per definizione ciò accade se non c'è interruzione interiore. In quella situazione continueelude ordinatamente la rottura esterna.

PEP 3136 propone break / continue etichettato. Guido lo respinse perché "il codice così complicato da richiedere questa funzione è molto raro". Il PEP menziona alcune soluzioni alternative (come la tecnica dell'eccezione), mentre Guido ritiene che il refactoring per utilizzare il ritorno sarà più semplice nella maggior parte dei casi.

Innanzitutto, la logica ordinaria è utile.

Se, per qualche motivo, le condizioni di terminazione non possono essere risolte, le eccezioni sono un piano di fallback.

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

Per questo esempio specifico, potrebbe non essere necessaria un'eccezione.

D'altra parte, spesso abbiamo le opzioni "Y", "N" e "Q" nelle applicazioni in modalità personaggio. Per l'opzione "Q", vogliamo un'uscita immediata. È più eccezionale.

Tendo a concordare sul fatto che il refactoring in una funzione è di solito l'approccio migliore per questo tipo di situazione, ma per quando è davvero necessario uscire dai loop annidati, ecco una variante interessante dell'approccio di aumento delle eccezioni descritto da @ S.Lott. Usa l' withaffermazione di Python per rendere un po 'più piacevole l'eccezione dell'eccezione. Definisci un nuovo gestore di contesto (devi farlo una sola volta) con:

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

Ora puoi utilizzare questo gestore di contesto come segue:

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"

Vantaggi: (1) è leggermente più pulito (nessun blocco try-tranne esplicito) e (2) si ottiene una Exceptionsottoclasse su misura per ogni uso di nested_break; non è necessario dichiarare la propria Exceptionsottoclasse ogni volta.

Innanzitutto, potresti anche considerare di rendere una funzione il processo di ottenere e validare l'input; all'interno di quella funzione, puoi semplicemente restituire il valore se è corretto e continuare a girare nel ciclo while in caso contrario. Questo essenzialmente elimina il problema che hai risolto e di solito può essere applicato nel caso più generale (interruzione di più loop). Se devi assolutamente mantenere questa struttura nel tuo codice, e davvero non vuoi occuparti dei booleani di contabilità ...

Puoi anche usare goto nel modo seguente (usando un modulo Pesce d'aprile da qui ):

#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

Lo so, lo so, "non usare goto" e tutto il resto, ma funziona bene in strani casi come questo.

Introduci una nuova variabile che utilizzerai come "interruzione di circuito". Prima assegna qualcosa ad esso (False, 0, ecc.), Quindi, all'interno del loop esterno, prima di interrompere da esso, cambia il valore in qualcos'altro (True, 1, ...). Una volta terminato il ciclo, verifica il ciclo "parent" per quel valore. Lasciami dimostrare:

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

Se hai un ciclo infinito, questa è l'unica via d'uscita; per altri loop, l'esecuzione è molto più veloce. Questo funziona anche se hai molti loop nidificati. Puoi uscire da tutto o solo da pochi. Possibilità infinite! Spero che questo abbia aiutato!

Per uscire da più loop nidificati, senza eseguire il refactoring in una funzione, utilizzare una "istruzione goto simulata" con l' eccezione StopIteration integrata :

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

except StopIteration: pass

Vedi questa discussione sull'uso delle dichiarazioni goto per uscire dai loop nidificati.

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

o qualcosa di simile. È possibile impostare una variabile nel loop interno e controllarla nel loop esterno immediatamente dopo l'uscita del loop interno, interrompendo se appropriato. Mi piace un po 'il metodo GOTO, a condizione che non ti dispiaccia usare un modulo joke di April Fool - non è Pythonic, ma ha senso.

Questo non è il modo più carino per farlo, ma secondo me è il modo migliore.

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

Sono abbastanza sicuro che potresti risolvere qualcosa usando anche la ricorsione qui, ma non so se sia una buona opzione per te.

E perché non continuare a ripetere il ciclo se due condizioni sono vere? Penso che questo sia un modo più pitonico:

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

No?

Ti auguro il meglio.

Fattorizza la tua logica di loop in un iteratore che produce le variabili di loop e restituisce una volta terminato: ecco un semplice che delinea le immagini in righe / colonne fino a quando non siamo fuori dalle immagini o fuori dai luoghi per metterle:

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 ...

Questo ha il vantaggio di dividere la complicata logica del loop e l'elaborazione ...

In questo caso, come sottolineato anche da altri, la decomposizione funzionale è la strada da percorrere. Codice 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

C'è un trucco nascosto nella while ... elsestruttura di Python che può essere usato per simulare la doppia interruzione senza molte modifiche / aggiunte al codice. In sostanza se la whilecondizione è falsa, il elseblocco viene attivato. Né eccezioni, continuené breakattivare il elseblocco. Per ulteriori informazioni, consultare le risposte a " Clausola Else su Python while statement " o Python doc su 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

L'unico aspetto negativo è che è necessario spostare la condizione di doppia interruzione nella whilecondizione (o aggiungere una variabile flag). Variazioni di questo esistono anche per il forloop, in cui il elseblocco viene attivato dopo il completamento del loop.

Un altro modo per ridurre la tua iterazione in un ciclo a livello singolo sarebbe tramite l'uso di generatori come specificato anche nel riferimento di Python

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

Potresti ridimensionarlo a qualsiasi numero di livelli per il loop

Il rovescio della medaglia è che non è più possibile interrompere solo un singolo livello. È tutto o niente.

Un altro aspetto negativo è che non funziona con un ciclo while. Inizialmente volevo pubblicare questa risposta su Python: `spezzare` da tutti i loop ma sfortunatamente è chiuso come duplicato

La mia ragione per venire qui è che avevo un loop esterno e un loop interno in questo modo:

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

Come puoi vedere, in realtà non andrà alla prossima x, ma andrà invece alla prossima y.

quello che ho scoperto per risolvere questo problema è stato semplicemente eseguire due volte l'array:

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

So che questo è stato un caso specifico della domanda di OP, ma lo sto pubblicando nella speranza che possa aiutare qualcuno a pensare al proprio problema in modo diverso mantenendo le cose semplici.

Prova a usare un generatore infinito.

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

Utilizzando una funzione:

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()

Prova a eseguire i codici sopra commentando anche returnquelli.

Senza usare alcuna funzione:

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

Ora, esegui i codici sopra come prima e poi prova a eseguire commenti commentando ogni riga che contiene breakuno alla volta dal basso.

È possibile utilizzare un modo semplice per trasformare più loop in un singolo loop interrompibile 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!

Devi indicizzare i tuoi oggetti, invece di essere in grado di iterare esplicitamente i valori, ma almeno in casi semplici sembra essere circa 2-20 volte più semplice della maggior parte delle risposte suggerite.

# 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

probabilmente un piccolo trucco come sotto farà se non preferisce il refactorial in funzione

aggiunto 1 variabile break_level per controllare la condizione del ciclo while

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

È possibile definire una variabile (ad esempio break_statement ), quindi cambiarla in un valore diverso quando si verifica una condizione a due interruzioni e utilizzarla se l'istruzione si interrompe anche dal secondo ciclo.

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

Vorrei ricordare che le funzioni in Python possono essere create proprio nel mezzo del codice e possono accedere in modo trasparente alle variabili circostanti per la lettura e con nonlocaloglobal dichiarazione per la scrittura.

Quindi puoi usare una funzione come "struttura di controllo fragile", definendo un posto in cui vuoi tornare:

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

Soluzioni in 2 modi

Con un esempio: queste due matrici sono uguali / uguali?
matrix1 e matrix2 hanno le stesse dimensioni, n, 2 matrici dimensionali.

Prima soluzione , senza una funzione

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

Seconda soluzione , con una funzione
Questa è la soluzione finale per il mio caso

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

Buona giornata!

# 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

Speriamo che questo aiuti:

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

Ecco un'implementazione che sembra funzionare:

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)

L'unico inconveniente è che devi definire break_prima dei loop.

Non è possibile farlo a livello linguistico. Alcune lingue hanno un goto altri hanno una pausa che accetta un argomento, Python no.

Le migliori opzioni sono:

1. Imposta un flag che viene controllato dal loop esterno o imposta la condizione dei loop esterni.

2. Metti il ​​loop in una funzione e usa return per uscire da tutti i loop contemporaneamente.

3. Riformula la tua logica.

Il merito va a Vivek Nagarajan, programmatore dal 1987

Utilizzando la funzione

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

Usando la bandiera

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

Simile a quello precedente, ma più compatto. (I booleani sono solo numeri)

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   # <--- !

Dal momento che questa domanda è diventata una domanda standard per entrare in un particolare ciclo, vorrei dare la mia risposta usando l'esempio Exception.

Sebbene non esista un'etichetta denominata interruzione del ciclo nel costrutto a più cicli, possiamo fare uso delle eccezioni definite dall'utente per interrompere un particolare ciclo di nostra scelta. Considera l'esempio seguente in cui stampiamo tutti i numeri fino a 4 cifre nel sistema di numerazione base-6:

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

Quando stampiamo l'output, non otterremo mai alcun valore il cui posto dell'unità è con 4. In quel caso, non ci rompiamo da nessun loop poiché BreakLoop(4)viene sollevato e catturato nello stesso loop. Allo stesso modo, ogni volta che dieci posti hanno 3, entriamo nel terzo ciclo usando BreakLoop(3). Ogni volta che centinaia di posti hanno 5, ci dividiamo nel secondo ciclo usando BreakLoop(2)e ogni volta che i mille posti hanno 2, ci dividiamo nel primo ciclo usandoBreakLoop(1) .

In breve, aumenta la tua eccezione (incorporata o definita dall'utente) nei loop interni e prendila nel loop da cui desideri riprendere il controllo. Se si desidera interrompere da tutti i loop, catturare l'eccezione al di fuori di tutti i loop. (Non ho mostrato questo caso nell'esempio).