Как узнать, что генератор с самого начала пуст?

Есть простой способ проверить , если генератор не имеет элементов, как peek, hasNext, isEmpty, что - то вдоль этих линий?

Простой ответ на ваш вопрос: нет, простого пути нет. Есть много способов обхода.

На самом деле не должно быть простого способа из-за того, что такое генераторы: способа вывода последовательности значений без сохранения последовательности в памяти . Так что обратного обхода нет.

Вы можете написать функцию 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.

Простой способ - использовать необязательный параметр для next (), который используется, если генератор исчерпан (или пуст). Например:

iterable = some_generator()

_exhausted = object()

if next(iterable, _exhausted) == _exhausted:
    print('generator is empty')

Изменить: исправлена ​​проблема, указанная в комментарии mehtunguh.

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

Лучше всего, ИМХО, избежать специальной проверки. В большинстве случаев использование генератора - это проверка:

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!"

Мне не нравится предлагать второе решение, особенно такое, которое я бы сам не использовал, но, если вам абсолютно необходимо это сделать и не использовать генератор, как в других ответах:

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)

Сейчас мне очень не нравится это решение, потому что я считаю, что генераторы должны использоваться не так.

Я понимаю, что этому посту на данный момент 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'

Обратите внимание, что вы можете проверить наличие пустоты в любое время, а не только в начале итерации.

Просто заглянул в эту ветку и понял, что не хватает очень простого и легко читаемого ответа:

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]

По подсказке Марка Рэнсома, вот класс, который вы можете использовать для обертывания любого итератора, чтобы вы могли заглядывать вперед, возвращать значения в поток и проверять пустоту. Это простая идея с простой реализацией, которую я считал очень удобной в прошлом.

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)

Извините за очевидный подход, но лучше всего было бы:

for item in my_generator:
     print item

Теперь вы обнаружили, что генератор пуст, пока вы его используете. Конечно, элемент никогда не будет отображаться, если генератор пуст.

Это может не совсем соответствовать вашему коду, но идиома генератора предназначена для итерации, поэтому, возможно, вы можете немного изменить свой подход или вообще не использовать генераторы.

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

Если вам нужно знать, прежде чем использовать генератор, то нет, простого способа не существует. Если вы не можете ждать , пока после того, как вы использовали генератор, есть простой способ:

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

Просто оберните генератор с помощью 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

В моем случае мне нужно было узнать, был ли заполнен набор генераторов, прежде чем я передал его функции, которая объединила элементы, т 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_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')

Вы можете прочитать больше здесь

Вот мой простой подход, который я использую, чтобы продолжать возвращать итератор при проверке, получилось ли что-то, я просто проверяю, выполняется ли цикл:

        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 %}

используя islice, вам нужно только проверить до первой итерации, чтобы узнать, пуста ли она.

from itertools import islice

def isempty (iterable):
    return list (islice (iterable, 1)) == []

Используйте заглянуть функцию в cytoolz.

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

Итератор, возвращаемый этой функцией, будет эквивалентен исходному, переданному в качестве аргумента.

Есть очень простое решение: if next(generator,-1) == -1тогда генератор пуст!

А как насчет использования any ()? Я использую его с генераторами, и он работает нормально. Вот парень, немного объясняющий это

Я решил это с помощью функции суммы. См. Ниже пример, который я использовал с glob.iglob (который возвращает генератор).

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

* Это, вероятно, не будет работать для ОГРОМНЫХ генераторов, но должно хорошо работать для небольших списков