Во-первых, полезна обычная логика.

Если по какой-либо причине условия прекращения не могут быть разработаны, исключения представляют собой запасной план.

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» нам нужен немедленный выход. Это более необычно.

Во-первых, вы можете также подумать о том, чтобы сделать процесс получения и проверки ввода функцией; внутри этой функции вы можете просто вернуть значение, если оно верное, и продолжать вращаться в цикле пока, если нет. Это по существу устраняет проблему, которую вы решили, и обычно может применяться в более общем случае (выход из нескольких циклов). Если вы абсолютно должны сохранить эту структуру в своем коде и действительно не хотите иметь дело с булевыми значениями бухгалтерского учета ...

Вы также можете использовать перейти к следующим образом (используя первоапрельский модуль из здесь):

#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" и все такое, но это хорошо работает в таких странных случаях, как этот.

Моим первым побуждением было бы преобразовать вложенный цикл в функцию и использовать return для выхода.

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

Я почти уверен, что здесь можно что-нибудь придумать, используя рекурсию, но не знаю, подходит ли это вам.

PEP 3136 предлагает пометку break / continue. Guido отклонил это, потому что «код, настолько сложный, чтобы требовать эту функцию, встречается очень редко». Однако в PEP упоминаются некоторые обходные пути (например, техника исключения), в то время как Гвидо считает, что рефакторинг для использования return будет проще в большинстве случаев.

Преобразуйте логику цикла в итератор, который выдает переменные цикла и возвращает по завершении - вот простой пример, который размещает изображения в строках / столбцах до тех пор, пока у нас не закончатся изображения или места для их размещения:

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

Это дает преимущество разделения сложной логики цикла и обработки ...

Вот еще один короткий подход. Недостатком является то, что вы можете разорвать только внешний цикл, но иногда это именно то, что вам нужно.

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 после циклов for и while?

Ключевой вывод: это только кажется, как будто внешний цикл всегда прерывается. Но если внутренний цикл не разорвется, то и внешний цикл не сломается.

Заявление continue - это волшебство. Это в предложении for-else. По определению, которое происходит, если нет внутреннего разрыва. В этой ситуации continue аккуратно обходит внешний разрыв.

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

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) он немного чище (без явного блока try-except) и (2) вы получаете специально созданный подкласс Exception для каждого использования nested_break; нет необходимости каждый раз объявлять собственный подкласс Exception.

Представьте новую переменную, которую вы будете использовать как «прерыватель цикла». Сначала присвойте ему что-нибудь (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   # <--- !

Если у вас бесконечный цикл, это единственный выход; для других циклов выполнение действительно намного быстрее. Это также работает, если у вас много вложенных циклов. Вы можете выйти из всех или только из нескольких. Безграничные возможности! Надеюсь, это помогло!

Похож на предыдущий, но более компактный. (Логические значения - это просто числа)

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

Я приехал сюда, потому что у меня был внешний цикл и внутренний цикл:

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

Я знаю, что это был конкретный случай вопроса OP, но я публикую его в надежде, что это поможет кому-то по-другому взглянуть на свою проблему, сохраняя при этом простоту.

И почему бы не продолжить цикл, если выполняются два условия? Я думаю, что это более питонический способ:

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

Не так ли?

Всего наилучшего.

Попробуйте использовать бесконечный генератор.

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

# 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

# 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

В этом случае, как указывали и другие, следует использовать функциональную декомпозицию. Код в 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

В структуре Python while ... else есть скрытый трюк, который можно использовать для имитации двойного разрыва без особых изменений / дополнений кода. По сути, если условие while ложно, срабатывает блок else. Ни исключения, continue или break не запускают блок else. Для получения дополнительной информации см. Ответы на «Предложение Else в инструкции Python while» или Документ Python о 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 запускается после завершения цикла.

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

добавлена ​​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

Другой способ сократить вашу итерацию до одноуровневого цикла - использовать генераторы, которые также указаны в ссылка на Python

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

Вы можете масштабировать его до любого количества уровней для цикла

Обратной стороной является то, что вы больше не можете сломать только один уровень. Все или ничего.

Еще одним недостатком является то, что он не работает с циклом while. Изначально я хотел опубликовать этот ответ на Python - выход из всех циклов, но, к сожалению, он закрыт как дубликат этого

Вы можете определить переменную (например, break_statement), затем изменить ее на другое значение при возникновении условия двух прерываний и использовать ее в операторе if, чтобы также выйти из второго цикла.

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

Надеюсь, это поможет:

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

Поскольку этот вопрос стал стандартным для взлома определенного цикла, я хотел бы дать свой ответ на примере использования Exception.

Хотя в конструкции с несколькими циклами не существует метки с именем break of loop, мы можем использовать Пользовательские исключения, чтобы разбить конкретный цикл по нашему выбору. Рассмотрим следующий пример, в котором мы напечатаем все числа до 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). Каждый раз, когда у 100 разряда 5, мы переходим ко второму циклу, используя BreakLoop(2), а когда у разряда тысячи 2, мы переходим к первому циклу, используя BreakLoop(1).

Короче говоря, поднимите свое исключение (встроенное или определяемое пользователем) во внутренних циклах и перехватите его в цикле, откуда вы хотите возобновить управление. Если вы хотите прервать выполнение всех циклов, перехватите исключение вне всех циклов. (Я не показывал этот случай на примере).

Чтобы выйти из нескольких вложенных циклов без преобразования в функцию, используйте «симулированный оператор goto» со встроенным StopIteration исключение:

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

except StopIteration: pass

См. это обсуждение об использовании операторов goto для выхода из вложенных циклов.

Я решаю эту проблему, определяя переменную, на которую ссылаются, чтобы определить, перейдете ли вы на следующий уровень или нет. В этом примере эта переменная называется shouldbreak.

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!''')

Это дает большой контроль над тем, как именно вы хотите, чтобы программа прервалась, позволяя вам выбирать, когда вы хотите прервать и на сколько уровней опуститься.

Используя функцию:

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 раз проще, чем большинство предложенных ответов.

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

На примере: эти две матрицы равны / одинаковы?
matrix1 и matrix2 имеют одинаковый размер, 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

Второе решение, с функцией
Это окончательное решение для моего случая

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

Хорошего дня!

Вот реализация, которая, кажется, работает:

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_ до циклов.

There is no way to do this from a language level. Some languages have a goto others have a break that takes an argument, python does not.

The best options are:

1. Set a flag which is checked by the outer loop, or set the outer loops condition.

2. Put the loop in a function and use return to break out of all the loops at once.

3. Reformulate your logic.

Благодарим Вивека Нагараджана, программиста с 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

Лично я бы использовал логическое значение, которое переключается, когда я готов разорвать внешний цикл. Например

while True:
    #snip: print out current state
    quit = False
    while True:
        ok = input("Is this ok? (y/n)")
        if ok.lower() == "y":
            quit = True
            break # this should work now :-)
        if ok.lower() == "n":
            quit = True
            break # This should work too :-)
    if quit:
        break
    #do more processing with menus and stuff