Eine Do-While-Schleife in Python emulieren?

Ich muss eine Do-While-Schleife in einem Python-Programm emulieren. Leider funktioniert der folgende einfache Code nicht:

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"

Anstelle von "1,2,3, erledigt" wird die folgende Ausgabe gedruckt:

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

Was kann ich tun, um die Ausnahme "Iteration stoppen" abzufangen und eine while-Schleife ordnungsgemäß zu unterbrechen?

Ein Beispiel dafür, warum so etwas benötigt wird, ist unten als Pseudocode gezeigt.

Zustandsmaschine:

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

Ich bin mir nicht sicher, was Sie versuchen zu tun. Sie können eine do-while-Schleife wie folgt implementieren:

while True:
  stuff()
  if fail_condition:
    break

Oder:

stuff()
while not fail_condition:
  stuff()

Was machst du, wenn du versuchst, eine do while-Schleife zu verwenden, um das Zeug in der Liste zu drucken? Warum nicht einfach verwenden:

for i in l:
  print i
print "done"

Aktualisieren:

Haben Sie eine Liste mit Zeilen? Und Sie möchten es weiter durchlaufen? Wie wäre es mit:

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

Scheint das etwas in der Nähe von dem zu sein, was Sie wollen würden? Mit Ihrem Codebeispiel wäre es:

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

Hier ist eine sehr einfache Möglichkeit, eine Do-While-Schleife zu emulieren:

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

Die Hauptmerkmale einer do-while-Schleife sind, dass der Schleifenkörper immer mindestens einmal ausgeführt wird und dass die Bedingung am unteren Rand des Schleifenkörpers ausgewertet wird. Die hier gezeigte Kontrollstruktur führt beide aus, ohne dass Ausnahmen oder break-Anweisungen erforderlich sind. Es wird eine zusätzliche boolesche Variable eingeführt.

Mein Code unten könnte eine nützliche Implementierung sein, die den Hauptunterschied zwischen hervorhebt do-while vs. während so wie ich es verstehe.

In diesem Fall durchlaufen Sie die Schleife also immer mindestens einmal.

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

Eine Ausnahme unterbricht die Schleife, sodass Sie sie auch außerhalb der Schleife behandeln können.

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

Ich denke, dass das Problem mit Ihrem Code darin besteht, dass das Verhalten von breakinnen exceptnicht definiert ist. Im Allgemeinen breakgeht es nur eine Ebene nach oben, also geht zB breakinnen trydirekt zu finally(wenn es existiert) einem aus der try, aber nicht aus der Schleife.

Verwandte PEP: http://www.python.org/dev/peps/pep-3136
Verwandte Frage: Ausbrechen verschachtelter Schleifen

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

->

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

Sie können eine Funktion ausführen:

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

Aber 1) Es ist hässlich. 2) Bedingung sollte eine Funktion mit einem Parameter sein, die mit Dingen gefüllt sein soll (dies ist der einzige Grund , die klassische while-Schleife nicht zu verwenden.)

Hier ist eine verrücktere Lösung eines anderen Musters - unter Verwendung von Coroutinen. Der Code ist immer noch sehr ähnlich, aber mit einem wichtigen Unterschied; Es gibt überhaupt keine Ausstiegsbedingungen! Die Coroutine (Kette von Coroutinen wirklich) stoppt nur, wenn Sie aufhören, sie mit Daten zu füttern.

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)

Der obige Code sammelt alle Token als Tupel tokensund ich gehe davon aus, dass es keinen Unterschied zwischen .append()und .add()im Originalcode gibt.

Ich habe das so gemacht ...

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

Dies scheint mir die vereinfachte Lösung zu sein. Ich bin überrascht, dass ich sie hier noch nicht gesehen habe. Dies kann natürlich auch umgekehrt werden

while not condition:

usw.

für eine do - while - Schleife mit try - Anweisungen

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

alternativ, wenn die 'finally'-Klausel nicht erforderlich ist

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

Schneller Hack:

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

Verwenden Sie wie folgt:

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

Warum tust du es nicht einfach?

for s in l :
    print s
print "done"

?

Sehen Sie, ob dies hilft:

Setzen Sie ein Flag im Exception-Handler und überprüfen Sie es, bevor Sie am s arbeiten.

flagBreak = false;
while True :

    if flagBreak : break

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

print "done"

Wenn Sie sich in einem Szenario befinden, in dem Sie eine Schleife ausführen, während eine Ressource nicht verfügbar ist, oder etwas Ähnliches, das eine Ausnahme auslöst, können Sie Folgendes verwenden

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

Für mich ist eine typische while-Schleife ungefähr so:

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

Ich könnte auch eine for..- Schleife in die while-Schleife aufnehmen, wenn die Situation dies erfordert, um eine andere Bedingung zu durchlaufen.