Враховуючи такий код (який не працює):

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

Чи є спосіб зробити цю роботу? Або я повинен зробити одну перевірку, щоб вийти з вхідного циклу, потім іншу, більш обмежену, перевірити у зовнішній цикл, щоб вирватися з усіх разом, якщо користувач задоволений?

Першим моїм інстинктом було б переробити вкладений цикл у функцію і використовувати його returnдля виривання.

Ось ще один підхід, який короткий. Недоліком є ​​те, що ви можете розірвати лише зовнішню петлю, але іноді це саме те, що ви хочете.

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

Для цього використовується конструкція for / else, пояснена в: Чому python використовує 'else' після і для циклів while і while?

Основне розуміння: лише здається , що зовнішня петля завжди ламається. Але якщо внутрішня петля не зламається, зовнішня петля також не буде.

continueЗаява магія тут. Це в пункті for-else. За визначенням, що відбувається, якщо немає внутрішнього розриву. У цій ситуації continueакуратно обходить зовнішній розрив.

PEP 3136 пропонує маркувати перерву / продовжувати. Гвідо відхилив це, оскільки "такий складний код вимагати цієї функції дуже рідко". Хоча PEP згадує деякі шляхи вирішення (наприклад, техніка виключень), тоді як Гвідо вважає, що рефакторинг на використання повернення буде більш простим у більшості випадків.

По-перше, корисна звичайна логіка.

Якщо з якихось причин терміни закінчення неможливо опрацювати, винятки становлять резервний план.

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

У цьому конкретному прикладі виняток може не знадобитися.

З іншого боку, ми часто маємо параметри "Y", "N" і "Q" в додатках в режимі символів. Для параметра "Q" ми хочемо негайного виходу. Це винятково.

Я схильний погоджуватися, що рефакторинг на функцію зазвичай є найкращим підходом для подібної ситуації, але для тих випадків, коли вам справді потрібно вирватися з вкладених циклів, ось цікавий варіант підходу до винятку, який описав @ S.Lott. Він використовує withзаяву Python, щоб зробити виняток винятком виглядати трохи приємніше. Визначте новий контекстний менеджер (це потрібно зробити лише один раз) за допомогою:

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

Тепер ви можете використовувати цей менеджер контексту наступним чином:

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"

Переваги: ​​(1) вона трохи чистіша (немає явного спроби, крім блоку), і (2) ви отримуєте Exceptionпідклас, побудований на замовлення для кожного використання nested_break; не потрібно декларувати свій Exceptionпідклас кожен раз.

По-перше, ви також можете розглянути можливість отримання процесу отримання та перевірки введення функції; в рамках цієї функції, ви можете просто повернути значення , якщо його правильно, і тримати спінінг в той час петлі , якщо немає. Це по суті усуває проблему, яку ви вирішили, і зазвичай її можна застосувати в більш загальному випадку (прорив декількох циклів). Якщо ви абсолютно зобов'язані зберігати цю структуру у своєму коді, і справді не хочете мати справу з булевими бухгалтерами ...

Ви також можете використовувати goto наступним чином (використовуючи модуль April Fools звідси ):

#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

Я знаю, я знаю, "ти не будеш використовувати goto" і все це, але це добре спрацьовує в таких дивних випадках.

Введіть нову змінну, яку ви будете використовувати як "вимикач циклу". Спочатку призначте йому щось (False, 0 і т. Д.), А потім всередині зовнішньої петлі, перш ніж вийти з неї, змініть значення на щось інше (True, 1, ...). Як тільки цикл виходить, зробіть цикл "батьків", щоб перевірити це значення. Дозвольте продемонструвати:

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

Якщо у вас є нескінченна петля, це єдиний вихід; для інших циклів виконання дійсно набагато швидше. Це також працює, якщо у вас багато вкладених циклів. Ви можете вийти з усіх, або лише з кількох. Нескінченні можливості! Сподіваюся, це допомогло!

Щоб вирватися з декількох вкладених циклів, не перетворюючи на функції, скористайтеся "імітаційним оператором goto" зі вбудованим винятком StopIteration :

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

except StopIteration: pass

Дивіться цю дискусію щодо використання операторів goto для виривання вкладених циклів.

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

чи щось подібне. Ви можете встановити змінну у внутрішньому циклі та перевірити її у зовнішньому циклі одразу після виходу із внутрішнього циклу, порушуючи, якщо це доречно. Мені якось подобається метод GOTO, за умови, що ви не заперечуєте проти використання анекдотного модуля в квітні - це не Pythonic, але це має сенс.

Це не найкрасивіший спосіб зробити це, але, на мою думку, це найкращий спосіб.

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

Я впевнений, що ви могли б щось розробити, використовуючи і рекурсію, але я не знаю, якщо це хороший варіант для вас.

І чому б не продовжувати циклічно, якщо дві умови справджуються? Я думаю, що це більш пітонічний спосіб:

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

Чи не так?

Все найкраще.

Спрямуйте свою логіку циклу на ітератор, який видає змінні цикли та повертається після завершення - ось простий, який розкладає зображення у рядках / стовпцях, поки ми не залишимо зображення чи не буде розміщено їх:

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

Це має перевагу в розбитті складної логіки циклу та обробці ...

У цьому випадку, як вказують і інші, функціональне розкладання - це шлях. Код в 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

У while ... elseструктурі Python є прихований трюк, який можна використовувати для імітації подвійного розриву без особливих змін / доповнень коду. По суті, якщо whileумова помилкова, elseблок спрацьовує. Ні виняток, continueабо breakне викликавши elseблок. Для отримання додаткової інформації див відповіді на " Else пункт у Python while statement ", або 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

Єдиним недоліком є ​​те, що вам потрібно перенести умову подвійного розриву у whileстан (або додати змінну прапора). Варіації цього існують і для forциклу, де elseблок спрацьовує після завершення циклу.

Іншим способом зведення вашої ітерації до однорівневого циклу буде використання генераторів, як це також зазначено в довідці python

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

Ви можете масштабувати його до будь-якої кількості рівнів для циклу

Мінус у тому, що ви більше не можете розбивати лише один рівень. Це все або нічого.

Ще один недолік полягає в тому, що він не працює з циклом час. Спочатку я хотів опублікувати цю відповідь на Python - `вирвати 'з усіх циклів, але, на жаль, це закрито як дублікат цього

Моя причина приходу сюди полягає в тому, що у мене була зовнішня петля і внутрішня петля так:

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

Як бачите, він насправді не перейде до наступного x, але замість цього перейде до наступного y.

що я вирішив це вирішити, просто пропустити масив двічі замість цього:

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

Я знаю, що це був конкретний випадок питання ОП, але я публікую його з надією, що це допоможе комусь по-іншому подумати про свою проблему, зберігаючи прості речі.

Спробуйте використовувати нескінченний генератор.

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

За допомогою функції:

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

Спробуйте запустити вищезгадані коди, коментуючи returnтакож.

Без використання жодної функції:

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

Тепер запустіть наведені вище коди, як спочатку, а потім спробуйте запустити, коментуючи кожний рядок, що містить по breakодному знизу.

Простий спосіб перетворити декілька петель в єдиний, нерозривний цикл - це використовувати 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!

Вам потрібно індексувати свої об'єкти, на відміну від можливості явної повторення значень, але, принаймні, у простих випадках це здається приблизно в 2–20 разів простішим, ніж більшість запропонованих відповідей.

# 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

мабуть, маленький трюк, як показано нижче, зробить, якщо не віддасть перевагу рефакторному функціонуванню

додано 1 змінну break_level, щоб контролювати стан циклу 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

Ви можете визначити змінну (наприклад, break_statement ), а потім змінити її на інше значення, коли виникає умова з двома перервами, і використати її, якщо оператор також перерветься з другого циклу.

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

Хочу нагадати, що функції в Python можна створювати прямо в середині коду і можуть отримувати доступ до навколишніх змінних прозоро для читання і за допомогою nonlocalабоglobal написання декларації для запису.

Таким чином, ви можете використовувати функцію як "зламану структуру управління", визначаючи місце, до якого потрібно повернутися:

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

Рішення двома способами

Прикладом: Чи рівні ці дві матриці / однакові?
matrix1 і matrix2 однакового розміру, n, 2 мірних матриць.

Перше рішення , без функції

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

Друге рішення , з функцією
Це остаточне рішення для мого випадку

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

Гарного дня!

# 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

Сподіваємось, це допомагає:

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

Ось реалізація, яка, здається, працює:

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)

Єдиний зворотний зворот - це те, що ви повинні визначитись break_до циклів.

Неможливо зробити це з мовного рівня. Деякі мови мають goto, інші мають перерву, яка бере аргументи, python - ні.

Найкращі варіанти:

1. Встановіть прапор, який перевіряється зовнішньою петлею, або встановіть стан зовнішніх циклів.

2. Введіть цикл у функцію і використовуйте return, щоб вирвати з усіх циклів відразу.

3. Переформулюйте свою логіку.

Кредит належить Вівеку Нагараджану, програмісту з 1987 року

Використання функції

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

Використовуючи прапор

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

Подібний, як і раніше, але більш компактний. (Булеви - це просто числа)

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

Оскільки це питання стало стандартним питанням для прориву певного циклу, я хотів би дати свою відповідь із прикладом, використовуючи Exception .

Хоча в конструкції, що перебуває в певному циклі, не існує ярлика з назвою "Розрив циклу", ми можемо використовувати винятки, визначені користувачем, для прориву в певний цикл на наш вибір. Розглянемо наступний приклад, де додрукуємо всі числа до 4 цифр у системі нумерації базових 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

Коли ми друкуємо вихід, ми ніколи не отримаємо жодного значення, одиничне місце якого становить 4. У цьому випадку ми не відриваємося від будь-якого циклу, BreakLoop(4)який піднімається і потрапляє в один цикл. Аналогічно, кожен раз, коли десяте місце займає 3, ми розбиваємось на третю петлю, використовуючи BreakLoop(3). Кожного разу, коли сто місця має 5, ми перериваємося на другу петлю, використовуючи BreakLoop(2)кожну тисячу місця, і ми використовуємо перший цикл BreakLoop(1).

Коротше кажучи, підніміть виняток (вбудований або визначений користувачем) у внутрішніх циклах та вловіть його у циклі, звідки ви хочете відновити свій контроль. Якщо ви хочете перерватися з усіх циклів, виловіть виняток поза всіма петлями. (Я не показав цього випадку в прикладі).