Емуляція циклу виконання часу в Python?

Мені потрібно емулювати цикл виконання часу в програмі Python. На жаль, наступний прямий код не працює:

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"

Замість "1,2,3, зроблено", він друкує такий вихід:

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

Що я можу зробити, щоб знайти виняток "зупинити ітерацію" та правильно перервати цикл?

Приклад того, чому може знадобитися таке, показаний нижче як псевдокод.

Державна машина:

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

Я не впевнений, що ти намагаєшся зробити. Ви можете реалізувати цикл "час виконання" таким чином:

while True:
  stuff()
  if fail_condition:
    break

Або:

stuff()
while not fail_condition:
  stuff()

Що ви робите, намагаючись використати цикл do while для друку матеріалів у списку? Чому б просто не використовувати:

for i in l:
  print i
print "done"

Оновлення:

Отже, у вас є список рядків? І ви хочете продовжувати це повторювати? Як щодо:

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

Це здається чимось близьким до того, що ви хотіли б? З прикладом коду, це:

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

Ось дуже простий спосіб емуляції циклу виконання часу:

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

Ключові особливості циклу виконання часу - те, що тіло циклу завжди виконується принаймні один раз і що умова оцінюється внизу тіла циклу. Структура управління, показана тут, виконує обидва ці пункти, не потребуючи винятків або заяв про розриви. Це вводить одну додаткову булеву змінну.

Мій код нижче може бути корисною реалізацією, підкреслюючи головну різницю між робити час проти поки як я це розумію.

Тож у цьому випадку ви завжди хоч раз проходите цикл.

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

Виняток порушить цикл, тож ви можете також обробити його поза циклом.

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

Я думаю, що проблема з вашим кодом полягає в тому, що поведінка breakвсередині exceptне визначена. Зазвичай breakйде лише на один рівень вгору, наприклад, breakвсерединіtry йде безпосередньо до finally(якщо він існує) поза try, але не з циклу.

Пов'язаний PEP: http://www.python.org/dev/peps/pep-3136
Пов'язане запитання: Вихід із вкладених циклів

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

->

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

Ви можете виконувати функцію:

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

Але 1) Це некрасиво. 2) Умова повинна бути функцією з одним параметром, який повинен бути заповнений начинками (це єдина причина не використовувати класичний цикл while.)

Ось божевільне рішення іншого малюнка - використання корутин. Код все ще дуже схожий, але з однією важливою різницею; взагалі немає умов виходу! Співпраця (ланцюжок спільнот дійсно) просто припиняється, коли ви перестаєте подавати її даними.

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)

Код вище збирає всі лексеми як кортежі, tokensі я припускаю, що немає різниці між оригінальним кодом .append()та .add()в ньому.

Я це робив так:

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

Мені це здається спрощеним рішенням, я здивований, що я його ще тут не бачив. Очевидно, це також можна перевернути

while not condition:

тощо.

для циклу "циклу", який містить операції спробу

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

альтернативно, коли немає необхідності в пункті "нарешті"

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

Швидкий злом:

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

Використовуйте так:

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

Чому ти просто не робиш

for s in l :
    print s
print "done"

?

Подивіться, чи це допомагає:

Встановіть прапор всередині обробника винятків і перевірте його, перш ніж працювати над s.

flagBreak = false;
while True :

    if flagBreak : break

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

print "done"

Якщо у вас є сценарій, коли ви займаєтеся циклами, коли ресурс є недійсним або щось подібне, що кидає виняток, ви можете використовувати щось на зразок

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

Для мене типовим циклом while буде щось подібне:

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

Я можу включити for..loop також в циклі while, якщо ситуація цього вимагає, для перегляду іншого набору умов.