Python'da bir do-while döngüsü taklit ediliyor mu?

Bir Python programında bir do-while döngüsü taklit etmek gerekiyor. Ne yazık ki, aşağıdaki basit kod çalışmaz:

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, tamamlandı" yerine, aşağıdaki çıktıyı yazdırır:

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

'Stop iteration' istisnasını yakalamak ve bir while döngüsünü düzgün bir şekilde kırmak için ne yapabilirim?

Böyle bir şeye neden ihtiyaç duyulabileceğinin bir örneği aşağıda sahte kod olarak gösterilmiştir.

Durum makinesi:

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

Ne yapmaya çalıştığından emin değilim. Aşağıdaki gibi bir do-while döngüsü uygulayabilirsiniz:

while True:
  stuff()
  if fail_condition:
    break

Veya:

stuff()
while not fail_condition:
  stuff()

Listedeki öğeleri yazdırmak için bir do while döngüsü kullanmaya ne yapıyorsunuz? Neden sadece kullanmıyorsunuz:

for i in l:
  print i
print "done"

Güncelleme:

Hatların bir listesi var mı? Ve yinelemeyi devam ettirmek mi istiyorsun? Nasıl olur:

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

Bu, istediğiniz şeye yakın bir şey gibi mi görünüyor? Kod örneğinizle şöyle olur:

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

İşte bir do-while döngüsünü taklit etmenin çok basit bir yolu:

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

Bir do-while döngüsünün temel özellikleri, döngü gövdesinin her zaman en az bir kez yürütülmesi ve koşulun döngü gövdesinin altında değerlendirilmesidir. Burada gösterilen kontrol yapısı, istisna veya kesme ifadesine gerek kalmadan her ikisini de gerçekleştirir. Bir ekstra Boole değişkeni ekler.

Aşağıdaki kodum, arasındaki temel farkı vurgulayan yararlı bir uygulama olabilir yaparken vs süre anladığım kadarıyla.

Bu durumda, her zaman döngüden en az bir kez geçersiniz.

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

İstisna döngüyü kıracaktır, böylece döngünün dışında da işleyebilirsiniz.

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

Kod ile sorun breakiç davranış excepttanımlanmamış olmasıdır sanırım . Genellikle breakbu nedenle örneğin, sadece bir seviye yukarı gider breakiçeride trydoğrudan gider finally(varsa) yetersiz try, fakat döngünün dışında.

İlgili PEP: http://www.python.org/dev/peps/pep-3136
İlgili soru: İç içe döngülerin kopması

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

->

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

Bir işlev yapabilirsiniz:

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

Ama 1) Çirkin. 2) Durum şeyler tarafından doldurulacak gerekiyordu bir parametresi olan bir işlev olmalıdır (bu tek nedeni değil klasik while döngüsü kullanmak.)

İşte farklı bir modelin daha çılgın bir çözümü - coroutines kullanarak. Kod hala çok benzer, ancak önemli bir fark var; hiç çıkış koşulu yok! Koroutin (gerçekten koroutin zinciri) veri ile beslemeyi bıraktığınızda durur.

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)

Yukarıdaki kod, tüm kodları tuples olarak toplar ve orijinal kod tokensarasında .append()ve .add()orijinal kodda hiçbir fark olmadığını varsayarım .

Bunu yapma şeklim şöyle ...

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

Bu bana basit bir çözüm gibi geliyor, burada daha önce görmediğime şaşırdım. Bu açıkça tersine çevrilebilir

while not condition:

vb.

try ifadeleri içeren bir do - while döngüsü için

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

alternatif olarak, 'nihayet' maddesine gerek olmadığında

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

Hızlı kesmek:

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

Şöyle kullanın:

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

Neden sadece yapmıyorsun

for s in l :
    print s
print "done"

?

Bunun yardımcı olup olmadığına bakın:

İstisna işleyicinin içine bir bayrak yerleştirin ve s üzerinde çalışmadan önce kontrol edin.

flagBreak = false;
while True :

    if flagBreak : break

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

print "done"

Bir kaynak uygun olmadığında veya istisna oluşturan benzer bir şeyde döngü yaptığınız bir senaryodaysanız, şöyle bir şey kullanabilirsiniz:

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

Benim için tipik bir while döngüsü şöyle olacak:

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

Eğer durum çok garanti, eğer başka bir koşul kümesi döngü için ise while döngüsü içinde bir for..loop içerebilir .