¿Emular un bucle do-while en Python?

Necesito emular un ciclo do-while en un programa Python. Desafortunadamente, el siguiente código directo no funciona:

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"

En lugar de "1,2,3, hecho", imprime el siguiente resultado:

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

¿Qué puedo hacer para detectar la excepción 'detener iteración' y romper un bucle while correctamente?

Un ejemplo de por qué tal cosa puede ser necesaria se muestra a continuación como pseudocódigo.

Máquina estatal:

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

No estoy seguro de lo que estás tratando de hacer. Puede implementar un ciclo do-while como este:

while True:
  stuff()
  if fail_condition:
    break

O:

stuff()
while not fail_condition:
  stuff()

¿Qué estás haciendo tratando de usar un bucle do while para imprimir las cosas en la lista? ¿Por qué no solo usar:

for i in l:
  print i
print "done"

Actualizar:

Entonces, ¿tienes una lista de líneas? ¿Y quieres seguir iterando? Qué tal si:

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

¿Te parece algo parecido a lo que quieres? Con su ejemplo de código, sería:

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

Aquí hay una manera muy simple de emular un ciclo do-while:

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

Las características clave de un ciclo do-while son que el cuerpo del ciclo siempre se ejecuta al menos una vez, y que la condición se evalúa en la parte inferior del cuerpo del ciclo. La estructura de control que se muestra aquí cumple ambas cosas sin necesidad de excepciones o declaraciones de interrupción. Introduce una variable booleana adicional.

Mi código a continuación podría ser una implementación útil, destacando la principal diferencia entre do-while vs mientras como yo lo entiendo

Entonces, en este caso, siempre pasa por el ciclo al menos una vez.

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

La excepción romperá el ciclo, por lo que también podría manejarlo fuera del ciclo.

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

Supongo que el problema con su código es que el comportamiento del breakinterior exceptno está definido. Por lo general, breaksolo sube un nivel, por ejemplo, el breakinterior tryva directamente a finally(si existe) un fuera del tryciclo, pero no fuera del ciclo.

PEP relacionada: http://www.python.org/dev/peps/pep-3136
Pregunta relacionada: ruptura de bucles anidados

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

->

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

Puedes hacer una función:

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

Pero 1) es feo. 2) La condición debe ser una función con un parámetro, que se supone que debe rellenarse con cosas (es la única razón para no usar el clásico bucle while).

Aquí hay una solución más loca de un patrón diferente: el uso de corutinas. El código sigue siendo muy similar, pero con una diferencia importante; no hay condiciones de salida en absoluto! La corutina (cadena de corutinas realmente) simplemente se detiene cuando deja de alimentarla con datos.

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)

El código anterior recopila todos los tokens como tuplas tokensy supongo que no hay diferencia entre .append()y .add()en el código original.

La forma en que hice esto es la siguiente ...

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

Esto me parece la solución simplista, me sorprende no haberlo visto aquí. Obviamente, esto también se puede invertir a

while not condition:

etc.

para un bucle do - while que contiene sentencias 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()

alternativamente, cuando no hay necesidad de la cláusula 'finalmente'

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 rápido:

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

Use así:

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

¿Por qué no lo haces?

for s in l :
    print s
print "done"

?

Vea si esto ayuda:

Establezca un indicador dentro del controlador de excepciones y verifíquelo antes de trabajar en el s.

flagBreak = false;
while True :

    if flagBreak : break

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

print "done"

Si se encuentra en un escenario en el que realiza un bucle mientras un recurso no está disponible o algo similar que arroja una excepción, podría usar algo como

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

Para mí, un bucle while típico será algo como esto:

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

Podría incluir un bucle for..loop dentro del bucle while también, si la situación lo amerita, para recorrer otro conjunto de condiciones.