Comment savoir si un générateur est vide depuis le début?

Est - il un moyen simple de tester si le générateur n'a pas d' éléments, comme peek, hasNext, isEmpty, quelque chose dans ce sens?

La réponse simple à votre question: non, il n'y a pas de moyen simple. Il y a beaucoup de solutions de rechange.

Il ne devrait vraiment pas y avoir de moyen simple, à cause de ce que sont les générateurs: un moyen de sortir une séquence de valeurs sans garder la séquence en mémoire . Il n'y a donc pas de traversée en arrière.

Vous pouvez écrire une fonction has_next ou peut-être même l'appliquer à un générateur comme méthode avec un décorateur sophistiqué si vous le souhaitez.

Suggestion:

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

Usage:

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.

Une manière simple est d'utiliser le paramètre optionnel pour next () qui est utilisé si le générateur est épuisé (ou vide). Par exemple:

iterable = some_generator()

_exhausted = object()

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

Edit: Correction du problème signalé dans le commentaire de mehtunguh.

next(generator, None) is not None

Ou remplacez, Nonemais quelle que soit la valeur que vous connaissez, ce n'est pas dans votre générateur.

Edit : Oui, cela sautera 1 élément dans le générateur. Souvent, cependant, je vérifie si un générateur est vide uniquement à des fins de validation, alors je ne l'utilise pas vraiment. Ou sinon je fais quelque chose comme:

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

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

Autrement dit, cela fonctionne si votre générateur provient d'une fonction , comme dans generator().

La meilleure approche, à mon humble avis, serait d'éviter un test spécial. La plupart du temps, l'utilisation d'un générateur est le 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)

Si cela ne suffit pas, vous pouvez toujours effectuer un test explicite. À ce stade, thingcontiendra la dernière valeur générée. Si rien n'a été généré, il sera indéfini - sauf si vous avez déjà défini la variable. Vous pouvez vérifier la valeur de thing, mais c'est un peu peu fiable. Au lieu de cela, définissez simplement un drapeau dans le bloc et vérifiez-le ensuite:

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

Je déteste offrir une deuxième solution, en particulier celui que je ne me utiliser, mais, si vous absolument deviez le faire et de ne pas consommer le générateur, comme dans d' autres réponses:

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)

Maintenant, je n'aime vraiment pas cette solution, car je pense que ce n'est pas ainsi que les générateurs doivent être utilisés.

Je me rends compte que ce post a 5 ans à ce stade, mais je l'ai trouvé en cherchant une manière idiomatique de le faire, et je n'ai pas vu ma solution postée. Donc pour la postérité:

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)

Bien sûr, comme je suis sûr que de nombreux commentateurs le souligneront, c'est piraté et ne fonctionne que dans certaines situations limitées (où les générateurs sont sans effets secondaires, par exemple). YMMV.

Désolé pour l'approche évidente, mais la meilleure façon serait de faire:

for item in my_generator:
     print item

Vous avez maintenant détecté que le générateur est vide pendant que vous l'utilisez. Bien sûr, l'élément ne sera jamais affiché si le générateur est vide.

Cela ne correspond peut-être pas exactement à votre code, mais c'est à cela que sert l'idiome du générateur: itérer, alors peut-être que vous pourriez changer légèrement votre approche, ou ne pas utiliser du tout de générateurs.

Tout ce que vous avez à faire pour voir si un générateur est vide est d'essayer d'obtenir le résultat suivant. Bien sûr, si vous n'êtes pas prêt à utiliser ce résultat, vous devez le stocker pour le renvoyer plus tard.

Voici une classe wrapper qui peut être ajoutée à un itérateur existant pour ajouter un __nonzero__test, afin que vous puissiez voir si le générateur est vide avec un simple if. Il peut probablement aussi être transformé en décorateur.

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)

Voici comment vous l'utiliseriez:

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

Notez que vous pouvez vérifier la vacuité à tout moment, pas seulement au début de l'itération.

À la demande de Mark Ransom, voici une classe que vous pouvez utiliser pour encapsuler n'importe quel itérateur afin que vous puissiez jeter un coup d'œil à l'avance, repousser les valeurs dans le flux et vérifier qu'elles sont vides. C'est une idée simple avec une implémentation simple que j'ai trouvée très pratique dans le passé.

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)

Je suis juste tombé sur ce fil et j'ai réalisé qu'il manquait une réponse très simple et facile à lire:

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

Si nous ne sommes censés consommer aucun élément, nous devons réinjecter le premier élément dans le générateur:

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

Exemple:

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

À la fin du générateur StopIterationest déclenché, car dans votre cas, la fin est immédiatement atteinte, l'exception est levée. Mais normalement, vous ne devriez pas vérifier l'existence de la valeur suivante.

une autre chose que vous pouvez faire est:

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

Si vous avez besoin de savoir avant d'utiliser le générateur, alors non, il n'y a pas de moyen simple. Si vous pouvez attendre après avoir utilisé le générateur, il existe un moyen simple:

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

Enveloppez simplement le générateur avec itertools.chain , mettez quelque chose qui représentera la fin de l'itérable comme le deuxième iterable, puis vérifiez simplement cela.

Ex:

import itertools

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

Il ne reste plus qu'à vérifier cette valeur que nous avons ajoutée à la fin de l'itérable, lorsque vous le lirez, cela signifiera la fin

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

Dans mon cas, j'avais besoin de savoir si une foule de générateurs était remplie avant de la transmettre à une fonction, qui fusionnait les éléments, c'est-à-dire zip(...). La solution est similaire, mais assez différente, de la réponse acceptée:

Définition:

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

Usage:

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"

Mon problème particulier a la propriété que les itérables sont vides ou ont exactement le même nombre d'entrées.

Je n'ai trouvé que cette solution fonctionnant également pour les itérations vides.

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 si vous ne souhaitez pas utiliser d'exception pour cela, essayez d'utiliser

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)

Dans la solution marquée, vous ne pouvez pas l'utiliser pour des générateurs vides comme

def get_empty_generator():
    while False:
        yield None 

generator = get_empty_generator()

C'est une question ancienne et avec réponse, mais comme personne ne l'a montré auparavant, la voici:

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

Vous pouvez lire plus ici

Voici mon approche simple que j'utilise pour continuer à renvoyer un itérateur tout en vérifiant si quelque chose a été produit.Je vérifie simplement si la boucle s'exécute:

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

Voici un décorateur simple qui enveloppe le générateur, il renvoie donc None s'il est vide. Cela peut être utile si votre code a besoin de savoir si le générateur produira quelque chose avant de le parcourir.

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

Usage:

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 exemple où cela est utile est dans la création de modèles de code - c'est-à-dire jinja2

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

en utilisant islice, vous n'avez qu'à vérifier jusqu'à la première itération pour découvrir s'il est vide.

à partir d'itertools importer islice

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

Qu'en est-il de l'utilisation de any ()? Je l'utilise avec des générateurs et ça marche très bien. Ici, il y a un gars qui explique un peu à ce sujet

Utilisez la fonction peek dans 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'itérateur retourné par cette fonction sera équivalent à l'itérateur d'origine passé en argument.

Je l'ai résolu en utilisant la fonction somme. Voir ci-dessous un exemple que j'ai utilisé avec glob.iglob (qui renvoie un générateur).

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

* Cela ne fonctionnera probablement pas pour les générateurs ÉNORMES mais devrait bien fonctionner pour les petites listes