Como sei se um gerador está vazio desde o início?

Existe uma maneira simples de testar se o gerador não tem itens, como peek, hasNext, isEmpty, algo nesse sentido?

A resposta simples para sua pergunta: não, não há uma maneira simples. Existem muitas soluções alternativas.

Realmente não deveria haver uma maneira simples, por causa do que são os geradores: uma maneira de gerar uma sequência de valores sem manter a sequência na memória . Portanto, não há travessia para trás.

Você pode escrever uma função has_next ou talvez até colocá-la em um gerador como um método com um decorador sofisticado, se você quiser.

Sugestão:

def peek(iterable):
    try:
        first = next(iterable)
    except StopIteration:
        return None
    return first, itertools.chain([first], iterable)

Uso:

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.

Uma maneira simples é usar o parâmetro opcional for next () que é usado se o gerador estiver esgotado (ou vazio). Por exemplo:

iterable = some_generator()

_exhausted = object()

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

Edit: Corrigido o problema apontado no comentário de mehtunguh.

next(generator, None) is not None

Ou substitua, Nonemas o valor que você sabe que não está no seu gerador.

Edit : Sim, isso irá pular 1 item no gerador. Freqüentemente, porém, verifico se um gerador está vazio apenas para fins de validação e, na verdade, não o uso. Ou então eu faço algo como:

def foo(self):
    if next(self.my_generator(), None) is None:
        raise Exception("Not initiated")

    for x in self.my_generator():
        ...

Ou seja, isso funciona se o seu gerador vier de uma função , como em generator().

A melhor abordagem, IMHO, seria evitar um teste especial. Na maioria das vezes, o uso de um gerador é o teste:

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)

Se isso não for bom o suficiente, você ainda poderá executar um teste explícito. Neste ponto, thingconterá o último valor gerado. Se nada foi gerado, será indefinido - a menos que você já tenha definido a variável. Você pode verificar o valor de thing, mas isso é um pouco confiável. Em vez disso, basta definir um sinalizador dentro do bloco e verificar depois:

if not thing_generated:
    print "Avast, ye scurvy dog!"

Detesto oferecer uma segunda solução, especialmente uma que eu não usaria, mas, se você tivesse que fazer isso absolutamente e não consumir o gerador, como em outras respostas:

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)

Agora, eu realmente não gosto desta solução, porque acredito que não é assim que os geradores devem ser usados.

Percebo que este post tem 5 anos neste momento, mas o encontrei enquanto procurava uma maneira idiomática de fazer isso e não vi minha solução postada. Assim, para a posteridade:

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)

Obviamente, como tenho certeza de que muitos comentaristas apontarão, isso é hacky e só funciona em determinadas situações limitadas (onde os geradores são livres de efeitos colaterais, por exemplo). YMMV.

Desculpe a abordagem óbvia, mas a melhor maneira seria:

for item in my_generator:
     print item

Agora você detectou que o gerador está vazio enquanto você o está usando. Obviamente, o item nunca será exibido se o gerador estiver vazio.

Isso pode não se encaixar exatamente no seu código, mas é para isso que serve o idioma: iterar, portanto, talvez você possa mudar um pouco sua abordagem ou não usar geradores.

Tudo o que você precisa fazer para verificar se um gerador está vazio é tentar obter o próximo resultado. Obviamente, se você não estiver pronto para usar esse resultado, precisará armazená-lo para devolvê-lo mais tarde.

Aqui está uma classe de wrapper que pode ser adicionada a um iterador existente para adicionar um __nonzero__teste, para que você possa ver se o gerador está vazio com um simples if. Provavelmente também pode ser transformado em um decorador.

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)

Veja como você o usaria:

with open(filename, 'r') as f:
    f = GenWrapper(f)
    if f:
        print 'Not empty'
    else:
        print 'Empty'

Observe que você pode verificar o vazio a qualquer momento, não apenas no início da iteração.

Solicitado por Mark Ransom, aqui está uma classe que você pode usar para agrupar qualquer iterador, para que você possa espreitar adiante, enviar valores de volta ao fluxo e verificar se estão vazios. É uma ideia simples, com uma implementação simples, que achei muito útil no passado.

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)

Apenas caí nessa discussão e percebi que faltava uma resposta muito simples e fácil de ler:

def is_empty(generator):
    for item in generator:
        return False
    return True

Se não devemos consumir nenhum item, precisamos injetar novamente o primeiro item no gerador:

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

Exemplo:

>>> 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]

>>> gen = (i for i in [])
>>> next(gen)
Traceback (most recent call last):
  File "<pyshell#43>", line 1, in <module>
    next(gen)
StopIteration

No final do gerador StopIterationé gerado, pois no seu caso o fim é alcançado imediatamente, a exceção é gerada.Mas normalmente você não deve verificar a existência do próximo valor.

Outra coisa que você pode fazer é:

>>> gen = (i for i in [])
>>> if not list(gen):
    print('empty generator')

Se você precisar saber antes de usar o gerador, não, não existe uma maneira simples. Se você pode esperar até depois de usar o gerador, existe uma maneira simples:

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

Simplesmente envolva o gerador com itertools.chain , coloque algo que represente o final do iterável como o segundo iterável e, em seguida, simplesmente verifique isso.

Ex:

import itertools

g = some_iterable
eog = object()
wrap_g = itertools.chain(g, [eog])

Agora tudo o que resta é verificar o valor que acrescentamos ao final do iterável, quando você o ler, isso significará o final

for value in wrap_g:
    if value == eog: # DING DING! We just found the last element of the iterable
        pass # Do something

No meu caso, eu precisava saber se uma série de geradores foi preenchida antes de passar para uma função que mesclava os itens, ou seja zip(...),. A solução é semelhante, mas diferente o suficiente, da resposta aceita:

Definição:

def has_items(iterable):
    try:
        return True, itertools.chain([next(iterable)], iterable)
    except StopIteration:
        return False, []

Uso:

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"

Meu problema específico tem a propriedade de que as iteráveis ​​estão vazias ou têm exatamente o mesmo número de entradas.

Eu encontrei apenas essa solução trabalhando para iterações vazias também.

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)

Ou, se você não quiser usar a exceção para esta tentativa, use

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)

Na solução marcada, não é possível usá-lo para geradores vazios, como

def get_empty_generator():
    while False:
        yield None 

generator = get_empty_generator()

Esta é uma pergunta antiga e respondida, mas como ninguém a mostrou antes, aqui está:

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

Você pode ler mais aqui

Aqui está minha abordagem simples que eu uso para continuar retornando um iterador enquanto verifica se algo foi produzido, apenas verifico se o loop é executado:

        n = 0
        for key, value in iterator:
            n+=1
            yield key, value
        if n == 0:
            print ("nothing found in iterator)
            break

Aqui está um decorador simples que envolve o gerador, e ele retorna Nenhum se estiver vazio. Isso pode ser útil se o seu código precisar saber se o gerador produzirá alguma coisa antes de passar por ele.

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

Uso:

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

Um exemplo em que isso é útil é no código de modelo - ie jinja2

{% if content_generator %}
  <section>
    <h4>Section title</h4>
    {% for item in content_generator %}
      {{ item }}
    {% endfor %
  </section>
{% endif %}

usando o islice, você só precisa verificar a primeira iteração para descobrir se está vazia.

de itertools import islice

def isempty (iterável):
    lista de retorno (islice (iterável, 1)) == []

Que tal usar any ()? Eu uso com geradores e está funcionando bem. Aqui tem um cara explicando um pouco sobre isso

Use a função de espiar no 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

O iterador retornado por esta função será equivalente ao original transmitido como argumento.

Eu o resolvi usando a função soma. Veja abaixo um exemplo que usei com glob.iglob (que retorna um gerador).

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

* Isso provavelmente não funcionará para geradores ENORME, mas deve funcionar bem para listas menores