Woher weiß ich, ob ein Generator von Anfang an leer ist?

Gibt es eine einfache Art und Weise zu testen , ob der Generator keine Elemente hat, wie peek, hasNext, isEmpty, etwas in diese Richtung?

Die einfache Antwort auf Ihre Frage: Nein, es gibt keinen einfachen Weg. Es gibt viele Umgehungsmöglichkeiten.

Es sollte wirklich keinen einfachen Weg geben, aufgrund dessen, was Generatoren sind: einen Weg, eine Folge von Werten auszugeben, ohne die Folge im Speicher zu halten . Es gibt also keine Rückwärtsdurchquerung.

Sie können eine has_next-Funktion schreiben oder sie sogar als Methode mit einem ausgefallenen Dekorateur auf einen Generator übertragen, wenn Sie möchten.

Vorschlag:

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

Verwendung:

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.

Eine einfache Möglichkeit besteht darin, den optionalen Parameter für next () zu verwenden, der verwendet wird, wenn der Generator erschöpft (oder leer) ist. Beispielsweise:

iterable = some_generator()

_exhausted = object()

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

Bearbeiten: Das in mehtunguhs Kommentar erwähnte Problem wurde behoben.

next(generator, None) is not None

Oder ersetzen Sie, Noneaber welcher Wert auch immer Sie wissen, er befindet sich nicht in Ihrem Generator.

Bearbeiten : Ja, dies überspringt 1 Element im Generator. Oft überprüfe ich jedoch, ob ein Generator nur zu Validierungszwecken leer ist, und verwende ihn dann nicht wirklich. Oder sonst mache ich so etwas wie:

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

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

Das heißt, dies funktioniert, wenn Ihr Generator von einer Funktion stammt , wie in generator().

Der beste Ansatz, IMHO, wäre es, einen speziellen Test zu vermeiden. In den meisten Fällen ist die Verwendung eines Generators der 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)

Wenn das nicht gut genug ist, können Sie trotzdem einen expliziten Test durchführen. Zu diesem Zeitpunkt thingwird der zuletzt generierte Wert enthalten. Wenn nichts generiert wurde, ist es undefiniert - es sei denn, Sie haben die Variable bereits definiert. Sie könnten den Wert von überprüfen thing, aber das ist ein bisschen unzuverlässig. Setzen Sie stattdessen einfach ein Flag innerhalb des Blocks und überprüfen Sie es anschließend:

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

Ich hasse eine zweite Lösung zu bieten, vor allem ein , dass ich mich nicht verwenden würde, aber, wenn Sie unbedingt hat , dies zu tun und zu konsumieren , ohne den Generator, wie in anderen Antworten:

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)

Jetzt mag ich diese Lösung wirklich nicht, weil ich glaube, dass Generatoren nicht so verwendet werden sollen.

Mir ist klar, dass dieser Beitrag zu diesem Zeitpunkt 5 Jahre alt ist, aber ich habe ihn gefunden, als ich nach einer idiomatischen Methode gesucht habe, und habe meine Lösung nicht veröffentlicht. Also für die Nachwelt:

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)

Wie viele Kommentatoren sicher betonen werden, ist dies natürlich hackig und funktioniert überhaupt nur in bestimmten begrenzten Situationen (in denen die Generatoren beispielsweise frei von Nebenwirkungen sind). YMMV.

Entschuldigen Sie den offensichtlichen Ansatz, aber der beste Weg wäre:

for item in my_generator:
     print item

Jetzt haben Sie festgestellt, dass der Generator leer ist, während Sie ihn verwenden. Natürlich wird das Element niemals angezeigt, wenn der Generator leer ist.

Dies passt möglicherweise nicht genau zu Ihrem Code, aber dafür ist die Redewendung des Generators gedacht: Iterieren. Vielleicht können Sie Ihren Ansatz geringfügig ändern oder Generatoren überhaupt nicht verwenden.

Alles, was Sie tun müssen, um festzustellen, ob ein Generator leer ist, ist zu versuchen, das nächste Ergebnis zu erhalten. Natürlich, wenn Sie nicht bereit sind dieses Ergebnis , müssen speichern, um es später erneut zurückzugeben.

Hier ist eine Wrapper-Klasse, die einem vorhandenen Iterator hinzugefügt werden kann, um einen __nonzero__Test hinzuzufügen , sodass Sie mit einem einfachen Befehl sehen können, ob der Generator leer ist if. Es kann wahrscheinlich auch in einen Dekorateur verwandelt werden.

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)

So würden Sie es verwenden:

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

Beachten Sie, dass Sie jederzeit auf Leere prüfen können, nicht nur zu Beginn der Iteration.

Auf Aufforderung von Mark Ransom finden Sie hier eine Klasse, mit der Sie jeden Iterator umschließen können, damit Sie einen Blick nach vorne werfen, Werte zurück in den Stream verschieben und nach Leerzeichen suchen können. Es ist eine einfache Idee mit einer einfachen Implementierung, die ich in der Vergangenheit als sehr praktisch empfunden habe.

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)

Ich bin gerade auf diesen Thread gefallen und habe festgestellt, dass eine sehr einfache und leicht zu lesende Antwort fehlt:

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

Wenn wir keinen Artikel konsumieren sollen, müssen wir den ersten Artikel erneut in den Generator injizieren:

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

Beispiel:

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

Am Ende des Generators StopIterationwird ausgelöst, da in Ihrem Fall das Ende sofort erreicht ist, wird eine Ausnahme ausgelöst. Normalerweise sollten Sie jedoch nicht prüfen, ob der nächste Wert vorhanden ist.

Sie können auch Folgendes tun:

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

Wenn Sie wissen müssen, bevor Sie den Generator verwenden, gibt es keinen einfachen Weg. Wenn Sie warten , bis können nach der Generator verwendet haben, gibt es eine einfache Art und Weise:

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

Wickeln Sie den Generator einfach mit itertools.chain ein , setzen Sie etwas, das das Ende der , als zweite Iterable ein und überprüfen Sie dies einfach.

Ex:

import itertools

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

Jetzt müssen Sie nur noch nach dem Wert suchen, den wir an das Ende der Iterable angehängt haben. Wenn Sie ihn lesen, bedeutet dies das Ende

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

In meinem Fall musste ich wissen, ob eine Vielzahl von Generatoren gefüllt war, bevor ich sie an eine Funktion weitergab, die die Elemente zusammenführte, d zip(...). H. Die Lösung ist ähnlich, aber unterschiedlich genug von der akzeptierten Antwort:

Definition:

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

Verwendung:

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"

Mein spezielles Problem hat die Eigenschaft, dass die Iterables entweder leer sind oder genau die gleiche Anzahl von Einträgen haben.

Ich fand nur diese Lösung auch für leere Iterationen geeignet.

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)

Oder wenn Sie hierfür keine Ausnahme verwenden möchten, versuchen Sie es

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)

In der markierten Lösung ist es nicht möglich, sie für leere Generatoren wie zu verwenden

def get_empty_generator():
    while False:
        yield None 

generator = get_empty_generator()

Dies ist eine alte und beantwortete Frage, aber wie noch niemand zuvor gezeigt hat, geht es los:

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

Hier können Sie mehr lesen

Hier ist mein einfacher Ansatz, mit dem ich immer wieder einen Iterator zurückgebe, während ich überprüfe, ob etwas ausgegeben wurde. Ich überprüfe nur, ob die Schleife ausgeführt wird:

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

Hier ist ein einfacher Dekorator, der den Generator umschließt, sodass er None zurückgibt, wenn er leer ist. Dies kann nützlich sein, wenn Ihr Code wissen muss, ob der Generator etwas erzeugt, bevor er ihn durchläuft.

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

Verwendung:

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

Ein Beispiel, wo dies nützlich ist, ist das Templating von Code - dh jinja2

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

Mit islice müssen Sie nur bis zur ersten Iteration prüfen, ob sie leer ist.

aus itertools islice importieren

def isempty (iterable):
    Rückgabeliste (islice (iterable, 1)) == []

Was ist mit any ()? Ich benutze es mit Generatoren und es funktioniert gut. Hier erklärt ein Typ ein wenig darüber

Verwenden Sie die Peek- Funktion 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

Der von dieser Funktion zurückgegebene Iterator entspricht dem ursprünglichen Argument, das als Argument übergeben wurde.

Ich habe es mit der Summenfunktion gelöst. Unten finden Sie ein Beispiel, das ich mit glob.iglob verwendet habe (das einen Generator zurückgibt).

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

* Dies wird wahrscheinlich nicht für RIESIGE Generatoren funktionieren, sollte aber für kleinere Listen gut funktionieren