嘗試循環空迭代時採取行動的習慣方式

Question

假設我正在循環一個迭代器，並且想要在迭代器爲空時採取一些操作。我能想到的做到這一點，兩個最好的方法是：

for i in iterable: 
    # do_something 
if not iterable: 
    # do_something_else 

和

empty = True 
for i in iterable: 
    empty = False 
    # do_something 
if empty: 
    # do_something_else 

首先依賴於可迭代是一個集合（所以沒用當迭代被傳遞到了函數/方法，其中循環是），第二次設置每循環看起來很醜陋的每個循環。

有沒有另一種方法，我失蹤或是第二個選擇最好？這將是非常酷，如果有一些條款，我可以添加到循環語句，將爲我處理這很像else使not_found旗幟消失。

---

我不是在尋找聰明的黑客。

我不是在尋找涉及大量的代碼

我要尋找一個簡單的語言功能的解決方案。 我在尋找一個明確和pythonic方式來迭代一個迭代，並採取一些行動，如果可迭代是空的，任何有經驗的Python程序員都會明白。如果我可以做到這一點，而不需要在每次迭代中設置一個標誌，那就太棒了。 如果沒有這樣的簡單習語，那麼就忘了它。

Answer 1

我覺得這個最乾淨的方式做到這一點：

# first try with exceptions 
def nonempty(iter): 
    """ returns `iter` if iter is not empty, else raises TypeError """ 
    try: 
     first = next(iter) 
    except StopIteration: 
     raise TypeError("Emtpy Iterator") 
    yield first 
    for item in iter: 
     yield item 


# a version without exceptions. Seems nicer: 
def isempty(iter): 
    """ returns `(True,())` if `iter` if is empty else `(False, iter)` 
     Don't use the original iterator! """ 
    try: 
     first = next(iter) 
    except StopIteration: 
     return True,() 
    else: 
     def iterator(): 
      yield first 
      for item in iter: 
       yield item 
     return False, iterator() 



for x in ([],[1]): 
    # first version 
    try: 
     list(nonempty(iter(x))) # trying to consume a empty iterator raises 
    except TypeError: 
     print x, "is empty" 
    else: 
     print x, "is not empty" 

    # with isempty 
    empty, it = isempty(iter(x)) 
    print x, "is", ("empty" if empty else "not empty") 

Answer 2

這是相當的hackish，但可以刪除i，然後檢查它是否在循環後存在（如果不是，則循環永遠不會發生）：

try: 
    del i 
except NameException: pass 

for i in iterable: 
    do_something(i) 

try: 
    del i 
except NameException: 
    do_something_else() 

我認爲這可能比只用一個標誌醜陋雖然

Answer 3

更新2

我喜歡Odomontois' answer。恕我直言，它比我下面寫的更適合這個問題。

更新

（讀取OP的評論和編輯問題之後）你可以做到這一點。請看下圖：

def with_divisible(n, a, b, f): 
it = (i for i in xrange(a, b) if not i % n) 
for i in wrapper(it): 
    f(i) 

>>> with_divisible(1, 1, 1, lambda x: x) 
Traceback (most recent call last): 
    File "<pyshell#55>", line 1, in <module> 
    with_divisible(1, 1, 1, lambda x: x) 
    File "<pyshell#54>", line 3, in with_divisible 
    for i in wrapper(it): 
    File "<pyshell#46>", line 4, in wrapper 
    raise EmptyIterableException("Empty") 
EmptyIterableException: Empty 

>>> with_divisible(7, 1, 21, lambda x: x) 
7 
14 
...Snipped... 
    raise EmptyIterableException("Empty") 
EmptyIterableException: Empty 

原來的答案

有趣的問題。我做了一些實驗，並與下面上來：

class EmptyIterableException(Exception): 
    pass 

def wrapper(iterable): 
    for each in iterable: 
     yield each 
    raise EmptyIterableException("Empty") 

try: 
    for each in wrapper(iterable): 
     do_something(each) 
except EmptyIterableException, e: 
    do_something_else() 

Answer 4

什麼扭轉「如果」和「對」：

if iterable: 
    for i in iterable: 
     do_something(i) 
else: 
    do_something_else() 

OK，這也不行！

這裏有一個其他的解決方案：http://code.activestate.com/recipes/413614-testing-for-an-empty-iterator/

Answer 5

if not map(do_something_callable,iterable) : 
    # do something else 

Answer 6

這是Michael Mrozek組合的和FM的答案：

def with_divisible(n, a, b, f): 
    '''apply f to every integer x such that n divides x and a <= x < b''' 
    it = (i for i in xrange(a, b) if not i % n) 
    for i in it: 
     f(i) 
    try: i   # test if `it` was empty 
    except NameError: print('do something else') 

def g(i): 
    print i, 

with_divisible(3, 1, 10, g) # Prints 3 6 9. 
with_divisible(33, 1, 10, g) # Prints "do something else" 

Answer 7

發電機有'gi _frame'屬性，一旦生成器耗盡，該屬性就爲None，但只有在StopIteration被引發之後。如果這是可以接受的，這裏的東西，你可以嘗試：

import types 

def do(x, f, f_empty): 
    if type(x) == types.GeneratorType: 
     # generators have a 'gi_frame' property, 
     # which is None once the generator is exhausted 
     if x.gi_frame: 
      # not empty 
      return f(x) 
     return f_empty(x) 
    if x: 
     return f(x) 
    return f_empty(x) 

def nempty(lst): 
    print lst, 'not empty' 

def empty(lst): 
    print 'Twas empty!' 

# lists 
do([2,3,4], nempty, empty) 
do([], nempty, empty) 

# generators 
do((i for i in range(5)), nempty, empty) 
gen = (i for i in range(1)) 
gen.next() 
try: 
    gen.next() 
except StopIteration: 
    pass 
do(gen, nempty, empty) 

Answer 8

前進的一般方式，如果一個迭代是被消耗之前部分檢查是使用itertools.tee。通過這種方式，我們可以有兩個迭代器副本，並檢查一個虛擬空間，同時仍然從一開始就消耗另一個副本。

from itertools import tee 
it1, it2 = tee(iterable) 
try: 
    it1.next() 
    for i in it2: 
     do_some_action(i) #iterator is not empty 
except StopIteration: 
    do_empty_action() #iterator is empty 

的StopIteration例外勢必會調用it1.next()的結果，提出了循環內弗魯姆將終止循環任何StopIteration例外。

編輯：對於那些誰不喜歡這樣的例外，islice可以用來建立一個單一的步驟循環：

from itertools import tee, islice 
it1, it2 = tee(iterable) 
for _ in islice(it1, 1): 
    #loop entered if iterator is not empty 
    for i in it2: 
     do_some_action(i) 
    break #if loop entered don't execute the else section 
else: 
    do_empty_action() 

我個人比較喜歡的第一個樣式。因人而異。