Biorąc pod uwagę następujący kod (który nie działa):

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

Czy istnieje sposób, aby to zadziałało? Czy też muszę wykonać jedną kontrolę, aby wyjść z pętli wejściowej, a następnie inną, bardziej ograniczoną, sprawdzić w pętli zewnętrznej, aby zerwać wszystko razem, jeśli użytkownik jest zadowolony?

Moim pierwszym instynktem byłoby przekształcenie zagnieżdżonej pętli w funkcję i użycie jej returndo wybicia.

Oto inne podejście, które jest krótkie. Wadą jest to, że możesz przełamać tylko zewnętrzną pętlę, ale czasami jest to dokładnie to, czego chcesz.

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

Wykorzystuje konstrukcję for / else wyjaśnioną na stronie: Dlaczego Python używa pętli „else” po pętli for i while?

Kluczowy wgląd: Wydaje się , że zewnętrzna pętla zawsze pęka.Ale jeśli pętla wewnętrzna nie pęknie, pętla zewnętrzna też nie.

continueStwierdzenie jest magia tutaj. Jest w klauzuli for-else. Z definicji dzieje się tak, jeśli nie ma wewnętrznej przerwy. W tej sytuacji continuestarannie omija zewnętrzną przerwę.

PEP 3136 proponuje oznaczenie przerwa / kontynuacja. Guido odrzucił go, ponieważ „tak skomplikowany kod wymagający tej funkcji jest bardzo rzadki”. PEP wspomina jednak o niektórych obejściach (takich jak technika wyjątków), podczas gdy Guido uważa, że ​​refaktoryzacja użycia return będzie w większości przypadków prostsza.

Po pierwsze, pomocna jest zwykła logika.

Jeśli z jakiegoś powodu warunki zakończenia nie mogą zostać wypracowane, wyjątki stanowią plan awaryjny.

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

W tym konkretnym przykładzie wyjątek może nie być konieczny.

Z drugiej strony często mamy opcje „Y”, „N” i „Q” w aplikacjach w trybie znakowym. W przypadku opcji „Q” chcemy natychmiastowego wyjścia. To bardziej wyjątkowe.

Zwykle zgadzam się, że refaktoryzacja do funkcji jest zwykle najlepszym podejściem w tego rodzaju sytuacjach, ale gdy naprawdę potrzebujesz wyrwać się z zagnieżdżonych pętli, oto ciekawy wariant podejścia do zgłaszania wyjątków opisanego przez @ S.Lott. Korzysta z withinstrukcji Pythona, aby wyjątek wyglądał nieco ładniej. Zdefiniuj nowego menedżera kontekstu (musisz to zrobić tylko raz) za pomocą:

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

Teraz możesz użyć tego menedżera kontekstu w następujący sposób:

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"

Zalety: (1) jest nieco czystszy (brak wyraźnego bloku try-oprócz), oraz (2) otrzymujesz niestandardową Exceptionpodklasę dla każdego zastosowania nested_break; nie trzeba za Exceptionkażdym razem deklarować własnej podklasy.

Po pierwsze, możesz również rozważyć uczynienie procesu pobierania i sprawdzania poprawności danych wejściowych funkcją; w ramach tej funkcji, można po prostu zwrócić wartość, jeżeli jego poprawne, i się obracać w czasie pętli czy nie. To zasadniczo eliminuje rozwiązany problem i zwykle można go zastosować w bardziej ogólnym przypadku (zerwanie wielu pętli). Jeśli absolutnie musisz zachować tę strukturę w swoim kodzie i naprawdę nie chcesz zajmować się rachunkami logicznymi ...

Możesz także użyć goto w następujący sposób (używając modułu April Fools stąd ):

#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

Wiem, wiem, „nie będziesz używać goto” i tak dalej, ale działa to dobrze w takich dziwnych przypadkach.

Wprowadź nową zmienną, której będziesz używać jako „przerywacza pętli”. Najpierw przypisz coś do niego (False, 0 itd.), A następnie w zewnętrznej pętli, zanim się od niego oderwiesz, zmień wartość na coś innego (True, 1, ...). Po wyjściu z pętli sprawdź w pętli „macierzystej” tę wartość. Pokażę:

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

Jeśli masz nieskończoną pętlę, jest to jedyne wyjście; dla innych pętli wykonywanie jest naprawdę dużo szybsze. Działa to również, jeśli masz wiele zagnieżdżonych pętli. Możesz wyjść ze wszystkich lub tylko kilku. Niekończące się możliwości! Mam nadzieję, że to pomogło!

Aby wyrwać się z wielu zagnieżdżonych pętli, bez refaktoryzacji do funkcji, skorzystaj z „symulowanej instrukcji goto” z wbudowanym wyjątkiem StopIteration :

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

except StopIteration: pass

Zobacz tę dyskusję na temat używania instrukcji goto do przełamywania zagnieżdżonych pętli.

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

czy jakoś tak. Możesz ustawić zmienną w wewnętrznej pętli i sprawdzić ją w zewnętrznej pętli natychmiast po wyjściu z wewnętrznej pętli, przerywając w razie potrzeby. Podoba mi się metoda GOTO, pod warunkiem, że nie masz nic przeciwko użyciu modułu żartów prima aprilis - nie jest to Python, ale ma sens.

To nie jest najładniejszy sposób na zrobienie tego, ale moim zdaniem jest to najlepszy sposób.

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

Jestem prawie pewien, że mógłbyś tutaj również opracować coś za pomocą rekurencji, ale nie wiem, czy to dla ciebie dobra opcja.

A dlaczego nie kontynuować pętli, jeśli dwa warunki są spełnione? Myślę, że jest to bardziej pythonowy sposób:

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

Czyż nie

Wszystkiego najlepszego.

Uwzględnij logikę pętli w iteratorze, który zwraca zmienne pętli i zwraca po zakończeniu - oto prosty układ, który układa obrazy w wierszach / kolumnach, dopóki nie zabraknie obrazów lub miejsc, aby je umieścić:

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

Ma to tę zaletę, że dzieli skomplikowaną logikę pętli i przetwarzanie ...

W tym przypadku, jak zauważyli również inni, właściwym rozwiązaniem jest rozkład funkcjonalny. Kod w Pythonie 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

W while ... elsestrukturze Pythona istnieje ukryta sztuczka , której można użyć do symulacji podwójnego podziału bez większych zmian / dodatków kodu. Zasadniczo, jeśli whilewarunek jest fałszywy, elseblok jest wyzwalany. Ani wyjątki, continueani breakwyzwalanie elsebloku. Aby uzyskać więcej informacji, zobacz odpowiedzi na „ Else klauzula dotycząca instrukcji Python while ” lub dokumentacja Python podczas korzystania (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

Jedynym minusem jest to, że musisz przenieść warunek podwójnego łamania do whilewarunku (lub dodać zmienną flagową). Istnieją tego warianty dla forpętli, w której elseblok jest wyzwalany po zakończeniu pętli.

Innym sposobem zredukowania iteracji do pętli jednopoziomowej byłoby użycie generatorów, jak również określono w odwołaniu do pytona

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

Możesz skalować go do dowolnej liczby poziomów dla pętli

Minusem jest to, że nie można już przekroczyć tylko jednego poziomu. To wszystko albo nic.

Kolejną wadą jest to, że nie działa z pętlą while. Pierwotnie chciałem opublikować tę odpowiedź na Pythonie - `wyrwij się ze wszystkich pętli, ale niestety jest to zamknięte jako duplikat tego

Powodem mojego przyjazdu jest to, że miałem zewnętrzną i wewnętrzną pętlę:

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

Jak widać, tak naprawdę nie przejdzie do następnego x, ale zamiast tego przejdzie do następnego y.

znalazłem rozwiązanie tego po prostu dwa razy przez tablicę:

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

Wiem, że był to konkretny przypadek pytania OP, ale piszę je w nadziei, że pomoże to komuś inaczej myśleć o ich problemie, jednocześnie zachowując prostotę.

Spróbuj użyć nieskończonego generatora.

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

Korzystając z funkcji:

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

Spróbuj uruchomić powyższe kody, komentując returnrównież.

Bez użycia żadnej funkcji:

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

Teraz uruchom powyższe kody w pierwszej kolejności, a następnie spróbuj uruchomić, komentując każdą linię zawierającą breakjeden na raz od dołu.

Łatwym sposobem na przekształcenie wielu pętli w jedną, łamliwą pętlę jest użycie 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!

Musisz indeksować do swoich obiektów, w przeciwieństwie do możliwości jawnego iterowania wartości, ale przynajmniej w prostych przypadkach wydaje się to około 2-20 razy prostsze niż większość sugerowanych odpowiedzi.

# 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

prawdopodobnie mała sztuczka, jak poniżej, zrobi, jeśli nie woli refaktoryzacji do funkcji

dodano 1 zmienną break_level, aby kontrolować warunek pętli 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

Możesz zdefiniować zmienną (na przykład break_statement ), a następnie zmienić ją na inną wartość, gdy wystąpi warunek dwóch przerw, i użyć jej w instrukcji if, aby również przerwać z drugiej pętli.

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

Chciałbym przypomnieć, że funkcje w języku Python można tworzyć bezpośrednio w środku kodu i mogą one w przejrzysty sposób uzyskać dostęp do otaczających zmiennych w celu odczytu nonlocallubglobal deklaracji do pisania.

Możesz więc użyć funkcji jako „łamliwej struktury kontroli”, określającej miejsce, do którego chcesz wrócić:

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

Rozwiązania na 2 sposoby

Na przykład: czy te dwie macierze są równe / takie same?
macierz 1 i macierz 2 mają ten sam rozmiar, n, 2 macierze wymiarowe.

Pierwsze rozwiązanie , bez funkcji

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

Drugie rozwiązanie , z funkcją
Jest to ostateczne rozwiązanie dla mojej sprawy

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

Miłego dnia!

# 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

Mam nadzieję, że to pomaga:

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

Oto implementacja, która wydaje się działać:

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)

Jedyną wadą jest to, że musisz zdefiniować break_przed pętlami.

Nie można tego zrobić z poziomu języka. Niektóre języki mają błąd, inne mają przerwę, która wymaga argumentu, a python nie.

Najlepsze opcje to:

1. Ustaw flagę sprawdzaną przez zewnętrzną pętlę lub ustaw stan zewnętrznej pętli.

2. Umieść pętlę w funkcji i użyj return, aby zerwać wszystkie pętle jednocześnie.

3. Przeformułuj swoją logikę.

Podziękowania należą się Vivek Nagarajan, programista od 1987 roku

Korzystanie z funkcji

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

Za pomocą flagi

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

Podobnie jak poprzednio, ale bardziej kompaktowy. (Booleany to tylko liczby)

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

Ponieważ pytanie to stało się standardowym pytaniem o włamanie do określonej pętli, chciałbym udzielić odpowiedzi na przykład, używając Exception.

Mimo że w konstrukcji wielokrotnie zapętlonej nie ma etykiety o nazwie zerwanie pętli, możemy skorzystać z wyjątków zdefiniowanych przez użytkownika, aby włamać się do wybranej przez nas pętli. Rozważ następujący przykład, w którym wydrukujmy wszystkie liczby do 4 cyfr w systemie numeracji base-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

Kiedy wypisujemy dane wyjściowe, nigdy nie otrzymamy żadnej wartości, której jednostką jest 4. W takim przypadku nie przerywamy żadnej pętli, ponieważ BreakLoop(4)jest ona podnoszona i przechwytywana w tej samej pętli. Podobnie, ilekroć dziesięć miejsc ma 3, włamy się do trzeciej pętli za pomocą BreakLoop(3). Ilekroć sto miejsc ma 5, BreakLoop(2)włamy się do drugiej pętli, a gdy tysiąc miejsc ma 2, włamujemy się do pierwszej pętli, używającBreakLoop(1) .

Krótko mówiąc, podnieś swój wyjątek (wbudowany lub zdefiniowany przez użytkownika) w wewnętrznych pętlach i złap go w pętli, z której chcesz wznowić kontrolę. Jeśli chcesz zerwać ze wszystkich pętli, złap wyjątek poza wszystkimi pętlami. (Nie pokazałem tego przypadku w przykładzie).