Dado el siguiente código (que no funciona):

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

¿Hay alguna manera de hacer que esto funcione? ¿O tengo que hacer una verificación para salir del bucle de entrada, luego otra, más limitada, verificar en el bucle exterior para salir todos juntos si el usuario está satisfecho?

Mi primer instinto sería refactorizar el bucle anidado en una función y usar returnpara romper.

Aquí hay otro enfoque que es corto. La desventaja es que solo puedes romper el bucle externo, pero a veces es exactamente lo que quieres.

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

Esto usa la construcción for / else explicada en: ¿Por qué Python usa 'else' después de los bucles for y while?

Visión clave: solo parece que el bucle externo siempre se rompe. Pero si el bucle interno no se rompe, el bucle externo tampoco lo hará.

La continuedeclaración es la magia aquí. Está en la cláusula for-else. Por definición, eso sucede si no hay una ruptura interna. En esa situación, continueelude cuidadosamente la ruptura exterior.

PEP 3136 propone rotura de descanso / continuar. Guido lo rechazó porque "el código tan complicado que requiere esta función es muy raro". Sin embargo, el PEP menciona algunas soluciones alternativas (como la técnica de excepción), mientras que Guido considera que la refactorización para usar el retorno será más simple en la mayoría de los casos.

Primero, la lógica ordinaria es útil.

Si, por alguna razón, las condiciones de terminación no se pueden resolver, las excepciones son un plan alternativo.

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

Para este ejemplo específico, una excepción puede no ser necesaria.

Por otro lado, a menudo tenemos las opciones "Y", "N" y "Q" en las aplicaciones en modo de caracteres. Para la opción "Q", queremos una salida inmediata. Eso es más excepcional.

Tiendo a estar de acuerdo en que la refactorización en una función suele ser el mejor enfoque para este tipo de situación, pero para cuando realmente necesita salir de los bucles anidados, aquí hay una variante interesante del enfoque de aumento de excepciones que describió @ S.Lott. Utiliza la withdeclaración de Python para hacer que el aumento de excepciones se vea un poco mejor. Defina un nuevo administrador de contexto (solo tiene que hacer esto una vez) con:

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

Ahora puede usar este administrador de contexto de la siguiente manera:

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"

Ventajas: (1) es un poco más limpio (sin bloque de prueba explícito), y (2) obtienes una Exceptionsubclase personalizada para cada uso de nested_break; No es necesario declarar su propia Exceptionsubclase cada vez.

Primero, también puede considerar hacer que el proceso de obtener y validar la entrada sea una función; dentro de esa función, puede devolver el valor si es correcto y seguir girando mientras tanto bucle si no. Esto esencialmente evita el problema que resolvió y, por lo general, puede aplicarse en el caso más general (ruptura de múltiples bucles). Si absolutamente debe mantener esta estructura en su código, y realmente no quiere tratar con booleanos de contabilidad ...

También puede usar goto de la siguiente manera (usando un módulo de April Fools desde aquí ):

#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 sé, lo sé, "no usarás goto" y todo eso, pero funciona bien en casos extraños como este.

Introduzca una nueva variable que usará como 'interruptor de bucle'. Primero asigne algo (False, 0, etc.), y luego, dentro del bucle externo, antes de romper, cambie el valor a otra cosa (True, 1, ...). Una vez que el ciclo sale, haga que el ciclo 'padre' verifique ese valor. Déjame demostrarte:

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

Si tiene un bucle infinito, esta es la única salida; para otros bucles, la ejecución es realmente mucho más rápida. Esto también funciona si tiene muchos bucles anidados. Puede salir de todo, o solo de unos pocos. ¡Posibilidades infinitas! Espero que esto haya ayudado!

Para salir de múltiples bucles anidados, sin refactorizar en una función, utilice una "instrucción goto simulada" con la excepción StopIteration incorporada :

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

except StopIteration: pass

Vea esta discusión sobre el uso de declaraciones goto para romper bucles anidados.

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

o algo así. Puede establecer una variable en el bucle interno y verificarla en el bucle externo inmediatamente después de que el bucle interno salga, rompiéndose si corresponde. Me gusta el método GOTO, siempre que no te importe usar un módulo de bromas de April Fool, no es Pythonic, pero tiene sentido.

Esta no es la forma más bonita de hacerlo, pero en mi opinión, es la mejor manera.

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

Estoy bastante seguro de que también podrías resolver algo usando la recursividad, pero no sé si es una buena opción para ti.

¿Y por qué no seguir haciendo bucles si se cumplen dos condiciones? Creo que esta es una forma más pitónica:

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 es así?

Todo lo mejor.

Factorice su lógica de bucle en un iterador que produzca las variables de bucle y regrese cuando haya terminado: aquí hay una simple que presenta imágenes en filas / columnas hasta que nos quedemos sin imágenes o sin lugares para colocarlas:

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

Esto tiene la ventaja de dividir la complicada lógica de bucle y el procesamiento ...

En este caso, como también lo señalaron otros, la descomposición funcional es el camino a seguir. Código en 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

Hay un truco oculto en la while ... elseestructura de Python que se puede usar para simular el doble salto sin muchos cambios / adiciones de código. En esencia, si la whilecondición es falsa, elsese activa el bloque. Ni excepciones, continueni breakactivan el elsebloqueo. Para obtener más información, consulte las respuestas a la " Cláusula Else en Python while ", o 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

El único inconveniente es que necesita mover la condición de doble ruptura a la whilecondición (o agregar una variable de bandera). Existen variaciones de esto también para el forciclo, donde el elsebloque se activa después de la finalización del ciclo.

Otra forma de reducir su iteración a un ciclo de un solo nivel sería mediante el uso de generadores como también se especifica en la referencia de Python

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

Puede ampliarlo a cualquier número de niveles para el bucle

La desventaja es que ya no puedes romper un solo nivel. Es todo o nada.

Otro inconveniente es que no funciona con un ciclo while. Originalmente quería publicar esta respuesta en Python: `romper` de todos los bucles, pero desafortunadamente eso está cerrado como un duplicado de este

Mi razón para venir aquí es que tenía un bucle externo y un bucle interno así:

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

Como puede ver, en realidad no irá a la próxima x, sino a la siguiente y.

Lo que encontré para resolver esto simplemente fue ejecutar la matriz dos veces:

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

Sé que este fue un caso específico de la pregunta de OP, pero lo estoy publicando con la esperanza de que ayude a alguien a pensar en su problema de manera diferente mientras mantiene las cosas simples.

Intenta usar un generador 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

Al usar una función:

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

Intente ejecutar los códigos anteriores comentando el return .

Sin usar ninguna función:

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

Ahora, ejecute los códigos anteriores tal como están primero y luego intente ejecutar comentando cada línea que contiene breakuna a la vez desde la parte inferior.

Una manera fácil de convertir múltiples bucles en un solo bucle rompible es usar 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!

Debe indexar sus objetos, en lugar de poder recorrer los valores explícitamente, pero al menos en casos simples parece ser aproximadamente 2-20 veces más simple que la mayoría de las respuestas sugeridas.

# 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

probablemente un pequeño truco como el que se muestra a continuación servirá si no prefiere volver a la función

Se agregó 1 variable break_level para controlar la condición del bucle 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

Puede definir una variable (por ejemplo, break_statement ), luego cambiarla a un valor diferente cuando se produce la condición de dos rupturas y usarla en la instrucción if para romper también desde el segundo bucle.

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

Me gustaría recordarle que las funciones en Python se pueden crear justo en el medio del código y pueden acceder a las variables circundantes de forma transparente para leer y con nonlocaloglobal declaración por escrito.

Por lo tanto, puede usar una función como una "estructura de control rompible", que define un lugar al que desea regresar:

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

Soluciones de 2 maneras

Con un ejemplo: ¿Son estas dos matrices iguales / iguales?
matriz1 y matriz2 son del mismo tamaño, n, 2 matrices dimensionales.

Primera solución , sin función

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

Segunda solución , con una función
Esta es la solución final para mi 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

¡Que tengas un buen día!

# 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

Esperemos que esto ayude:

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

Aquí hay una implementación que parece funcionar:

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)

El único inconveniente es que debe definir break_antes de los bucles.

No hay forma de hacerlo desde un nivel de idioma. Algunos idiomas tienen un goto, otros tienen un descanso que requiere una discusión, Python no.

Las mejores opciones son:

1. Establezca un indicador que sea verificado por el bucle externo, o establezca la condición de los bucles externos.

2. Ponga el bucle en una función y use el retorno para romper todos los bucles a la vez.

3. Reformula tu lógica.

El crédito es para Vivek Nagarajan, programador desde 1987

Usando la función

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

Usando bandera

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

Similar al anterior, pero más compacto. (Los booleanos son solo números)

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

Dado que esta pregunta se ha convertido en una pregunta estándar para entrar en un ciclo particular, me gustaría dar mi respuesta con un ejemplo usando Exception .

Aunque no existe una etiqueta llamada ruptura del bucle en la construcción de bucle multipally, podemos hacer uso de Excepciones definidas por el usuario para dividirnos en un bucle particular de nuestra elección. Considere el siguiente ejemplo donde imprimamos todos los números de hasta 4 dígitos en el sistema de numeración de 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

Cuando imprimimos la salida, nunca obtendremos ningún valor cuyo lugar de unidad sea 4. En ese caso, no saldremos de ningún bucle cuando BreakLoop(4)se eleva y se atrapa en el mismo bucle. Del mismo modo, cada vez que diez lugares tienen 3, nos dividimos en el tercer bucle usando BreakLoop(3). Cada vez que cien lugares tienen 5, nos BreakLoop(2)separamos en el segundo bucle usando y cuando el mil lugar tiene 2, nos separamos en el primer bucle usando BreakLoop(1).

En resumen, aumente su Excepción (incorporada o definida por el usuario) en los bucles internos, y recójala en el bucle desde donde desea reanudar su control. Si desea romper todos los bucles, tome la excepción fuera de todos los bucles. (No he mostrado este caso en el ejemplo).