Emulować pętlę „do-while” w Pythonie?

Muszę emulować pętlę „do-while” w programie Python. Niestety następujący prosty kod nie działa:

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"

Zamiast „1,2,3, gotowe” wypisuje następujące dane wyjściowe:

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

Co mogę zrobić, aby złapać wyjątek „zatrzymaj iterację” i przerwać pętlę while?

Przykład, dlaczego taka rzecz może być potrzebna, pokazano poniżej jako pseudokod.

Maszyna stanowa:

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

Nie jestem pewien, co próbujesz zrobić. Możesz zaimplementować następującą pętlę:

while True:
  stuff()
  if fail_condition:
    break

Lub:

stuff()
while not fail_condition:
  stuff()

Co robisz, próbując użyć pętli do while, aby wydrukować rzeczy z listy? Dlaczego nie po prostu użyć:

for i in l:
  print i
print "done"

Aktualizacja:

Czy masz listę linii? I chcesz to powtarzać? Co powiesz na:

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

Czy to wydaje się być czymś zbliżonym do tego, czego byś chciał? W twoim przykładzie kodu byłoby to:

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

Oto bardzo prosty sposób emulacji pętli „do-while”:

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

Kluczowe cechy pętli „do-while” polegają na tym, że ciało pętli zawsze wykonuje się co najmniej raz, a warunek jest oceniany na dole ciała pętli. Przedstawiona tutaj struktura kontrolna realizuje oba z nich bez potrzeby wyjątków lub instrukcji break. Wprowadza jedną dodatkową zmienną logiczną.

Mój kod poniżej może być użyteczną implementacją, podkreślając główną różnicę między nimi robić vs podczas tak jak rozumiem.

Tak więc w tym przypadku zawsze przechodzisz przez pętlę przynajmniej raz.

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

Wyjątek spowoduje przerwanie pętli, więc równie dobrze możesz obsługiwać ją poza pętlą.

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

Myślę, że problem z twoim kodem polega na tym, że zachowanie breakwewnątrz exceptnie jest zdefiniowane. Zasadniczo breakidzie tylko o jeden poziom wyżej, więc np. breakWnętrze tryidzie bezpośrednio do finally(jeśli istnieje) poza try, ale nie poza pętlę.

Powiązane PEP: http://www.python.org/dev/peps/pep-3136
Podobne pytanie: Wyjście z zagnieżdżonych pętli

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

->

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

Możesz wykonać funkcję:

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

Ale 1) To brzydkie. 2) Warunek powinien być funkcją z jednym parametrem, który powinien być wypełniony przez rzeczy (to jedyny powód, dla którego nie należy używać klasycznej pętli while).

Oto bardziej szalone rozwiązanie o innym wzorze - wykorzystujące coroutines. Kod jest nadal bardzo podobny, ale z jedną ważną różnicą; w ogóle nie ma warunków wyjścia! Coroutine (tak naprawdę łańcuch coroutines) po prostu przestaje, kiedy przestajesz karmić go danymi.

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)

Powyższy kod zbiera wszystkie żetony jak w krotki tokensi zakładam nie ma różnicy pomiędzy .append()i .add()w oryginalnym kodzie.

Sposób, w jaki to zrobiłem, jest następujący ...

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

Wydaje mi się, że to proste rozwiązanie, jestem zaskoczony, że jeszcze go tu nie widziałem. Można to oczywiście również odwrócić

while not condition:

itp.

dla pętli do - while zawierającej instrukcje 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()

alternatywnie, gdy nie ma potrzeby stosowania klauzuli „w końcu”

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

Szybki hack:

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

Użyj tak:

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

Dlaczego po prostu nie zrobisz

for s in l :
    print s
print "done"

?

Sprawdź, czy to pomoże:

Ustaw flagę w module obsługi wyjątków i sprawdź ją przed rozpoczęciem pracy na s.

flagBreak = false;
while True :

    if flagBreak : break

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

print "done"

Jeśli masz scenariusz, w którym zapętlasz się, gdy zasób jest niedostępny lub coś podobnego, co rzuca wyjątek, możesz użyć czegoś takiego

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

Dla mnie typowa pętla while będzie taka:

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

Mógłbym również włączyć pętlę for .. w pętli while, jeśli sytuacja tego wymaga, do zapętlenia innego zestawu warunków.