Diberikan kode berikut (itu tidak berfungsi):

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

Apakah ada cara untuk membuat ini berfungsi? Atau apakah saya harus melakukan satu pemeriksaan untuk keluar dari loop input, lalu yang lain, lebih terbatas, periksa di loop luar untuk memecahkan semua bersama-sama jika pengguna puas?

Insting pertama saya adalah untuk memperbaiki loop bersarang menjadi fungsi dan digunakan returnuntuk keluar.

Ini pendekatan lain yang pendek. Kerugiannya adalah Anda hanya dapat mematahkan loop luar, tetapi kadang-kadang itulah yang Anda inginkan.

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

Ini menggunakan for / else construct yang dijelaskan di: Mengapa python menggunakan 'else' after for dan while loop?

Wawasan utama: Sepertinya lingkaran luar selalu putus. Tetapi jika loop dalam tidak putus, loop luar tidak akan baik.

The continuepernyataan adalah keajaiban di sini. Ada dalam klausa untuk yang lain. Menurut definisi itu terjadi jika tidak ada istirahat batin. Dalam situasi itu continuedengan rapi mengeliminasi istirahat luar.

PEP 3136 mengusulkan pelabelan / lanjutkan. Guido menolaknya karena "kode sangat rumit untuk memerlukan fitur ini sangat jarang". PEP memang menyebutkan beberapa solusi, (seperti teknik pengecualian), sementara Guido merasa refactoring untuk menggunakan pengembalian akan lebih sederhana dalam banyak kasus.

Pertama, logika biasa sangat membantu.

Jika, karena alasan tertentu, kondisi terminasi tidak dapat dikerjakan, pengecualian adalah rencana mundur.

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

Untuk contoh khusus ini, pengecualian mungkin tidak diperlukan.

Di sisi lain, kita sering memiliki opsi "Y", "N" dan "Q" dalam aplikasi mode-karakter. Untuk opsi "Q", kami ingin segera keluar. Itu lebih luar biasa.

Saya cenderung setuju bahwa refactoring ke fungsi biasanya merupakan pendekatan terbaik untuk situasi semacam ini, tetapi untuk ketika Anda benar - benar perlu keluar dari loop bersarang, inilah varian menarik dari pendekatan peningkatan pengecualian yang dijelaskan oleh @ S.Lott. Ini menggunakan withpernyataan Python untuk membuat kenaikan pengecualian terlihat sedikit lebih baik. Tetapkan manajer konteks baru (Anda hanya perlu melakukan ini satu kali) dengan:

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

Sekarang Anda dapat menggunakan manajer konteks ini sebagai berikut:

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"

Keuntungan: (1) ini sedikit lebih bersih (tidak ada blok coba-kecuali eksplisit), dan (2) Anda mendapatkan Exceptionsubkelas yang dibuat khusus untuk setiap penggunaan nested_break; tidak perlu mendeklarasikan Exceptionsubclass Anda sendiri setiap kali.

Pertama, Anda juga dapat mempertimbangkan untuk membuat proses mendapatkan dan memvalidasi fungsi input; dalam fungsi itu, Anda bisa mengembalikan nilai jika itu benar, dan terus berputar di loop sementara jika tidak. Ini pada dasarnya meniadakan masalah yang Anda selesaikan, dan biasanya dapat diterapkan dalam kasus yang lebih umum (keluar dari banyak loop). Jika Anda benar-benar harus menjaga struktur ini dalam kode Anda, dan benar-benar tidak ingin berurusan dengan para boolean pembukuan ...

Anda juga dapat menggunakan goto dengan cara berikut (menggunakan modul April Mop dari sini ):

#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

Saya tahu, saya tahu, "kamu tidak boleh menggunakan goto" dan semua itu, tetapi itu bekerja dengan baik dalam kasus-kasus aneh seperti ini.

Perkenalkan variabel baru yang akan Anda gunakan sebagai 'loop breaker'. Pertama tetapkan sesuatu untuk itu (Salah, 0, dll.), Dan kemudian, di dalam lingkaran luar, sebelum Anda memutuskannya, ubah nilainya menjadi sesuatu yang lain (Benar, 1, ...). Setelah loop keluar, lakukan loop 'induk' untuk memeriksa nilai itu. Biarkan saya menunjukkan:

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

Jika Anda memiliki loop tak terbatas, ini adalah satu-satunya jalan keluar; untuk eksekusi loop lainnya jauh lebih cepat. Ini juga berfungsi jika Anda memiliki banyak loop bersarang. Anda dapat keluar semua, atau hanya beberapa. Kemungkinan tak terbatas! Semoga ini bisa membantu!

Untuk keluar dari beberapa loop bersarang, tanpa refactoring ke fungsi, gunakan "pernyataan goto yang disimulasikan" dengan pengecualian StopIteration bawaan :

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

except StopIteration: pass

Lihat diskusi ini tentang penggunaan pernyataan goto untuk keluar dari loop bersarang.

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

atau semacam itu. Anda bisa mengatur variabel di loop dalam, dan memeriksanya di loop luar segera setelah loop dalam keluar, rusak jika perlu. Saya agak suka metode GOTO, asalkan Anda tidak keberatan menggunakan modul lelucon April Mop - ini bukan Pythonic, tapi itu masuk akal.

Ini bukan cara tercantik untuk melakukannya, tetapi menurut saya, ini cara terbaik.

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

Saya cukup yakin Anda bisa melakukan sesuatu menggunakan rekursi di sini juga, tapi saya tidak tahu apakah itu pilihan yang baik untuk Anda.

Dan mengapa tidak terus mengulang-ulang jika dua kondisi itu benar? Saya pikir ini adalah cara yang lebih pythonic:

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

Bukan?

Semua yang terbaik.

Factor logika loop Anda menjadi sebuah iterator yang menghasilkan variabel loop dan kembali ketika selesai - berikut ini adalah yang sederhana yang menjabarkan gambar dalam baris / kolom sampai kita kehabisan gambar atau keluar dari tempat untuk meletakkannya:

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

Ini memiliki keuntungan memisahkan logika loop rumit dan pemrosesan ...

Dalam hal ini, sebagaimana ditunjukkan oleh orang lain juga, dekomposisi fungsional adalah cara yang harus dilakukan. Kode dalam 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

Ada trik tersembunyi dalam while ... elsestruktur Python yang dapat digunakan untuk mensimulasikan double break tanpa banyak perubahan / penambahan kode. Intinya jika whilekondisinya salah, elseblok dipicu. Tidak ada pengecualian, continueatau breakmemicu elseblokir. Untuk informasi lebih lanjut, lihat jawaban " Klausa lain pada pernyataan Python sementara ", atau dokumen Python sementara (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

Satu-satunya downside adalah bahwa Anda perlu memindahkan kondisi melanggar ganda ke dalam whilekondisi (atau menambahkan variabel bendera). Variasi ini ada juga untuk forloop, di mana elseblok dipicu setelah loop selesai.

Cara lain untuk mengurangi iterasi Anda menjadi satu tingkat loop akan melalui penggunaan generator seperti yang ditentukan dalam referensi python

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

Anda bisa meningkatkannya ke sejumlah level untuk loop

Kelemahannya adalah Anda tidak lagi dapat menembus hanya satu level. Semuanya atau tidak sama sekali.

Kelemahan lain adalah tidak bekerja dengan loop sementara. Saya awalnya ingin memposting jawaban ini dengan Python - `break` dari semua loop tetapi sayangnya itu ditutup sebagai duplikat dari yang ini

Alasan saya datang ke sini adalah saya memiliki loop luar dan loop dalam seperti:

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

Seperti yang Anda lihat, itu tidak akan benar-benar pergi ke x berikutnya, tetapi akan pergi ke y berikutnya.

apa yang saya temukan untuk menyelesaikan ini adalah menjalankan array dua kali sebagai gantinya:

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

Saya tahu ini adalah kasus spesifik dari pertanyaan OP, tetapi saya mempostingnya dengan harapan bahwa itu akan membantu seseorang memikirkan masalah mereka secara berbeda sambil menjaga hal-hal sederhana.

Coba gunakan generator tanpa batas.

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

Dengan menggunakan fungsi:

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

Coba jalankan kode di atas dengan berkomentar returnjuga.

Tanpa menggunakan fungsi apa pun:

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

Sekarang, jalankan kode di atas seperti yang pertama dan kemudian coba jalankan dengan mengomentari setiap baris yang berisi breaksatu per satu dari bawah.

Cara mudah untuk mengubah banyak loop menjadi satu loop yang dapat diputuskan adalah dengan menggunakannya 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!

Anda memang harus mengindeks ke objek Anda, sebagai lawan untuk dapat beralih melalui nilai-nilai secara eksplisit, tetapi setidaknya dalam kasus-kasus sederhana tampaknya sekitar 2-20 kali lebih sederhana daripada sebagian besar jawaban yang disarankan.

# 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

mungkin sedikit trik seperti di bawah ini akan dilakukan jika tidak lebih suka refactorial menjadi fungsi

menambahkan 1 variabel break_level untuk mengontrol kondisi loop sementara

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

Anda dapat mendefinisikan variabel (misalnya break_statement ), kemudian mengubahnya ke nilai yang berbeda ketika kondisi dua-break terjadi dan menggunakannya dalam pernyataan if untuk break dari loop kedua juga.

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

Saya ingin mengingatkan Anda bahwa fungsi dalam Python dapat dibuat tepat di tengah kode dan dapat mengakses variabel sekitarnya secara transparan untuk membaca dan dengan nonlocalatau globaldeklarasi untuk menulis.

Jadi, Anda dapat menggunakan fungsi sebagai "struktur kontrol yang dapat dipecah", menentukan tempat Anda ingin kembali ke:

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

Solusi dalam 2 Cara

Dengan sebuah contoh: Apakah kedua matriks ini sama / sama?
matrix1 dan matrix2 memiliki ukuran yang sama, n, 2 matriks dimensi.

Solusi Pertama , tanpa fungsi

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

Solusi Kedua , dengan fungsi
Ini adalah solusi terakhir untuk kasus saya

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

Semoga harimu menyenangkan!

# 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

Semoga ini membantu:

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

Berikut ini adalah implementasi yang tampaknya berhasil:

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)

Satu-satunya penarikan adalah bahwa Anda harus mendefinisikan break_sebelum loop.

Tidak ada cara untuk melakukan ini dari tingkat bahasa. Beberapa bahasa memiliki goto yang lain memiliki jeda yang membutuhkan argumen, python tidak.

Pilihan terbaik adalah:

1. Atur bendera yang diperiksa oleh loop luar, atau atur kondisi loop luar.

2. Letakkan loop dalam suatu fungsi dan gunakan kembali untuk keluar dari semua loop sekaligus.

3. Merumuskan kembali logika Anda.

Kredit diberikan kepada Vivek Nagarajan, Programmer sejak 1987

Menggunakan Fungsi

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

Menggunakan bendera

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

Mirip seperti sebelumnya, tetapi lebih ringkas. (Booleans hanya angka)

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

Karena pertanyaan ini telah menjadi pertanyaan standar untuk membobol lingkaran tertentu, saya ingin memberikan jawaban saya dengan menggunakan contoh Exception .

Meskipun tidak ada label yang bernama breaking of loop dalam konstruk yang dilipatgandakan secara berulang, kita dapat menggunakan Pengecualian Buatan Pengguna untuk memecah menjadi loop tertentu dari pilihan kita. Pertimbangkan contoh berikut di mana mari kita mencetak semua angka hingga 4 digit dalam sistem penomoran basis-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

Ketika kita mencetak output, kita tidak akan pernah mendapatkan nilai yang unit place-nya dengan 4. Dalam hal itu, kita tidak putus dari loop apa pun seperti BreakLoop(4)dinaikkan dan ditangkap dalam loop yang sama. Demikian pula, setiap kali sepuluh tempat memiliki 3, kita masuk ke loop ketiga menggunakan BreakLoop(3). Setiap kali seratus tempat memiliki 5, kita masuk ke loop kedua menggunakan BreakLoop(2)dan ketika ribuan tempat memiliki 2, kita masuk ke loop pertama menggunakanBreakLoop(1) .

Singkatnya, naikkan Pengecualian Anda (bawaan atau yang ditentukan pengguna) di loop bagian dalam, dan tangkap di loop dari tempat Anda ingin melanjutkan kontrol. Jika Anda ingin istirahat dari semua loop, tangkap Pengecualian di luar semua loop. (Saya belum menunjukkan kasus ini sebagai contoh).