Giả lập một vòng lặp do-while trong Python?

Tôi cần mô phỏng một vòng lặp do-while trong chương trình Python. Thật không may, mã đơn giản sau đây không hoạt động:

list_of_ints = [ 1, 2, 3 ]
iterator = list_of_ints.__iter__()
element = None

while True:
  if element:
    print element

  try:
    element = iterator.next()
  except StopIteration:
    break

print "done"

Thay vì "1,2,3, xong", nó in ra kết quả sau:

[stdout:]1
[stdout:]2
[stdout:]3
None['Traceback (most recent call last):
', '  File "test_python.py", line 8, in <module>
    s = i.next()
', 'StopIteration
']

Tôi có thể làm gì để bắt ngoại lệ 'dừng lặp' và phá vỡ vòng lặp while đúng cách?

Một ví dụ về lý do tại sao một điều như vậy có thể cần thiết được hiển thị dưới đây là mã giả.

Máy nhà nước:

s = ""
while True :
  if state is STATE_CODE :
    if "//" in s :
      tokens.add( TOKEN_COMMENT, s.split( "//" )[1] )
      state = STATE_COMMENT
    else :
      tokens.add( TOKEN_CODE, s )
  if state is STATE_COMMENT :
    if "//" in s :
      tokens.append( TOKEN_COMMENT, s.split( "//" )[1] )
    else
      state = STATE_CODE
      # Re-evaluate same line
      continue
  try :
    s = i.next()
  except StopIteration :
    break

Tôi không chắc chắn những gì bạn đang cố gắng làm. Bạn có thể thực hiện một vòng lặp do-while như thế này:

while True:
  stuff()
  if fail_condition:
    break

Hoặc là:

stuff()
while not fail_condition:
  stuff()

Bạn đang làm gì để cố gắng sử dụng một vòng lặp do while để in các thứ trong danh sách? Tại sao không chỉ sử dụng:

for i in l:
  print i
print "done"

Cập nhật:

Vì vậy, bạn có một danh sách các dòng? Và bạn muốn tiếp tục lặp qua nó? Làm thế nào về:

for s in l: 
  while True: 
    stuff() 
    # use a "break" instead of s = i.next()

Điều đó có vẻ giống như một cái gì đó gần với những gì bạn muốn? Với ví dụ mã của bạn, nó sẽ là:

for s in some_list:
  while True:
    if state is STATE_CODE:
      if "//" in s:
        tokens.add( TOKEN_COMMENT, s.split( "//" )[1] )
        state = STATE_COMMENT
      else :
        tokens.add( TOKEN_CODE, s )
    if state is STATE_COMMENT:
      if "//" in s:
        tokens.append( TOKEN_COMMENT, s.split( "//" )[1] )
        break # get next s
      else:
        state = STATE_CODE
        # re-evaluate same line
        # continues automatically

Đây là một cách rất đơn giản để mô phỏng vòng lặp do-while:

condition = True
while condition:
    # loop body here
    condition = test_loop_condition()
# end of loop

Các tính năng chính của vòng lặp do-while là thân vòng lặp luôn thực thi ít nhất một lần và điều kiện được đánh giá ở dưới cùng của thân vòng lặp. Cấu trúc điều khiển hiển thị ở đây hoàn thành cả hai điều này mà không cần ngoại lệ hoặc phá vỡ các câu lệnh. Nó không giới thiệu thêm một biến Boolean.

Mã của tôi dưới đây có thể là một triển khai hữu ích, nêu bật sự khác biệt chính giữa làm trong khi đấu với trong khi như tôi hiểu nó.

Vì vậy, trong trường hợp này, bạn luôn luôn đi qua vòng lặp ít nhất một lần.

first_pass = True
while first_pass or condition:
    first_pass = False
    do_stuff()

Ngoại lệ sẽ phá vỡ vòng lặp, vì vậy bạn cũng có thể xử lý nó bên ngoài vòng lặp.

try:
  while True:
    if s:
      print s
    s = i.next()
except StopIteration:   
  pass

Tôi đoán rằng vấn đề với mã của bạn là hành vi breakbên trong exceptkhông được xác định. Nói chung breakchỉ đi lên một cấp, vì vậy, ví dụ breakbên trong tryđi thẳng vào finally(nếu nó tồn tại) một bên ngoài try, nhưng không ra khỏi vòng lặp.

PEP liên quan: http://www.python.org/dev/peps/pep-3136
Câu hỏi liên quan: Thoát ra khỏi các vòng lặp lồng nhau

do {
  stuff()
} while (condition())

->

while True:
  stuff()
  if not condition():
    break

Bạn có thể thực hiện một chức năng:

def do_while(stuff, condition):
  while condition(stuff()):
    pass

Nhưng 1) Thật xấu xí. 2) Điều kiện phải là một hàm có một tham số, được cho là được điền bởi công cụ (đó là lý do duy nhất để không sử dụng vòng lặp while cổ điển.)

Đây là một giải pháp điên rồ hơn của một mô hình khác - sử dụng coroutines. Mã vẫn rất giống nhau, nhưng với một sự khác biệt quan trọng; không có điều kiện thoát nào cả! Các coroutine (chuỗi coroutines thực sự) chỉ dừng lại khi bạn ngừng cho nó ăn với dữ liệu.

def coroutine(func):
    """Coroutine decorator

    Coroutines must be started, advanced to their first "yield" point,
    and this decorator does this automatically.
    """
    def startcr(*ar, **kw):
        cr = func(*ar, **kw)
        cr.next()
        return cr
    return startcr

@coroutine
def collector(storage):
    """Act as "sink" and collect all sent in @storage"""
    while True:
        storage.append((yield))

@coroutine      
def state_machine(sink):
    """ .send() new parts to be tokenized by the state machine,
    tokens are passed on to @sink
    """ 
    s = ""
    state = STATE_CODE
    while True: 
        if state is STATE_CODE :
            if "//" in s :
                sink.send((TOKEN_COMMENT, s.split( "//" )[1] ))
                state = STATE_COMMENT
            else :
                sink.send(( TOKEN_CODE, s ))
        if state is STATE_COMMENT :
            if "//" in s :
                sink.send(( TOKEN_COMMENT, s.split( "//" )[1] ))
            else
                state = STATE_CODE
                # re-evaluate same line
                continue
        s = (yield)

tokens = []
sm = state_machine(collector(tokens))
for piece in i:
    sm.send(piece)

Đoạn mã trên thu thập tất cả các mã thông báo dưới dạng bộ dữ liệu tokensvà tôi cho rằng không có sự khác biệt giữa .append()và .add()trong mã gốc.

Cách tôi đã làm điều này như sau ...

condition = True
while condition:
     do_stuff()
     condition = (<something that evaluates to True or False>)

Đây dường như là một giải pháp đơn giản, tôi ngạc nhiên vì tôi chưa thấy nó ở đây. Điều này rõ ràng cũng có thể được đảo ngược để

while not condition:

Vân vân.

cho một vòng lặp do - while chứa các câu lệnh try

loop = True
while loop:
    generic_stuff()
    try:
        questionable_stuff()
#       to break from successful completion
#       loop = False  
    except:
        optional_stuff()
#       to break from unsuccessful completion - 
#       the case referenced in the OP's question
        loop = False
   finally:
        more_generic_stuff()

cách khác, khi không cần mệnh đề 'cuối cùng'

while True:
    generic_stuff()
    try:
        questionable_stuff()
#       to break from successful completion
#       break  
    except:
        optional_stuff()
#       to break from unsuccessful completion - 
#       the case referenced in the OP's question
        break

while condition is True: 
  stuff()
else:
  stuff()

Hack nhanh:

def dowhile(func = None, condition = None):
    if not func or not condition:
        return
    else:
        func()
        while condition():
            func()

Sử dụng như vậy:

>>> x = 10
>>> def f():
...     global x
...     x = x - 1
>>> def c():
        global x
        return x > 0
>>> dowhile(f, c)
>>> print x
0

Tại sao bạn không làm

for s in l :
    print s
print "done"

?

Xem nếu điều này giúp:

Đặt cờ bên trong trình xử lý ngoại lệ và kiểm tra nó trước khi làm việc trên s.

flagBreak = false;
while True :

    if flagBreak : break

    if s :
        print s
    try :
        s = i.next()
    except StopIteration :
        flagBreak = true

print "done"

Nếu bạn đang ở trong một kịch bản mà bạn đang lặp trong khi tài nguyên không thể thực hiện được hoặc một cái gì đó tương tự ném ngoại lệ, bạn có thể sử dụng một cái gì đó như

import time

while True:
    try:
       f = open('some/path', 'r')
    except IOError:
       print('File could not be read. Retrying in 5 seconds')   
       time.sleep(5)
    else:
       break

Đối với tôi một vòng lặp while điển hình sẽ là một cái gì đó như thế này:

xBool = True
# A counter to force a condition (eg. yCount = some integer value)

while xBool:
    # set up the condition (eg. if yCount > 0):
        (Do something)
        yCount = yCount - 1
    else:
        # (condition is not met, set xBool False)
        xBool = False

Tôi cũng có thể bao gồm một for..loop trong vòng lặp while, nếu tình huống như vậy đảm bảo, cho việc lặp qua một tập hợp điều kiện khác.