รับรหัสต่อไปนี้ (ที่ใช้งานไม่ได้):

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

มีวิธีที่จะทำให้งานนี้หรือไม่? หรือฉันจะตรวจสอบหนึ่งครั้งเพื่อแยกออกจากลูปอินพุทจากนั้นอีก จำกัด มากขึ้นตรวจสอบในลูปภายนอกเพื่อแยกออกทั้งหมดด้วยกันถ้าผู้ใช้พอใจ?

สัญชาตญาณแรกของฉันคือการ refactor วนซ้อนกันเป็นฟังก์ชั่นและใช้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 ที่อธิบายไว้ที่: ทำไมไพ ธ อนจึงใช้ 'else' หลังจาก for และ while loops?

ข้อมูลเชิงลึกที่สำคัญ: ดูเหมือนว่าลูปด้านนอกจะแตกเสมอ แต่ถ้าวงด้านในไม่แตกออกมาวงนอกก็ไม่เหมือนกัน

continueคำสั่งคือความมหัศจรรย์ที่นี่ มันอยู่ในประโยคอื่น ตามคำนิยามที่เกิดขึ้นหากไม่มีการแบ่งด้านใน ในสถานการณ์นั้นcontinueหลีกเลี่ยงการแบ่งด้านนอกอย่างเรียบร้อย

PEP 3136เสนอตัวแบ่ง / ติดป้ายกำกับ กุยโดปฏิเสธเพราะ "รหัสที่ซับซ้อนซึ่งต้องใช้คุณสมบัตินี้หายากมาก" 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คำสั่งPython เพื่อสร้างข้อยกเว้นให้ดูดีขึ้นเล็กน้อย กำหนดผู้จัดการบริบทใหม่ (คุณต้องทำสิ่งนี้เพียงครั้งเดียว) ด้วย:

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คลาสย่อยของคุณเองทุกครั้ง

ก่อนอื่นคุณอาจพิจารณาทำกระบวนการรับและตรวจสอบฟังก์ชันการป้อนข้อมูล ในฟังก์ชั่นนั้นคุณสามารถคืนค่าได้ถ้ามันถูกต้องและหมุนไปเรื่อย ๆในขณะที่ลูปถ้าไม่ สิ่งนี้จะทำให้เกิดปัญหาที่คุณแก้ไขและมักจะสามารถนำไปใช้ในกรณีทั่วไปมากขึ้น (แบ่งออกเป็นหลายลูป) หากคุณต้องเก็บโครงสร้างนี้ไว้ในรหัสของคุณและไม่ต้องการจัดการกับการทำบัญชีบูลีน ...

คุณสามารถใช้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

ฉันรู้ฉันรู้ว่า "เจ้าจะไม่ใช้ 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   # <--- !

หากคุณมีการวนซ้ำไม่สิ้นสุดนี่เป็นทางออกเดียวเท่านั้น สำหรับการประมวลผลลูปอื่น ๆ นั้นเร็วกว่ามาก วิธีนี้ใช้งานได้หากคุณมีลูปซ้อนกันหลายลูป คุณสามารถออกทั้งหมดหรือเพียงไม่กี่ ความเป็นไปได้ไม่สิ้นสุด! หวังว่านี่จะช่วยได้!

หากต้องการแยกลูปซ้อนหลายวงโดยไม่ต้องเปลี่ยนโครงสร้างเป็นฟังก์ชันให้ใช้คำสั่ง "จำลองคำสั่ง goto" พร้อมกับข้อยกเว้น StopIterationในตัว :

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 ถ้าคุณไม่รังเกียจที่จะใช้โมดูลตลกของ April Fool - ไม่ใช่ 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

ฉันค่อนข้างมั่นใจว่าคุณสามารถหาสิ่งที่ใช้การสอบถามซ้ำได้ที่นี่เช่นกัน แต่ฉันก็ไม่รู้ว่ามันเป็นตัวเลือกที่ดีสำหรับคุณหรือไม่

และทำไมไม่ลองวนซ้ำถ้าสองเงื่อนไขเป็นจริง ฉันคิดว่านี่เป็นวิธี 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

ไม่ใช่เหรอ

ทั้งหมดที่ดีที่สุด

ใช้ตรรกะลูปของคุณเป็นตัววนซ้ำที่ให้ผลตอบแทนตัวแปรลูปและส่งคืนเมื่อเสร็จแล้ว - นี่คือวิธรรมดาที่วางรูปภาพในแถว / คอลัมน์จนกว่าเราจะออกจากภาพหรือนอกสถานที่

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

มีเคล็ดลับที่ซ่อนอยู่ในwhile ... elseโครงสร้างPython ซึ่งสามารถใช้ในการจำลองการแบ่งคู่โดยไม่มีการเปลี่ยนแปลง / เพิ่มเติมรหัสมาก ในสาระสำคัญหากwhileเงื่อนไขเป็นเท็จelseบล็อกจะถูกเรียก ไม่มีข้อยกเว้นcontinueหรือbreakเรียกใช้elseบล็อก สำหรับข้อมูลเพิ่มเติมโปรดดูที่คำตอบ " ข้ออื่นในหลามในขณะที่คำสั่ง " หรืองูหลาม 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

คุณสามารถปรับขนาดได้ตามระดับของลูป

ข้อเสียคือคุณไม่สามารถทำลายเพียงระดับเดียวอีกต่อไป มันคือทั้งหมดหรือไม่มีอะไร

ข้อเสียอีกอย่างคือมันไม่สามารถทำงานได้ในขณะที่ลูป ฉันต้องการโพสต์คำตอบนี้ไว้บน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 ต่อไปแทน

สิ่งที่ฉันพบเพื่อแก้ปัญหานี้ก็คือการทำงานผ่านอาร์เรย์สองครั้งแทน

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

อาจเป็นกลอุบายเล็ก ๆ น้อย ๆ เช่นด้านล่างนี้หากไม่ต้องการปรับโครงสร้างให้ทำงาน

เพิ่ม 1 break_level variable เพื่อควบคุมเงื่อนไข while loop

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 ) จากนั้นเปลี่ยนเป็นค่าที่แตกต่างกันเมื่อเกิดเงื่อนไขสองจุดและใช้ในถ้าคำสั่งแตกจากลูปที่สองด้วย

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 วิธี

ด้วยตัวอย่าง: เมทริกซ์สองตัวนี้มีค่าเท่ากันหรือไม่
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 ที่คนอื่นมีตัวแบ่งที่ใช้อาร์กิวเมนต์, หลามไม่

ตัวเลือกที่ดีที่สุดคือ:

1. ตั้งค่าสถานะซึ่งตรวจสอบโดยลูปภายนอกหรือตั้งค่าเงื่อนไขลูปภายนอก

2. ใส่วนในฟังก์ชันและใช้ return เพื่อแยกลูปทั้งหมดในครั้งเดียว

3. จัดระเบียบตรรกะของคุณใหม่

เครดิตไปที่ Vivek Nagarajan โปรแกรมเมอร์ตั้งแต่ปี 1987

การใช้ฟังก์ชั่น

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

คล้ายกับรุ่นก่อน แต่มีขนาดกะทัดรัดกว่า (Booleans เป็นเพียงตัวเลข)

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เนื่องจากคำถามนี้ได้กลายเป็นคำถามมาตรฐานสำหรับการทำลายเป็นห่วงโดยเฉพาะอย่างยิ่งผมอยากจะให้คำตอบของฉันกับตัวอย่างการใช้

แม้ว่าจะไม่มีชื่อฉลากว่าแบ่งเป็นลูปในโครงสร้างวนลูปแบบทวีคูณ แต่เราสามารถใช้ข้อยกเว้นที่ผู้ใช้กำหนดเองเพื่อเจาะเข้าไปในลูปเฉพาะของตัวเลือกของเรา ลองพิจารณาตัวอย่างต่อไปนี้ที่ให้เราพิมพ์ตัวเลขทั้งหมดไม่เกิน 4 หลักในระบบเลขฐาน 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

เมื่อเราพิมพ์ผลลัพธ์เราจะไม่ได้รับค่าใด ๆ ที่มีหน่วยเป็น 4 ในกรณีนี้เราไม่แยกจากลูปใด ๆ ตามที่BreakLoop(4)ยกขึ้นและติดในลูปเดียวกัน ในทำนองเดียวกันเมื่อใดก็ตามที่สิบสถานที่จะมี 3 BreakLoop(3)เราบุกเข้าไปในวงที่สามใช้ เมื่อใดก็ตามที่ร้อยที่มี 5 เราแบ่งออกเป็นสองวงโดยใช้BreakLoop(2)และเมื่อใดก็ตามที่หนึ่งพันมี 2 เราก็แบ่งออกเป็นวงแรกโดยใช้BreakLoop(1)เราบุกเข้าไปในวงครั้งแรกที่ใช้

กล่าวโดยสรุปยกข้อยกเว้นของคุณ (ในตัวหรือสร้างโดยผู้ใช้กำหนด) ในวงในและจับมันในวงจากที่คุณต้องการกลับมาควบคุมของคุณ หากคุณต้องการแยกจากลูปทั้งหมดให้จับข้อยกเว้นภายนอกลูปทั้งหมด (ฉันไม่ได้แสดงกรณีนี้ในตัวอย่าง)