다음 코드가 주어지면 작동하지 않습니다.

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 구문에 설명되어 있습니다 : 왜 파이썬은 for 및 while 루프 후에 'else'를 사용합니까?

주요 통찰력 : 외부 루프가 항상 끊어지는 것처럼 보입니다 . 그러나 내부 루프가 끊어지지 않으면 외부 루프도 끊어지지 않습니다.

continue문은 여기 마법이다. for-else 절에 있습니다. 내부 휴식이없는 경우 발생하는 정의 에 의해 . 이 상황 continue에서 외피가 깔끔하게 우회됩니다.

PEP 3136 은 분류 된 중단 / 계속을 제안합니다. Guido 는 "이 기능을 요구하기에 너무 복잡한 코드는 매우 드물기 때문에" 거부했습니다 . PEP는 (예외 기술과 같은) 몇 가지 해결 방법을 언급하지만 Guido는 반환을 사용하기 위해 리팩토링하는 것이 대부분의 경우 더 간단하다고 생각합니다.

첫째, 일반적인 논리가 도움이됩니다.

어떤 이유로 종료 조건을 해결할 수없는 경우 예외는 대체 계획입니다.

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문장을 사용하여 예외 발생을 조금 더 멋지게 만듭니다. 다음을 사용하여 새 컨텍스트 관리자를 정의하십시오 (한 번만 수행).

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매번 자신의 서브 클래스 를 선언 할 필요가 없습니다 .

먼저 입력을 가져오고 유효성을 검사하는 프로세스를 만드는 것도 고려할 수 있습니다. 해당 함수 내에서 올바른 경우 값을 반환하고 그렇지 않은 경우 while 루프 에서 계속 회전 할 수 있습니다 . 이것은 본질적으로 해결 한 문제를 방지하며 일반적으로보다 일반적인 경우 (여러 루프에서 발생)에 적용 할 수 있습니다. 코드 에이 구조를 유지해야하고 부기 부울을 다루고 싶지 않은 경우 ...

다음과 같은 방식으로 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

나는 "고토를 사용하지 말아야한다"는 것을 알고 있지만, 이런 경우에는 이상하게 작동합니다.

'루프 브레이커'로 사용할 새 변수를 소개하십시오. 먼저 무언가 (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   # <--- !

무한 루프가 있다면 이것이 유일한 방법입니다. 다른 루프의 경우 실행 속도가 훨씬 빠릅니다. 중첩 루프가 많은 경우에도 작동합니다. 모두 또는 몇 개만 종료 할 수 있습니다. 끝없는 가능성! 이것이 도움이 되었기를 바랍니다!

함수로 리팩토링하지 않고 여러 개의 중첩 된 루프를 해제하려면 내장 된 StopIteration 예외 와 함께 "시뮬레이트 된 goto 문"을 사용하십시오 .

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

또는 그런 것. 내부 루프에서 변수를 설정하고 내부 루프가 종료 된 직후 외부 루프에서 변수를 확인하여 적절한 경우 중단합니다. 파이썬 바보가 아닌 April Fool의 농담 모듈을 사용하는 것이 마음에 들지 않는다면 GOTO 방법과 비슷합니다.

가장 좋은 방법은 아니지만 제 생각에는 가장 좋은 방법입니다.

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

이것은 복잡한 루프 논리와 처리를 분리하는 이점이 있습니다 ...

이 경우 다른 사람들이 지적한 것처럼 기능적 분해가 진행됩니다. 파이썬 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구조에는 많은 코드 변경 / 추가없이 이중 중단을 시뮬레이션하는 데 사용할 수 있는 숨겨진 트릭 이 있습니다. 본질적으로 while조건이 거짓이면 else블록이 트리거됩니다. 예외 continue나 블록을 break트리거 하지 않습니다 else. 자세한 내용은 " Python while statement의 Else 절 "에 대한 답변 또는 while on doc (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.

반복을 단일 레벨 루프로 줄이는 또 다른 방법은 파이썬 참조에 지정된대로 생성기를 사용하는 것입니다.

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

루프 레벨에 관계없이 레벨을 조정할 수 있습니다

단점은 더 이상 단일 레벨 만 깰 수 없다는 것입니다. 전부 아니면 아무것도 아니야

또 다른 단점은 while 루프에서는 작동하지 않는다는 것입니다. 나는 원래이 답변을 파이썬 에 게시하고 싶었습니다 -모든 루프에서`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의 질문의 특정 사례라는 것을 알고 있지만, 문제를 단순하게 유지하면서 누군가가 자신의 문제에 대해 다르게 생각하는 데 도움이되기를 희망하여 게시하고 있습니다.

무한 발전기를 사용해보십시오.

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

아마도 기능과 같은 리팩토링을 선호하지 않는다면 아래와 같은 작은 트릭은

while 루프 조건을 제어하기 위해 1 개의 break_level 변수를 추가했습니다.

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 ) 를 정의한 다음 2 중단 조건이 발생 하면 변수 를 다른 값으로 변경 한 후 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

파이썬의 함수는 코드 중간에 바로 작성 될 수 있으며, 읽기 및 쓰기 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

두 가지 방법으로 솔루션

예를 들면 :이 두 행렬이 같거나 같습니까?
행렬 1과 행렬 2는 같은 크기, 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_은 루프 전에 정의 해야 한다는 것 입니다.

언어 수준에서이 작업을 수행 할 방법이 없습니다. 일부 언어에는 다른 언어가 있으며, 다른 언어에는 논쟁이 있지만 파이썬은 그렇지 않습니다.

가장 좋은 옵션은 다음과 같습니다.

1. 외부 루프에 의해 점검되는 플래그를 설정하거나 외부 루프 조건을 설정하십시오.

2. 루프를 함수에 넣고 return을 사용하여 모든 루프를 한 번에 나눕니다.

3. 논리를 재구성하십시오.

1987 년부터 프로그래머 인 Vivek Nagarajan에게 크레딧 제공

기능 사용

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.

다중 루프 구조에는 루프 브레이킹이라는 레이블이 없지만 사용자 정의 예외 를 사용하여 선택한 특정 루프로 나눌 수 있습니다. 기본 6 번호 시스템에서 최대 4 자리까지 모든 숫자를 인쇄하는 다음 예를 고려하십시오.

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)동일한 루프에서 발생하여 잡은 루프에서 벗어나지 않습니다 . 마찬가지로 10 개의 장소에 3이있을 때마다를 사용하여 세 번째 루프로 나눕니다 BreakLoop(3). 백자리에 5가 BreakLoop(2)있으면를 사용하여 두 번째 루프로 나누고 천 자리에 2가 있으면마다를 사용하여 첫 번째 루프로 나눕니다 BreakLoop(1).

간단히 말해서, 내부 루프에서 예외 (내장 또는 사용자 정의)를 발생시키고 제어를 재개하려는 위치의 루프에서 예외를 포착하십시오. 모든 루프에서 벗어나려면 모든 루프 외부에서 예외를 포착하십시오. (나는이 경우를 보여주지 않았다).