是否有一种简单的方法来测试生成器是否没有项目，比如peek, hasNext, isEmpty之类的?
>>> gen = (i for i in [])
>>> next(gen)
Traceback (most recent call last):
File "<pyshell#43>", line 1, in <module>
next(gen)
StopIteration
在生成器结束时引发StopIteration，因为在您的情况下立即到达结束，因此引发异常。但通常你不应该检查下一个值是否存在。
你可以做的另一件事是:
>>> gen = (i for i in [])
>>> if not list(gen):
print('empty generator')
对于这种显而易见的方法，我很抱歉，但最好的方法是:
for item in my_generator:
print item
现在您已经检测到在使用生成器时它是空的。当然，如果生成器为空，项将永远不会显示。
这可能不完全适合您的代码，但这就是生成器的习惯用法:迭代，所以您可能会稍微改变您的方法，或者根本不使用生成器。
我讨厌提供第二个解决方案，特别是一个我自己不会使用的解决方案，但是，如果你绝对必须这样做，并且不消耗生成器，就像在其他答案中一样:
def do_something_with_item(item):
print item
empty_marker = object()
try:
first_item = my_generator.next()
except StopIteration:
print 'The generator was empty'
first_item = empty_marker
if first_item is not empty_marker:
do_something_with_item(first_item)
for item in my_generator:
do_something_with_item(item)
现在我真的不喜欢这个解决方案，因为我相信这不是生成器的使用方式。
恕我直言，最好的办法是避免特殊测试。大多数时候，使用生成器是一种测试:
thing_generated = False
# Nothing is lost here. if nothing is generated,
# the for block is not executed. Often, that's the only check
# you need to do. This can be done in the course of doing
# the work you wanted to do anyway on the generated output.
for thing in my_generator():
thing_generated = True
do_work(thing)
如果这还不够好，您仍然可以执行显式测试。此时，thing将包含最后生成的值。如果没有生成任何内容，它将是未定义的—除非您已经定义了该变量。你可以检查东西的价值，但那有点不可靠。相反，只需在块内设置一个标志，然后检查它:
if not thing_generated:
print "Avast, ye scurvy dog!"
对你的问题的简单回答是:不，没有简单的方法。有很多变通办法。
不应该有一种简单的方法，因为生成器是一种输出值序列而不将序列保存在内存中的方法。所以没有向后遍历。
你可以写一个has_next函数，或者甚至可以把它作为一个带有花哨装饰器的方法放在生成器上。
建议:
def peek(iterable):
try:
first = next(iterable)
except StopIteration:
return None
return first, itertools.chain([first], iterable)
用法:
res = peek(mysequence)
if res is None:
# sequence is empty. Do stuff.
else:
first, mysequence = res
# Do something with first, maybe?
# Then iterate over the sequence:
for element in mysequence:
# etc.
如果你在使用生成器之前需要知道，那么不，没有简单的方法。如果你可以等到你使用生成器之后，有一个简单的方法:
was_empty = True
for some_item in some_generator:
was_empty = False
do_something_with(some_item)
if was_empty:
handle_already_empty_generator_case()
一种简单的方法是使用next()的可选参数，如果生成器耗尽(或为空)，则使用该参数。例如:
_exhausted = object()
if next(some_generator, _exhausted) is _exhausted:
print('generator is empty')
我意识到这篇文章已经5年了，但我在寻找一种惯用的方法时发现了它，并没有看到我的解决方案发布出来。所以为了子孙后代:
import itertools
def get_generator():
"""
Returns (bool, generator) where bool is true iff the generator is not empty.
"""
gen = (i for i in [0, 1, 2, 3, 4])
a, b = itertools.tee(gen)
try:
a.next()
except StopIteration:
return (False, b)
return (True, b)
当然，我相信许多评论员会指出，这很俗气，而且只在某些有限的情况下有效(例如，生成器没有副作用)。YMMV。
要查看生成器是否为空，只需尝试获得下一个结果。当然，如果你还没有准备好使用这个结果，那么你必须存储它，以便以后再次返回。
下面是一个包装器类，可以添加到现有的迭代器中以添加__nonzero__测试，因此您可以通过简单的if查看生成器是否为空。它也可以变成一个装饰器。
class GenWrapper:
def __init__(self, iter):
self.source = iter
self.stored = False
def __iter__(self):
return self
def __nonzero__(self):
if self.stored:
return True
try:
self.value = next(self.source)
self.stored = True
except StopIteration:
return False
return True
def __next__(self): # use "next" (without underscores) for Python 2.x
if self.stored:
self.stored = False
return self.value
return next(self.source)
下面是你如何使用它:
with open(filename, 'r') as f:
f = GenWrapper(f)
if f:
print 'Not empty'
else:
print 'Empty'
请注意，您可以在任何时候检查空，而不仅仅是在迭代的开始。
Quick-dirty解决方案:
next(generator, None)不是None
或者将None替换为任何你知道不在生成器中的值。
编辑:是的，这将跳过生成器中的一项。然而，有时我只是出于验证目的检查生成器是否为空，然后并不真正使用它。否则我就会这样做:
def foo(self):
if next(self.my_generator(), None) is None:
raise Exception("Not initiated")
for x in self.my_generator():
...
也就是说，如果您的生成器来自一个函数，如my_generator()，则此方法有效。
我用求和函数解出来了。请参阅下面我使用glob的示例。Iglob(返回一个生成器)。
def isEmpty():
files = glob.iglob(search)
if sum(1 for _ in files):
return True
return False
*这可能不适用于巨大的生成器，但对于较小的列表应该表现得很好
简单地用itertools包装生成器。Chain，在第二个可迭代对象中放入一个表示可迭代对象的结尾的东西，然后简单地检查它。
Ex:
import itertools
g = some_iterable
eog = object()
wrap_g = itertools.chain(g, [eog])
现在剩下的就是检查我们附加到可迭代对象末尾的值，当你读取它时，它将表示结束
for value in wrap_g:
if value == eog: # DING DING! We just found the last element of the iterable
pass # Do something
下面是一个包装生成器的简单装饰器，因此如果为空，它将返回None。如果您的代码需要知道生成器在循环遍历之前是否会生成任何东西，那么这可能很有用。
def generator_or_none(func):
"""Wrap a generator function, returning None if it's empty. """
def inner(*args, **kwargs):
# peek at the first item; return None if it doesn't exist
try:
next(func(*args, **kwargs))
except StopIteration:
return None
# return original generator otherwise first item will be missing
return func(*args, **kwargs)
return inner
用法:
import random
@generator_or_none
def random_length_generator():
for i in range(random.randint(0, 10)):
yield i
gen = random_length_generator()
if gen is None:
print('Generator is empty')
一个有用的例子是在模板代码中—即jinj2
{% if content_generator %}
<section>
<h4>Section title</h4>
{% for item in content_generator %}
{{ item }}
{% endfor %
</section>
{% endif %}
在我的例子中，我需要知道在我将一组生成器传递给一个函数之前，它是否已经填充，该函数合并了这些项，即zip(…)。解决方案与公认的答案相似，但又有足够的不同:
定义:
def has_items(iterable):
try:
return True, itertools.chain([next(iterable)], iterable)
except StopIteration:
return False, []
用法:
def filter_empty(iterables):
for iterable in iterables:
itr_has_items, iterable = has_items(iterable)
if itr_has_items:
yield iterable
def merge_iterables(iterables):
populated_iterables = filter_empty(iterables)
for items in zip(*populated_iterables):
# Use items for each "slice"
我的特定问题具有这样的属性，即可迭代对象要么为空，要么具有完全相同数量的条目。
使用cytoolz中的peek函数。
from cytoolz import peek
from typing import Tuple, Iterable
def is_empty_iterator(g: Iterable) -> Tuple[Iterable, bool]:
try:
_, g = peek(g)
return g, False
except StopIteration:
return g, True
此函数返回的迭代器将等效于作为参数传入的原始迭代器。
在Mark Ransom的提示下，这里有一个类，你可以使用它来包装任何迭代器，这样你就可以提前查看，将值推回流并检查是否为空。这是一个简单的想法和简单的实现，我发现在过去非常方便。
class Pushable:
def __init__(self, iter):
self.source = iter
self.stored = []
def __iter__(self):
return self
def __bool__(self):
if self.stored:
return True
try:
self.stored.append(next(self.source))
except StopIteration:
return False
return True
def push(self, value):
self.stored.append(value)
def peek(self):
if self.stored:
return self.stored[-1]
value = next(self.source)
self.stored.append(value)
return value
def __next__(self):
if self.stored:
return self.stored.pop()
return next(self.source)
刚刚读到这篇文章，意识到缺少一个非常简单易懂的答案:
def is_empty(generator):
for item in generator:
return False
return True
如果我们不打算使用任何项，那么我们需要将第一项重新注入生成器:
def is_empty_no_side_effects(generator):
try:
item = next(generator)
def my_generator():
yield item
yield from generator
return my_generator(), False
except StopIteration:
return (_ for _ in []), True
例子:
>>> g=(i for i in [])
>>> g,empty=is_empty_no_side_effects(g)
>>> empty
True
>>> g=(i for i in range(10))
>>> g,empty=is_empty_no_side_effects(g)
>>> empty
False
>>> list(g)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
我发现只有这个解决方案也适用于空迭代。
def is_generator_empty(generator):
a, b = itertools.tee(generator)
try:
next(a)
except StopIteration:
return True, b
return False, b
is_empty, generator = is_generator_empty(generator)
或者如果你不想使用异常来尝试使用
def is_generator_empty(generator):
a, b = itertools.tee(generator)
for item in a:
return False, b
return True, b
is_empty, generator = is_generator_empty(generator)
在标记的解决方案中，您不能将其用于空生成器，如
def get_empty_generator():
while False:
yield None
generator = get_empty_generator()
这是一个古老的问题，但之前没有人提出过，下面是这个问题:
for _ in generator:
break
else:
print('Empty')
你可以在这里阅读更多
为了表达我的“2美分”，我将描述一下我的经历:
我有一个生成器，我需要用itertools切片它。分成小发电机。然后检查我的子生成器是否为空，我只是将它们转换/消耗到一个小列表中，然后检查列表是否为空。
例如:
from itertools import islice
def generator(max_yield=10):
a = 0
while True:
a += 1
if a > max_yield:
raise StopIteration()
yield a
tg = generator()
label = 1
while True:
itg = list(islice(tg, 3))
if not itg: # <-- I check if the list is empty or not
break
for i in itg:
print(f'#{label} - {i}')
label += 1
输出:
#1 - 1
#1 - 2
#1 - 3
#2 - 4
#2 - 5
#2 - 6
#3 - 7
#3 - 8
#3 - 9
#4 - 10
也许这不是最好的方法，主要是因为它会消耗生成器，但对我来说却是可行的。
在遍历生成器之前检查生成器符合LBYL编码风格。另一种方法(EAFP)是遍历它，然后检查它是否为空。
is_empty = True
for item in generator:
is_empty = False
do_something(item)
if is_empty:
print('Generator is empty')
这种方法也可以很好地处理无限生成器。
