Emulare un ciclo do-while in Python?

Devo emulare un ciclo do-while in un programma Python. Sfortunatamente, il seguente codice semplice non funziona:

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"

Invece di "1,2,3, done", stampa il seguente output:

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

Cosa posso fare per rilevare l'eccezione "stop iteration" e interrompere correttamente un ciclo while?

Un esempio del perché una cosa del genere può essere necessaria è mostrato sotto come pseudocodice.

Macchina a stati:

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

Non sono sicuro di quello che stai cercando di fare. È possibile implementare un ciclo do-while in questo modo:

while True:
  stuff()
  if fail_condition:
    break

O:

stuff()
while not fail_condition:
  stuff()

Cosa stai facendo cercando di usare un ciclo do while per stampare le cose nell'elenco? Perché non usare solo:

for i in l:
  print i
print "done"

Aggiornare:

Quindi hai un elenco di righe? E vuoi continuare a iterarlo? Che ne dite di:

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

Ti sembra qualcosa di simile a quello che vorresti? Con il tuo esempio di codice, sarebbe:

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

Ecco un modo molto semplice per emulare un ciclo do-while:

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

Le caratteristiche principali di un ciclo do-while sono che il corpo del ciclo viene sempre eseguito almeno una volta e che la condizione viene valutata nella parte inferiore del corpo del ciclo. La struttura di controllo mostrata qui realizza entrambe queste cose senza la necessità di eccezioni o dichiarazioni di rottura. Introduce una variabile booleana aggiuntiva.

Il mio codice di seguito potrebbe essere un'implementazione utile, evidenziando la differenza principale tra fare mentre vs mentre come ho capito.

Quindi, in questo caso, fai sempre il giro almeno una volta.

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

L'eccezione interromperà il ciclo, quindi potresti anche gestirlo al di fuori del ciclo.

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

Immagino che il problema con il tuo codice sia che il comportamento di breakinside exceptnon è definito. Di solito breaksale solo di un livello, quindi ad esempio breakinside tryva direttamente finally(se esiste) fuori da try, ma non fuori dal circuito.

PEP correlato: http://www.python.org/dev/peps/pep-3136
Domanda correlata: eliminazione di loop nidificati

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

->

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

Puoi fare una funzione:

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

Ma 1) È brutto. 2) La condizione dovrebbe essere una funzione con un parametro, che dovrebbe essere riempita da cose (è l'unica ragione per non usare il classico ciclo while).

Ecco una soluzione più folle di un modello diverso - usando le coroutine. Il codice è ancora molto simile, ma con un'importante differenza; non ci sono condizioni di uscita! La coroutine (catena di coroutine in realtà) si interrompe quando si interrompe l'alimentazione con i dati.

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)

Il codice sopra raccoglie tutti i token come tuple tokense suppongo che non ci siano differenze tra .append()e .add()nel codice originale.

Il modo in cui l'ho fatto è il seguente ...

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

Questa mi sembra la soluzione semplicistica, sono sorpreso di non averlo già visto qui. Questo ovviamente può anche essere invertito

while not condition:

eccetera.

per un ciclo do - while contenente istruzioni 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()

in alternativa, quando non è necessaria la clausola "finally"

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 rapido:

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

Usa così:

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

Perché non lo fai e basta

for s in l :
    print s
print "done"

?

Vedi se questo aiuta:

Imposta un flag all'interno del gestore eccezioni e controllalo prima di lavorare su s.

flagBreak = false;
while True :

    if flagBreak : break

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

print "done"

Se ti trovi in ​​uno scenario in cui esegui il loop mentre una risorsa non è disponibile o qualcosa di simile che genera un'eccezione, puoi utilizzare qualcosa di simile

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

Per me un tipico ciclo while sarà qualcosa del genere:

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

Potrei includere un for..loop anche nel ciclo while, se la situazione lo giustifica, per passare in rassegna un altro insieme di condizioni.