196

有没有一种简单的方法来测试生成器是否没有项目，比如peek, hasNext, isEmpty, 类似的东西？

4

23 回答 23

130

建议：

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.
于 2009-03-19T22:01:31.527 回答
65

您的问题的简单答案：不，没有简单的方法。有很多解决方法。

真的不应该有一个简单的方法，因为生成器是：一种输出一系列值而不将序列保存在内存中的方法。所以没有反向遍历。

你可以编写一个 has_next 函数，或者如果你愿意的话，甚至可以将它作为一个带有精美装饰器的方法放在生成器上。

于 2009-03-19T16:25:12.830 回答
42

一种简单的方法是使用next()的可选参数，如果生成器耗尽（或为空），则使用该参数。例如：

_exhausted  = object()

if next(some_generator, _exhausted) is _exhausted:
    print('generator is empty')
于 2014-02-03T10:41:42.023 回答
22

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

于 2016-05-22T14:58:54.963 回答
16

恕我直言，最好的方法是避免特殊测试。大多数时候，使用生成器是一种测试：

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!"
于 2009-03-19T12:08:48.183 回答
8

我讨厌提供第二种解决方案，尤其是我自己不会使用的解决方案，但是，如果您绝对必须这样做并且不消耗生成器，就像其他答案一样：

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)

现在我真的不喜欢这个解决方案，因为我相信这不是生成器的使用方式。

于 2009-03-19T10:23:37.500 回答
8

刚刚落在这个线程上，并意识到缺少一个非常简单易读的答案：

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]
于 2019-03-20T10:52:07.067 回答
6

在 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)
于 2018-06-25T22:46:49.073 回答
5

要查看生成器是否为空，您需要做的就是尝试获取下一个结果。当然，如果您还没有准备好使用该结果，那么您必须存储它以便稍后再次返回它。

这是一个可以添加到现有迭代器以添加__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'

请注意，您可以随时检查是否为空，而不仅仅是在迭代开始时。

于 2014-06-13T06:30:58.543 回答
4

我意识到此时这篇文章已有 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)

当然，我相信许多评论员会指出，这很hacky，并且仅在某些有限的情况下才有效（例如，生成器没有副作用）。YMMV。

于 2014-03-23T17:02:20.177 回答
3 
>>> 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')
于 2009-03-19T10:00:23.140 回答
3

我发现只有这个解决方案也适用于空迭代。

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()
于 2020-02-04T17:28:29.537 回答
2

很抱歉这种明显的方法，但最好的方法是：

for item in my_generator:
     print item

现在您已经检测到生成器在使用时是空的。当然，如果生成器为空，则永远不会显示 item。

这可能不完全适合您的代码，但这就是生成器的习惯用法：迭代，所以也许您可能会稍微改变您的方法，或者根本不使用生成器。

于 2009-03-19T10:14:14.853 回答
1

如果您在使用生成器之前需要知道，那么不，没有简单的方法。如果您可以等到使用生成器之后，有一个简单的方法：

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()
于 2011-11-01T19:47:29.997 回答
1

只需用itertools.chain包装生成器，将代表迭代结束的东西作为第二个迭代，然后简单地检查它。

前任：

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
于 2016-06-28T22:14:12.573 回答
1

在我的情况下，我需要知道是否填充了许多生成器，然后再将其传递给一个函数，该函数合并了项目，即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"

我的特殊问题具有可迭代对象为空或具有完全相同数量的条目的属性。

于 2017-03-16T17:25:17.560 回答
1

使用 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

此函数返回的迭代器将等同于作为参数传入的原始迭代器。

于 2018-04-11T18:25:15.450 回答
1

bool(generator) 将返回正确的结果

于 2021-12-24T09:11:58.967 回答
0

这是一个包装生成器的简单装饰器，因此如果为空，则返回 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 %}
于 2016-07-29T03:43:42.677 回答
0

这是一个古老且已回答的问题，但正如以前没有人展示过的那样，这里是：

for _ in generator:
    break
else:
    print('Empty')

你可以在这里阅读更多

于 2020-02-21T10:53:04.850 回答
0

有一个非常简单的解决方案：if next(generator,-1) == -1然后生成器是空的！

于 2020-10-01T20:39:25.520 回答
0

只是为了帮助我的“2美分”，我将描述我的经历：

我有一个发电机，我需要将它itertools.islice切成小发电机。然后检查我的子生成器是否为空，我只需将它们转换/使用为一个小列表，然后检查列表是否为空。

例如：

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

也许这不是最好的方法，主要是因为它消耗了生成器，但是它对我有用。

于 2021-02-23T12:07:44.193 回答
-2

我通过使用 sum 函数解决了它。下面是我与 glob.iglob 一起使用的示例（它返回一个生成器）。

def isEmpty():
    files = glob.iglob(search)
    if sum(1 for _ in files):
        return True
    return False

*这可能不适用于 HUGE 生成器，但对于较小的列表应该可以很好地执行

于 2016-06-14T20:09:31.373 回答