Une seule ligne pour vérifier si un itérateur produit au moins un élément?

Actuellement, je fais ceci:

try:
    something = iterator.next()
    # ...
except StopIteration:
    # ...

Mais je voudrais une expression que je puisse placer dans un simple if déclaration. Y a-t-il quelque chose de intégré qui rendrait ce code moins maladroit?

any() Retour False si un itérable est vide, mais il itérera potentiellement sur tous les éléments si ce n'est pas le cas. Je n'en ai besoin que pour vérifier le premier élément.

Quelqu'un demande ce que j'essaye de faire. J'ai écrit une fonction qui exécute une requête SQL et donne ses résultats. Parfois, lorsque j'appelle cette fonction, je veux juste savoir si la requête a renvoyé quelque chose et prendre une décision en fonction de cela.

anyn'ira pas au-delà du premier élément s'il est vrai. Au cas où l'itérateur donnerait quelque chose de faux, vous pouvez écrire any(True for _ in iterator).

En Python 2.6+, si le nom sentinelest lié à une valeur que l'itérateur ne peut pas fournir,

if next(iterator, sentinel) is sentinel:
    print('iterator was empty')

Si vous n'avez aucune idée de ce que l'itérateur pourrait éventuellement produire, créez votre propre sentinelle (par exemple en haut de votre module) avec

sentinel = object()

Sinon, vous pouvez utiliser, dans le rôle sentinelle, n'importe quelle valeur que vous «connaissez» (en fonction des considérations d'application) que l'itérateur ne peut pas fournir.

Ce n'est pas vraiment plus propre, mais cela montre un moyen de le regrouper dans une fonction sans perte:

def has_elements(iter):
  from itertools import tee
  iter, any_check = tee(iter)
  try:
    any_check.next()
    return True, iter
  except StopIteration:
    return False, iter

has_el, iter = has_elements(iter)
if has_el:
  # not empty

Ce n'est pas vraiment pythonique, et pour des cas particuliers, il existe probablement de meilleures solutions (mais moins générales), comme la prochaine valeur par défaut.

first = next(iter, None)
if first:
  # Do something

Ce n'est pas général car None peut être un élément valide dans de nombreux itérables.

vous pouvez utiliser:

if zip([None], iterator):
    # ...
else:
    # ...

mais c'est un peu non explicatif pour le lecteur de code

La meilleure façon de le faire est d'utiliser un peekablefichier from more_itertools.

from more_itertools import peekable
iterator = peekable(iterator)
if iterator:
    # Iterator is non-empty.
else:
    # Iterator is empty.

Méfiez-vous simplement si vous avez conservé les références de l'ancien itérateur, cet itérateur deviendra avancé. Vous devez utiliser le nouvel itérateur visible à partir de là. Vraiment, cependant, peekable s'attend à être le seul morceau de code modifiant cet ancien itérateur, vous ne devriez donc pas garder les références de l'ancien itérateur de toute façon.

Qu'en est-il de:

In [1]: i=iter([])

In [2]: bool(next(i,False))
Out[2]: False

In [3]: i=iter([1])

In [4]: bool(next(i,False))
Out[4]: True

__length_hint__ estime la longueur de list(it)- c'est une méthode privée, cependant:

x = iter( (1, 2, 3) )
help(x.__length_hint__)
      1 Help on built-in function __length_hint__:
      2 
      3 __length_hint__(...)
      4     Private method returning an estimate of len(list(it)).

C'est un wrapper d'itérateur excessif qui permet généralement de vérifier s'il y a un élément suivant (via la conversion en booléen). Bien sûr assez inefficace.

class LookaheadIterator ():

    def __init__(self, iterator):
        self.__iterator = iterator
        try:
            self.__next      = next (iterator)
            self.__have_next = True
        except StopIteration:
            self.__have_next = False

    def __iter__(self):
        return self

    def next (self):
        if self.__have_next:
            result = self.__next
            try:
                self.__next      = next (self.__iterator)
                self.__have_next = True
            except StopIteration:
                self.__have_next = False

            return result

        else:
            raise StopIteration

    def __nonzero__(self):
        return self.__have_next

x = LookaheadIterator (iter ([]))
print bool (x)
print list (x)

x = LookaheadIterator (iter ([1, 2, 3]))
print bool (x)
print list (x)

Production:

False
[]
True
[1, 2, 3]

Un peu tard, mais ... Vous pouvez transformer l'itérateur en liste et travailler avec cette liste:

# Create a list of objects but runs out the iterator.
l = [_ for _ in iterator]

# If the list is not empty then the iterator had elements; else it was empty.
if l :
    pass # Use the elements of the list (i.e. from the iterator)
else :
    pass # Iterator was empty, thus list is empty.