Cho mã sau (không hoạt động):

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

Có cách nào để làm cho công việc này? Hoặc tôi có thực hiện một kiểm tra để thoát ra khỏi vòng lặp đầu vào, sau đó kiểm tra khác, hạn chế hơn, kiểm tra trong vòng lặp bên ngoài để thoát ra tất cả cùng nhau nếu người dùng hài lòng?

Bản năng đầu tiên của tôi sẽ là cấu trúc lại vòng lặp lồng vào một hàm và sử dụng returnđể thoát ra.

Đây là một cách tiếp cận ngắn. Nhược điểm là bạn chỉ có thể phá vỡ vòng lặp bên ngoài, nhưng đôi khi nó chính xác là những gì bạn muốn.

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

Điều này sử dụng cấu trúc for / other được giải thích tại: Tại sao python sử dụng 'other' sau vòng lặp for và while?

Thông tin chi tiết chính: Có vẻ như nếu vòng lặp bên ngoài luôn luôn bị phá vỡ. Nhưng nếu vòng lặp bên trong không bị phá vỡ, vòng lặp bên ngoài sẽ không.

Các continuetuyên bố là sự kỳ diệu ở đây. Đó là trong mệnh đề for-other. Theo định nghĩa đó sẽ xảy ra nếu không có sự phá vỡ bên trong. Trong tình huống đó continuegọn gàng phá vỡ các phá vỡ bên ngoài.

PEP 3136 đề xuất phá vỡ / tiếp tục dán nhãn. Guido đã từ chối vì "mã quá phức tạp để yêu cầu tính năng này là rất hiếm". PEP có đề cập đến một số cách giải quyết, mặc dù (chẳng hạn như kỹ thuật ngoại lệ), trong khi Guido cảm thấy việc tái cấu trúc để sử dụng trả lại sẽ đơn giản hơn trong hầu hết các trường hợp.

Đầu tiên, logic thông thường là hữu ích.

Nếu, vì một số lý do, các điều kiện chấm dứt không thể được giải quyết, các trường hợp ngoại lệ là một kế hoạch dự phòng.

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

Đối với ví dụ cụ thể này, một ngoại lệ có thể không cần thiết.

Mặt khác, chúng ta thường có các tùy chọn "Y", "N" và "Q" trong các ứng dụng chế độ ký tự. Đối với tùy chọn "Q", chúng tôi muốn có một lối thoát ngay lập tức. Điều đó đặc biệt hơn.

Tôi có xu hướng đồng ý rằng tái cấu trúc thành một hàm thường là cách tiếp cận tốt nhất cho loại tình huống này, nhưng khi bạn thực sự cần thoát ra khỏi các vòng lặp lồng nhau, đây là một biến thể thú vị của phương pháp nâng cao ngoại lệ mà @ S.Lott đã mô tả. Nó sử dụng withcâu lệnh của Python để làm cho ngoại lệ tăng lên trông đẹp hơn một chút. Xác định trình quản lý bối cảnh mới (bạn chỉ phải thực hiện việc này một lần) với:

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

Bây giờ bạn có thể sử dụng trình quản lý bối cảnh này như sau:

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"

Ưu điểm: (1) nó sạch hơn một chút (không có khối ngoại trừ thử rõ ràng) và (2) bạn có được một Exceptionlớp con được xây dựng tùy chỉnh cho mỗi lần sử dụng nested_break; không cần phải khai báo Exceptionlớp con của riêng bạn mỗi lần.

Đầu tiên, bạn cũng có thể xem xét làm cho quá trình nhận và xác nhận đầu vào thành một hàm; trong hàm đó, bạn có thể trả về giá trị nếu đúng và tiếp tục quay trong khi vòng lặp nếu không muốn nói. Điều này về cơ bản làm giảm bớt vấn đề bạn đã giải quyết và thường có thể được áp dụng trong trường hợp tổng quát hơn (thoát ra khỏi nhiều vòng lặp). Nếu bạn hoàn toàn phải giữ cấu trúc này trong mã của mình và thực sự không muốn đối phó với các booleans kế toán ...

Bạn cũng có thể sử dụng goto theo cách sau (sử dụng mô-đun Cá tháng Tư từ đây ):

#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

Tôi biết, tôi biết, "ngươi sẽ không sử dụng goto" và tất cả những thứ đó, nhưng nó hoạt động tốt trong những trường hợp lạ như thế này.

Giới thiệu một biến mới mà bạn sẽ sử dụng làm 'bộ ngắt vòng'. Trước tiên, gán một cái gì đó cho nó (Sai, 0, v.v.), và sau đó, bên trong vòng lặp bên ngoài, trước khi bạn thoát khỏi nó, thay đổi giá trị thành một thứ khác (Đúng, 1, ...). Khi thoát khỏi vòng lặp, hãy kiểm tra vòng lặp 'cha mẹ' cho giá trị đó. Hãy để tôi chứng minh:

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

Nếu bạn có một vòng lặp vô hạn, đây là lối thoát duy nhất; thực hiện các vòng lặp khác thực sự nhanh hơn rất nhiều. Điều này cũng hoạt động nếu bạn có nhiều vòng lặp lồng nhau. Bạn có thể thoát tất cả, hoặc chỉ một vài. Khả năng vô tận! Hy vọng điều này sẽ giúp!

Để thoát ra khỏi nhiều vòng lặp lồng nhau, mà không tái cấu trúc thành một hàm, hãy sử dụng "câu lệnh goto mô phỏng" với ngoại lệ StopIteration tích hợp :

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

except StopIteration: pass

Xem cuộc thảo luận này về việc sử dụng các câu lệnh goto để thoát ra khỏi các vòng lặp lồng nhau.

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

hoặc điều tương tự. Bạn có thể đặt một biến trong vòng lặp bên trong và kiểm tra nó trong vòng lặp bên ngoài ngay sau khi vòng lặp bên trong thoát ra, phá vỡ nếu thích hợp. Tôi giống như phương pháp GOTO, miễn là bạn không phiền khi sử dụng mô-đun trò đùa Cá tháng Tư - nó không phải là Pythonic, nhưng nó thực sự có ý nghĩa.

Đây không phải là cách đẹp nhất để làm điều đó, nhưng theo tôi, đó là cách tốt nhất.

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

Tôi khá chắc chắn rằng bạn cũng có thể tìm ra thứ gì đó bằng cách sử dụng đệ quy ở đây, nhưng tôi không biết nếu đó là một lựa chọn tốt cho bạn.

Và tại sao không tiếp tục lặp nếu hai điều kiện là đúng? Tôi nghĩ rằng đây là một cách pythonic hơn:

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

Phải không?

Tất cả tốt nhất.

Yếu tố logic vòng lặp của bạn vào một trình vòng lặp mang lại các biến vòng lặp và trả về khi hoàn thành - đây là một cách đơn giản để đưa ra hình ảnh trong các hàng / cột cho đến khi chúng ta hết hình ảnh hoặc ra khỏi vị trí để đặt chúng:

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

Điều này có lợi thế là phân tách logic vòng lặp phức tạp và xử lý ...

Trong trường hợp này, như được chỉ ra bởi những người khác, phân rã chức năng là cách để đi. Mã trong 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

Có một mẹo ẩn trong while ... elsecấu trúc Python có thể được sử dụng để mô phỏng ngắt kép mà không cần thay đổi / bổ sung nhiều mã. Về bản chất nếu whileđiều kiện là sai, elsekhối được kích hoạt. Không có ngoại lệ, continuehoặc breakkích hoạt elsekhối. Để biết thêm thông tin, hãy xem câu trả lời cho " Điều khoản khác trên Python while statement " hoặc Python doc on 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

Nhược điểm duy nhất là bạn cần di chuyển điều kiện ngắt kép vào whileđiều kiện (hoặc thêm một biến cờ). Biến thể của điều này cũng tồn tại đối với forvòng lặp, trong đó elsekhối được kích hoạt sau khi hoàn thành vòng lặp.

Một cách khác để giảm số lần lặp của bạn xuống một vòng lặp cấp đơn sẽ thông qua việc sử dụng các trình tạo như được chỉ định trong tham chiếu python

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

Bạn có thể mở rộng nó tới bất kỳ số cấp nào cho vòng lặp

Nhược điểm là bạn không còn có thể phá vỡ chỉ một cấp độ duy nhất. Đó là tất cả hoặc không có gì.

Một nhược điểm khác là nó không hoạt động với vòng lặp while. Ban đầu tôi muốn đăng câu trả lời này lên Python - `break` trong tất cả các vòng lặp nhưng tiếc là nó đã bị đóng như một bản sao của câu hỏi này

Lý do tôi đến đây là tôi có một vòng lặp bên ngoài và một vòng lặp bên trong như vậ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

  do some other stuff with x

Như bạn có thể thấy, nó sẽ không thực sự đi đến x tiếp theo, mà sẽ chuyển sang y tiếp theo.

thay vào đó, điều tôi tìm thấy để giải quyết điều này chỉ đơn giản là chạy qua mảng hai lần:

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

Tôi biết đây là một trường hợp cụ thể của câu hỏi của OP, nhưng tôi đăng nó với hy vọng nó sẽ giúp ai đó nghĩ về vấn đề của họ một cách khác biệt trong khi giữ mọi thứ đơn giản.

Hãy thử sử dụng một máy phát vô hạn.

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

Bằng cách sử dụng một chức năng:

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

Hãy thử chạy các mã trên bằng cách bình luận returnlà tốt.

Không sử dụng bất kỳ chức năng nào:

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

Bây giờ, hãy chạy các mã ở trên như trước và sau đó thử chạy bằng cách nhận xét từng dòng chứa breakmột dòng từ dưới lên.

Một cách dễ dàng để biến nhiều vòng lặp thành một vòng lặp đơn, có thể phá vỡ là sử dụng 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!

Bạn phải lập chỉ mục vào các đối tượng của mình, trái ngược với việc có thể lặp lại thông qua các giá trị một cách rõ ràng, nhưng ít nhất trong các trường hợp đơn giản, nó dường như đơn giản hơn khoảng 2-20 lần so với hầu hết các câu trả lời được đề xuất.

# 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

có lẽ mẹo nhỏ như dưới đây sẽ làm nếu không thích tái cấu trúc thành chức năng

đã thêm 1 biến break_level để kiểm soát điều kiện vòng lặp 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

Bạn có thể định nghĩa một biến (ví dụ break_statement ), sau đó thay đổi nó thành một giá trị khác khi điều kiện hai ngắt xảy ra và sử dụng nó trong câu lệnh if để ngắt từ vòng lặp thứ hai.

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

Tôi muốn nhắc bạn rằng các hàm trong Python có thể được tạo ngay giữa mã và có thể truy cập các biến xung quanh một cách trong suốt để đọc và với nonlocalhoặc globalkhai báo để viết.

Vì vậy, bạn có thể sử dụng một chức năng như một "cấu trúc điều khiển có thể phá vỡ", xác định địa điểm bạn muốn quay lại:

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

Giải pháp theo 2 cách

Với một ví dụ: Hai ma trận này có bằng nhau không?
matrix1 và matrix2 có cùng kích thước, n, 2 ma trận thay thế.

Giải pháp đầu tiên , không có chức năng

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

Giải pháp thứ hai , với chức năng
Đây là giải pháp cuối cùng cho trường hợp của tôi

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

Chúc một ngày tốt lành!

# 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

Hy vọng điều này sẽ giúp:

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

Đây là một triển khai có vẻ hoạt động:

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)

Hạn chế duy nhất là bạn phải xác định break_trước các vòng lặp.

Không có cách nào để làm điều này từ cấp độ ngôn ngữ. Một số ngôn ngữ có goto, một số ngôn ngữ khác có một cuộc tranh luận, nhưng python thì không.

Các tùy chọn tốt nhất là:

1. Đặt cờ được kiểm tra bởi vòng lặp bên ngoài hoặc đặt điều kiện vòng lặp bên ngoài.

2. Đặt vòng lặp trong một hàm và sử dụng return để thoát ra khỏi tất cả các vòng lặp cùng một lúc.

3. Cải cách logic của bạn.

Tín dụng cho Vivek Nagarajan, Lập trình viên từ năm 1987

Sử dụng chức năng

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

Sử dụng cờ

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

Tương tự như trước đây, nhưng nhỏ gọn hơn. (Booleans chỉ là số)

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

Vì câu hỏi này đã trở thành một câu hỏi tiêu chuẩn để xâm nhập vào một vòng lặp cụ thể, tôi muốn đưa ra câu trả lời của mình với ví dụ sử dụng Exception .

Mặc dù tồn tại không có nhãn có tên là phá vỡ vòng lặp trong cấu trúc lặp nhiều lần, chúng ta có thể sử dụng Ngoại lệ do Người dùng xác định để đột nhập vào một vòng lặp cụ thể mà chúng ta chọn. Xem xét ví dụ sau trong đó cho phép chúng tôi in tất cả các số có tối đa 4 chữ số trong hệ thống đánh số cơ sở 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

Khi chúng tôi in đầu ra, chúng tôi sẽ không bao giờ nhận được bất kỳ giá trị nào có vị trí đơn vị là 4. Trong trường hợp đó, chúng tôi không thoát khỏi bất kỳ vòng lặp nào khi BreakLoop(4)được nâng lên và bắt trong cùng một vòng lặp. Tương tự, bất cứ khi nào mười vị trí có 3, chúng tôi sẽ chia thành vòng lặp thứ ba bằng cách sử dụng BreakLoop(3). Bất cứ khi nào hàng trăm địa điểm có 5, chúng tôi sẽ chia thành vòng lặp thứ hai bằng cách sử dụngBreakLoop(2) và khi hàng nghìn vị trí có 2, chúng ta sẽ chia thành vòng lặp thứ nhất bằng cách sử dụngBreakLoop(1) .

Nói tóm lại, hãy nâng Ngoại lệ của bạn (được xây dựng hoặc do người dùng xác định) vào các vòng bên trong và bắt nó trong vòng lặp từ nơi bạn muốn tiếp tục điều khiển của mình. Nếu bạn muốn thoát khỏi tất cả các vòng lặp, hãy bắt Ngoại lệ bên ngoài tất cả các vòng lặp. (Tôi đã không hiển thị trường hợp này trong ví dụ).