Émuler une boucle do-while en Python?

J'ai besoin d'émuler une boucle do-while dans un programme Python. Malheureusement, le code simple suivant ne fonctionne pas:

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"

Au lieu de "1,2,3, terminé", il imprime la sortie suivante:

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

Que puis-je faire pour intercepter l'exception «stop itération» et rompre correctement une boucle while?

Un exemple de la raison pour laquelle une telle chose peut être nécessaire est illustré ci-dessous sous le nom de pseudocode.

État machine:

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

Je ne sais pas trop ce que vous essayez de faire. Vous pouvez implémenter une boucle do-while comme ceci:

while True:
  stuff()
  if fail_condition:
    break

Ou:

stuff()
while not fail_condition:
  stuff()

Que faites-vous en essayant d'utiliser une boucle do while pour imprimer le contenu de la liste? Pourquoi ne pas simplement utiliser:

for i in l:
  print i
print "done"

Mise à jour:

Avez-vous une liste de lignes? Et vous voulez continuer à le parcourir? Que diriez-vous:

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

Cela semble-t-il quelque chose de proche de ce que vous voudriez? Avec votre exemple de code, ce serait:

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

Voici un moyen très simple d'émuler une boucle do-while:

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

Les principales caractéristiques d'une boucle do-while sont que le corps de la boucle s'exécute toujours au moins une fois et que la condition est évaluée au bas du corps de la boucle. La structure de contrôle montrée ici accomplit ces deux opérations sans avoir besoin d'exceptions ou d'instructions break. Il introduit une variable booléenne supplémentaire.

Mon code ci-dessous pourrait être une implémentation utile, soulignant la principale différence entre faire pendant contre tandis que si je comprends bien.

Donc, dans ce cas, vous parcourez toujours la boucle au moins une fois.

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

L'exception rompra la boucle, vous pourriez donc aussi bien la gérer en dehors de la boucle.

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

Je suppose que le problème avec votre code est que le comportement de l' breakintérieur exceptn'est pas défini. breakNe monte généralement que d'un niveau, donc par exemple, l' breakintérieur tryva directement finally(s'il existe) à une trysortie de la boucle, mais pas à une sortie de boucle.

PEP connexe: http://www.python.org/dev/peps/pep-3136
Question connexe: rupture des boucles imbriquées

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

->

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

Vous pouvez faire une fonction:

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

Mais 1) c'est moche. 2) La condition devrait être une fonction avec un paramètre, censée être remplie par des trucs (c'est la seule raison de ne pas utiliser la boucle while classique.)

Voici une solution plus folle d'un modèle différent - en utilisant des coroutines. Le code est toujours très similaire, mais avec une différence importante; il n'y a aucune condition de sortie! La coroutine (chaîne de coroutines vraiment) s'arrête juste lorsque vous arrêtez de la nourrir avec des données.

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)

Le code ci-dessus recueille tous les jetons sous forme de tuples dans tokenset je suppose qu'il n'y a aucune différence entre .append()et .add()dans le code d'origine.

La façon dont je l'ai fait est la suivante ...

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

Cela me semble être la solution simpliste, je suis surpris de ne pas l'avoir déjà vu ici. Cela peut évidemment aussi être inversé pour

while not condition:

etc.

pour une boucle do - while contenant des instructions 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()

alternativement, quand il n'y a pas besoin de la clause «enfin»

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

Piratage rapide:

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

Utilisez comme ça:

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

Pourquoi ne fais-tu pas

for s in l :
    print s
print "done"

?

Voyez si cela aide:

Définissez un indicateur à l'intérieur du gestionnaire d'exceptions et vérifiez-le avant de travailler sur le s.

flagBreak = false;
while True :

    if flagBreak : break

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

print "done"

Si vous êtes dans un scénario où vous effectuez une boucle alors qu'une ressource est indisponible ou quelque chose de similaire qui lève une exception, vous pouvez utiliser quelque chose comme

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

Pour moi, une boucle while typique sera quelque chose comme ceci:

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

Je pourrais également inclure un for..loop dans la boucle while, si la situation le justifie, pour parcourir une autre série de conditions.