有没有一种简单的方法来测试生成器是否没有项目，比如peek，hasNext，isEmpty，这些是什么？
你问题的简单答案：不，没有简单的方法。有很多解决方法。
真的不应该有一个简单的方法，因为生成器是什么：一种输出一系列值而不将序列保存在内存中的方法。所以没有向后遍历。
你可以编写一个has_next函数，或者甚至可以将它作为一个带有花式装饰器的方法打到生成器上，如果你愿意的话。
>>> gen = (i for i in [])
>>> next(gen)
Traceback (most recent call last):
File "<pyshell#43>", line 1, in <module>
next(gen)
StopIteration
在生成器结束时引发StopIteration，因为在你的情况下立即到达end，会引发异常。但通常你不应该检查下一个值是否存在。
你可以做的另一件事是：
>>> gen = (i for i in [])
>>> if not list(gen):
print('empty generator')
在我的情况下，我需要知道是否在我将其传递给函数之前填充了许多生成器，该函数合并了项目，即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"
我的特殊问题具有迭代物为空或具有完全相同数量的条目的属性。
刚刚落在这个线程上，意识到缺少一个非常简单易读的答案：
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]
如果你在使用发电机之前需要知道，那么不，没有简单的方法。如果你可以等到使用发电机后，有一个简单的方法：
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()
这是我用来继续返回迭代器的简单方法，同时检查是否产生了某些东西我只是检查循环是否运行：
n = 0
for key, value in iterator:
n+=1
yield key, value
if n == 0:
print ("nothing found in iterator)
break
这是一个包装生成器的简单装饰器，因此如果为空则返回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')
这很有用的一个例子是模板代码 - 即jinja2
{% if content_generator %}
<section>
<h4>Section title</h4>
{% for item in content_generator %}
{{ item }}
{% endfor %
</section>
{% endif %}
只需用itertools.chain包装生成器，将表示迭代结束的东西作为第二个可迭代，然后简单地检查它。
例如：
import itertools
g = some_iterable
eog = object()
wrap_g = itertools.chain(g, [eog])
现在剩下的就是检查我们附加到iterable末尾的值，当你读到它然后表示结束
for value in wrap_g:
if value == eog: # DING DING! We just found the last element of the iterable
pass # Do something
使用islice，你只需要检查第一次迭代，发现它是否为空。
来自itertools import islice
def isempty（iterable）： 返回列表（islice（iterable，1））== []
使用any（）怎么样？我用它与发电机一起工作正常。 Here有人解释了这一点
在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
此函数返回的迭代器将等同于作为参数传入的原始迭代器。
建议：
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.
由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)
我通过使用sum函数解决了它。请参阅下面的我与glob.iglob（返回生成器）一起使用的示例。
def isEmpty():
files = glob.iglob(search)
if sum(1 for _ in files):
return True
return False
*这可能不适用于HUGE生成器，但对于较小的列表应该可以很好地执行
一种简单的方法是使用next()的可选参数，如果生成器耗尽（或为空），则使用该参数。例如：
iterable = some_generator()
_exhausted = object()
if next(iterable, _exhausted) == _exhausted:
print('generator is empty')
编辑：更正了mehtunguh评论中指出的问题。
最好的方法，恕我直言，将避免一个特殊的测试。大多数情况下，使用发电机是测试：
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将包含生成的最后一个值。如果没有生成任何内容，它将是未定义的 - 除非您已经定义了变量。你可以查看thing的值，但这有点不可靠。相反，只需在块中设置一个标志，然后检查它：
if not thing_generated:
print "Avast, ye scurvy dog!"
next(generator, None) is not None
或者更换None，但无论你知道什么价值都不在您的发电机中。
编辑：是的，这将跳过生成器中的1项。但是，我经常检查生成器是否为空以用于验证目的，然后不要真正使用它。或者我做的事情如下：
def foo(self):
if next(self.my_generator(), None) is None:
raise Exception("Not initiated")
for x in self.my_generator():
...
也就是说，如果你的生成器来自一个函数，就像在generator()中一样。
我讨厌提供第二种解决方案，特别是我不会自己使用的解决方案，但是，如果你绝对必须这样做并且不使用生成器，就像在其他答案中一样：
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)
现在我真的不喜欢这个解决方案，因为我认为这不是生成器的使用方式。
抱歉显而易见的方法，但最好的办法是：
for item in my_generator:
print item
现在，您在使用它时检测到生成器为空。当然，如果生成器为空，则永远不会显示项目。
这可能与你的代码完全不符，但这就是生成器的成语：迭代，所以也许你可能会略微改变你的方法，或者根本不使用生成器。
我意识到这篇文章目前还有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)
当然，正如我相信很多评论员都会指出的那样，这很麻烦，只能在某些有限的情况下发挥作用（例如，发电机是无副作用的）。因人而异。
要查看生成器是否为空，您需要做的就是尝试获取下一个结果。当然，如果您还没有准备好使用该结果，那么您必须将其存储以便稍后再次返回。
这是一个包装类，可以添加到现有迭代器中以添加__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'
请注意，您可以随时检查空虚，而不仅仅是在迭代开始时。