Skąd mam wiedzieć, czy generator jest pusty od samego początku?

Czy istnieje prosty sposób na sprawdzenie, czy generator ma żadnych przedmiotów, jak peek, hasNext, isEmpty, coś w tym kierunku?

Prosta odpowiedź na twoje pytanie: nie, nie ma prostego sposobu. Istnieje wiele obejść.

Naprawdę nie powinno być prostego sposobu, z powodu tego, czym są generatory: sposobem na wyjście sekwencji wartości bez przechowywania sekwencji w pamięci . Nie ma więc przechodzenia wstecz.

Możesz napisać funkcję has_next, a może nawet wrzucić ją do generatora jako metodę z fantazyjnym dekoratorem, jeśli chcesz.

Sugestia:

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

Stosowanie:

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.

Prostym sposobem jest użycie opcjonalnego parametru next (), który jest używany, gdy generator jest wyczerpany (lub pusty). Na przykład:

iterable = some_generator()

_exhausted = object()

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

Edycja: poprawiono problem wskazany w komentarzu mehtunguh.

next(generator, None) is not None

Lub wymień, Noneale nie ma jej w generatorze jakąkolwiek znaną Ci wartość .

Edycja : Tak, spowoduje to pominięcie 1 elementu w generatorze. Często jednak sprawdzam, czy generator jest pusty tylko do celów walidacji, a potem tak naprawdę go nie używam. Lub inaczej robię coś takiego:

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

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

Oznacza to, że działa to, jeśli twój generator pochodzi z funkcji , jak w generator().

Najlepszym podejściem, IMHO, byłoby uniknięcie specjalnego testu. W większości przypadków użycie generatora jest testem:

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)

Jeśli to nie wystarczy, nadal możesz przeprowadzić wyraźny test. W tym momencie thingbędzie zawierać ostatnią wygenerowaną wartość. Jeśli nic nie zostało wygenerowane, będzie niezdefiniowane - chyba że zdefiniowałeś już zmienną. Możesz sprawdzić wartość thing, ale to trochę niewiarygodne. Zamiast tego po prostu ustaw flagę w bloku i sprawdź ją później:

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

Nienawidzę oferować drugiego rozwiązania, szczególnie takiego, którego sam bym nie użył, ale gdybyś absolutnie musiał to zrobić i nie zużywać generatora, jak w innych odpowiedziach:

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)

Teraz bardzo mi się to rozwiązanie nie podoba, bo uważam, że nie tak mają być używane generatory.

Zdaję sobie sprawę, że ten post ma w tym momencie 5 lat, ale znalazłem go, szukając idiomatycznego sposobu na zrobienie tego, i nie widziałem opublikowanego mojego rozwiązania. Więc dla potomnych:

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)

Oczywiście, jak z pewnością zauważy wielu komentatorów, jest to zepsute i działa tylko w pewnych ograniczonych sytuacjach (na przykład, gdy generatory są wolne od efektów ubocznych). YMMV.

Przepraszamy za oczywiste podejście, ale najlepiej byłoby zrobić:

for item in my_generator:
     print item

Teraz wykryłeś, że generator jest pusty, gdy go używasz. Oczywiście pozycja nigdy nie zostanie wyświetlona, ​​jeśli generator jest pusty.

Może to nie pasować do twojego kodu, ale do tego służy idiom generatora: iteracja, więc być może możesz nieznacznie zmienić swoje podejście lub w ogóle nie używać generatorów.

Wszystko, co musisz zrobić, aby sprawdzić, czy generator jest pusty, to spróbować uzyskać następny wynik. Oczywiście, jeśli nie jesteś gotowy do użycia tego wyniku, musisz go zapisać, aby ponownie go później zwrócić.

Oto klasa opakowania, którą można dodać do istniejącego iteratora w celu dodania __nonzero__testu, dzięki czemu można sprawdzić, czy generator jest pusty za pomocą prostego if. Prawdopodobnie można go również przekształcić w dekoratora.

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)

Oto jak tego użyjesz:

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

Zauważ, że możesz sprawdzić pustkę w dowolnym momencie, nie tylko na początku iteracji.

Poproszona przez Mark Ransom, oto klasa, której możesz użyć do zawinięcia dowolnego iteratora, abyś mógł zerknąć przed siebie, wrzucić wartości z powrotem do strumienia i sprawdzić, czy są puste. To prosty pomysł z prostą implementacją, która była dla mnie bardzo przydatna w przeszłości.

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)

Właśnie wpadłem na ten wątek i zdałem sobie sprawę, że brakuje bardzo prostej i łatwej do odczytania odpowiedzi:

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

Jeśli nie zamierzamy konsumować żadnego przedmiotu, musimy ponownie wstrzyknąć pierwszy przedmiot do generatora:

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

Przykład:

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

Na końcu generator StopIterationjest podnoszony, ponieważ w twoim przypadku koniec jest osiągany natychmiast, zgłaszany jest wyjątek. Ale normalnie nie powinieneś sprawdzać istnienia następnej wartości.

inną rzeczą, którą możesz zrobić, jest:

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

Jeśli chcesz wiedzieć, zanim użyjesz generatora, to nie, nie ma prostego sposobu. Jeśli możesz poczekać, aż po użyłeś generatora, istnieje prosty sposób:

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

Po prostu zawiń generator za pomocą itertools.chain , umieść coś, co będzie reprezentować koniec iteracji jako drugą iterowalną, a następnie po prostu sprawdź to.

Dawny:

import itertools

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

Teraz pozostaje tylko sprawdzić tę wartość, którą dodaliśmy na końcu iterowalnej, kiedy ją przeczytasz, będzie to oznaczało koniec

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

W moim przypadku musiałem wiedzieć, czy zapełniono wiele generatorów, zanim przekazałem je do funkcji, która scalała elementy, tj zip(...).. Rozwiązanie jest podobne, ale dostatecznie różne od przyjętej odpowiedzi:

Definicja:

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

Stosowanie:

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"

Mój szczególny problem ma tę właściwość, że elementy iteracyjne są albo puste, albo mają dokładnie taką samą liczbę wpisów.

Uważam, że tylko to rozwiązanie działa również dla pustych iteracji.

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)

Lub jeśli nie chcesz używać wyjątku do tego, spróbuj użyć

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)

W zaznaczonym rozwiązaniu nie ma możliwości zastosowania go do pustych generatorów typu

def get_empty_generator():
    while False:
        yield None 

generator = get_empty_generator()

To jest stare pytanie, na które udzielono odpowiedzi, ale ponieważ nikt go wcześniej nie pokazał, oto ono:

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

Możesz przeczytać więcej tutaj

Oto moje proste podejście, którego używam, aby zwracać iterator podczas sprawdzania, czy coś zostało znalezione.Po prostu sprawdzam, czy pętla działa:

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

Oto prosty dekorator, który otacza generator, więc zwraca None, jeśli jest pusty. Może to być przydatne, jeśli Twój kod musi wiedzieć, czy generator coś wyprodukuje, zanim przejdzie przez niego w pętli.

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

Stosowanie:

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

Jednym z przykładów, w którym jest to przydatne, jest kod szablonów - np. Jinja2

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

używając islice, wystarczy sprawdzić do pierwszej iteracji, aby stwierdzić, czy jest pusty.

z itertools import islice

def isempty (iterowalne):
    lista zwrotów (islice (iterowalne, 1)) == []

A co z użyciem any ()? Używam go z generatorami i działa dobrze. Tutaj jest facet, który trochę to wyjaśnia

Użyj Peek funkcji w 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

Iterator zwracany przez tę funkcję będzie równoważny z oryginalnym przekazanym jako argument.

Rozwiązałem to za pomocą funkcji sumy. Zobacz poniżej przykład, którego użyłem z glob.iglob (który zwraca generator).

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

* To prawdopodobnie nie zadziała dla OGROMNYCH generatorów, ale powinno dobrze działać dla mniejszych list