次のコードがあると（動作しません）：

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

これを機能させる方法はありますか？または、入力ループから抜け出すために1つのチェックを行ってから、ユーザーが満足している場合は、さらに制限された外側のループをチェックしてすべてをまとめて抜け出しますか？

私の最初の本能は、ネストされたループを関数にリファクタリングし、それを使用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はforループとwhileループの後に 'else'を使用するのですか？

重要な洞察：外側のループが常に壊れているように見えるだけです。しかし、内側のループが壊れなければ、外側のループも壊れません。

ここでのcontinueステートメントは魔法です。これはfor-else句にあります。定義により何の内側のブレークがない場合はどうなります。そのような状況でcontinueは、外側のブレークをきちんと回避します。

PEP 3136は、ラベル付きの中断/継続を提案しています。「この機能を必要とするほど複雑なコードは非常にまれである」ため、Guido はこれを拒否しました。ただし、PEPはいくつかの回避策（例外テクニックなど）について言及していますが、Guidoは、ほとんどの場合、returnを使用するようにリファクタリングする方が簡単だと感じています。

まず、通常のロジックが役立ちます。

何らかの理由で終了条件を解決できない場合、例外はフォールバック計画です。

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が説明した例外発生アプローチの興味深いバリアントを次に示します。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毎回独自のサブクラスを宣言する必要はありません。

まず、入力を取得して検証するプロセスを関数にすることも検討できます。その関数内では、値が正しい場合は単に値を返し、正しくない場合はwhileループで回転し続けることができます。これにより、本質的に、解決した問題が取り除かれ、通常、より一般的なケース（複数のループから抜け出す）に適用できます。この構造をコードで絶対に維持する必要があり、簿記のブール値を処理したくない場合は...

次の方法でgotoを使用することもできます（ここからエイプリルフールモジュールを使用）。

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

無限ループがある場合、これが唯一の方法です。他のループの実行は本当にずっと速いです。これは、ネストされたループが多数ある場合にも機能します。すべてまたはいくつかを終了できます。無限の可能性！これが役に立てば幸い！

関数にリファクタリングせずに複数のネストされたループから抜け出すには、組み込みの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

またはそのようなもの。内側のループで変数を設定し、内側のループが終了した直後に外側のループで変数をチェックし、必要に応じて中断することができます。エイプリルフールのジョークモジュールを使用することを気にしない限り、私は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

ここでも再帰を使用して何かを解決できると確信していますが、それがあなたにとって良いオプションであるかどうかはわかりません。

そして、2つの条件が真の場合にループを継続しないのはなぜですか？これはよりパイソン的な方法だと思います：

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

Pythonのwhile ... else構造には隠されたトリックがあり、コードの変更や追加をあまり行わなくても、ダブルブレークをシミュレートできます。基本的に、while条件がfalseの場合、elseブロックがトリガーされます。例外もブロックcontinueもbreakトリガーしませんelse。詳細については、「Python whileステートメントのElse句」への回答、または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ループの完了後にブロックがトリガーされます。

反復を単一レベルのループに減らす別の方法は、Pythonリファレンスでも指定されているジェネレーターを使用することです。

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

ループのレベルをいくつでもスケールアップできます

欠点は、1つのレベルだけを壊すことができなくなることです。それは全部か無かです。

もう1つの欠点は、whileループでは機能しないことです。私はもともとこの答えを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に移動します。

これを解決するために私が見つけたのは、代わりに配列を2回実行することでした：

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、下から1つずつ含まれる各行をコメント化して実行してみます。

複数のループを1つの壊れやすいループに変える簡単な方法は、 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ステートメントで使用して2番目のループからブレークすることもできます。

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

2つの方法でのソリューション

例：これらの2つの行列は等しい/同じですか？
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年以来プログラマーである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ます。

multipally looped構文にはbreaking of loopという名前のラベルはありませんが、ユーザー定義の例外を利用して、選択した特定のループに割り込むことができます。基数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がある場合は常に、を使用して3番目のループに分割しBreakLoop(3)ます。100の場所が5を持っているときはいつでも、2番目のループを使用BreakLoop(2)して分割し、1000の場所が2を持っているときはいつでも、使用して最初のループに分割しますBreakLoop(1)。

簡単に言うと、内側のループで（組み込みまたはユーザー定義の）例外を発生させ、制御を再開したい場所からループでそれをキャッチします。すべてのループから抜けたい場合は、すべてのループの外側で例外をキャッチします。（私はこの例を例に示していません）。