Come faccio a sapere se un generatore è vuoto dall'inizio?

C'è un modo semplice di testare se il generatore non ha oggetti, come peek, hasNext, isEmpty, qualcosa del genere?

La semplice risposta alla tua domanda: no, non esiste un modo semplice. Ci sono molte soluzioni alternative.

In realtà non dovrebbe esserci un modo semplice, a causa di cosa sono i generatori: un modo per produrre una sequenza di valori senza tenere la sequenza in memoria . Quindi non c'è attraversamento all'indietro.

Potresti scrivere una funzione has_next o magari schiaffeggiarla su un generatore come metodo con un decoratore di fantasia se lo desideri.

Suggerimento:

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.

Un modo semplice è usare il parametro opzionale per next () che viene usato se il generatore è esaurito (o vuoto). Per esempio:

iterable = some_generator()

_exhausted = object()

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

Modifica: corretto il problema sottolineato nel commento di mehtunguh.

next(generator, None) is not None

O sostituisci Nonema qualunque valore tu sappia non è nel tuo generatore.

Modifica : Sì, questo salterà 1 elemento nel generatore. Spesso, tuttavia, controllo se un generatore è vuoto solo a fini di convalida, quindi non lo uso davvero. O altrimenti faccio qualcosa del tipo:

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

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

Cioè, funziona se il tuo generatore proviene da una funzione , come in generator().

L'approccio migliore, IMHO, sarebbe quello di evitare un test speciale. La maggior parte delle volte, l'uso di un generatore è il test:

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 ciò non è abbastanza buono, puoi comunque eseguire un test esplicito. A questo punto, thingconterrà l'ultimo valore generato. Se non è stato generato nulla, sarà indefinito, a meno che tu non abbia già definito la variabile. Potresti verificare il valore di thing, ma è un po 'inaffidabile. Invece, basta impostare un flag all'interno del blocco e controllarlo in seguito:

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

Odio per offrire una seconda soluzione, in particolare uno che non vorrei usare me stesso, ma, se proprio doveva fare questo e di non consumare il generatore, come in altre risposte:

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)

Ora non mi piace davvero questa soluzione, perché credo che non sia così che devono essere usati i generatori.

Mi rendo conto che questo post ha 5 anni a questo punto, ma l'ho trovato mentre cercavo un modo idiomatico di farlo e non ho visto la mia soluzione pubblicata. Quindi per i posteri:

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)

Naturalmente, come sono sicuro che molti commentatori faranno notare, questo è confuso e funziona solo in determinate situazioni limitate (dove i generatori sono privi di effetti collaterali, per esempio). YMMV.

Ci scusiamo per l'approccio ovvio, ma il modo migliore sarebbe quello di fare:

for item in my_generator:
     print item

Ora hai rilevato che il generatore è vuoto mentre lo stai utilizzando. Naturalmente, l'oggetto non verrà mai visualizzato se il generatore è vuoto.

Questo potrebbe non adattarsi esattamente al tuo codice, ma questo è lo scopo del linguaggio del generatore: iterando, quindi forse potresti cambiare leggermente il tuo approccio o non usare affatto i generatori.

Tutto quello che devi fare per vedere se un generatore è vuoto è cercare di ottenere il risultato successivo. Naturalmente se non sei pronto per utilizzare quel risultato, devi memorizzarlo per restituirlo in seguito.

Ecco una classe wrapper che può essere aggiunta a un iteratore esistente per aggiungere un __nonzero__test, in modo da poter vedere se il generatore è vuoto con un semplice if. Probabilmente può anche essere trasformato in un decoratore.

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)

Ecco come lo useresti:

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

Si noti che è possibile verificare la presenza di vuoto in qualsiasi momento, non solo all'inizio dell'iterazione.

Su richiesta di Mark Ransom, ecco una classe che puoi usare per avvolgere qualsiasi iteratore in modo da poter sbirciare in avanti, reinserire i valori nello stream e controllare se sono vuoti. È un'idea semplice con una semplice implementazione che ho trovato molto utile in passato.

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)

Sono appena caduto su questo thread e ho capito che mancava una risposta molto semplice e facile da leggere:

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

Se non si suppone di consumare alcun articolo, è necessario reiniettare il primo articolo nel generatore:

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

Esempio:

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

Alla fine del generatore StopIterationviene sollevato, poiché nel tuo caso viene raggiunta immediatamente la fine, viene sollevata l'eccezione. Ma normalmente non dovresti controllare l'esistenza del prossimo valore.

un'altra cosa che puoi fare è:

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

Se devi sapere prima di utilizzare il generatore, allora no, non esiste un modo semplice. Se puoi aspettare fino a quando non hai usato il generatore, c'è un modo semplice:

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

Avvolgi semplicemente il generatore con itertools.chain , metti qualcosa che rappresenterà la fine dell'iterabile come secondo iterabile, quindi controlla semplicemente quello.

Ex:

import itertools

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

Ora tutto ciò che rimane è verificare il valore che abbiamo aggiunto alla fine dell'iterabile, quando lo leggi allora significherà la fine

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

Nel mio caso avevo bisogno di sapere se un host di generatori era popolato prima di passarlo a una funzione, che univa gli elementi, cioè zip(...). La soluzione è simile, ma abbastanza diversa, dalla risposta accettata:

Definizione:

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"

Il mio problema particolare ha la proprietà che gli iterabili sono vuoti o hanno esattamente lo stesso numero di voci.

Ho trovato solo questa soluzione funzionante anche per iterazioni vuote.

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)

O se non si desidera utilizzare l'eccezione per questo, provare a utilizzare

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)

Nella soluzione contrassegnata non è possibile usarlo per generatori vuoti come

def get_empty_generator():
    while False:
        yield None 

generator = get_empty_generator()

Questa è una domanda vecchia e con risposta, ma come nessuno ha mostrato prima, eccola qui:

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

Puoi leggere di più qui

Ecco il mio semplice approccio che uso per continuare a restituire un iteratore mentre controllo se qualcosa è stato prodotto Controllo solo se il ciclo funziona:

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

Ecco un semplice decoratore che avvolge il generatore, quindi restituisce None se vuoto. Questo può essere utile se il tuo codice deve sapere se il generatore produrrà qualcosa prima di eseguirne il ciclo.

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

Un esempio in cui questo è utile è nel codice di template - ovvero jinja2

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

usando islice devi solo controllare fino alla prima iterazione per scoprire se è vuoto.

da itertools import islice

def isempty (iterable):
    lista di restituzione (islice (iterable, 1)) == []

Che ne dici di usare any ()? Lo uso con i generatori e funziona benissimo. Qui c'è un ragazzo che spiega un po 'di questo

Utilizzare la funzione peek in 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

L'iteratore restituito da questa funzione sarà equivalente a quello originale passato come argomento.

L'ho risolto usando la funzione somma. Vedi sotto per un esempio che ho usato con glob.iglob (che restituisce un generatore).

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

* Questo probabilmente non funzionerà per generatori ENORMI ma dovrebbe funzionare bene per elenchi più piccoli