¿Una línea para comprobar si un iterador produce al menos un elemento?

Actualmente estoy haciendo esto:

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

Pero me gustaría una expresión que pueda colocar dentro de una ifdeclaración simple . ¿Hay algo integrado que haga que este código parezca menos torpe?

any()devuelve Falsesi un iterable está vacío, pero potencialmente iterará sobre todos los elementos si no lo está. Solo lo necesito para comprobar el primer elemento.

Alguien pregunta qué estoy tratando de hacer. He escrito una función que ejecuta una consulta SQL y produce sus resultados. A veces, cuando llamo a esta función, solo quiero saber si la consulta devolvió algo y tomar una decisión basada en eso.

anyno irá más allá del primer elemento si es True. En caso de que el iterador produzca algo falso, puede escribir any(True for _ in iterator).

En Python 2.6+, si el nombre sentinelestá vinculado a un valor que el iterador no puede producir,

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

Si no tiene idea de lo que posiblemente podría producir el iterador, cree su propio centinela (por ejemplo, en la parte superior de su módulo) con

sentinel = object()

De lo contrario, podría utilizar, en el rol de centinela, cualquier valor que "conozca" (según las consideraciones de la aplicación) que el iterador no pueda obtener.

Esto no es realmente más limpio, pero muestra una forma de empaquetarlo en una función sin pérdidas:

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

Esto no es realmente pitónico y, para casos particulares, probablemente haya soluciones mejores (pero menos generales), como la siguiente predeterminada.

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

Esto no es general porque None puede ser un elemento válido en muchos iterables.

puedes usar:

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

pero es un poco inexplicable para el lector de código

La mejor forma de hacerlo es con un peekablefrom more_itertools.

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

Solo tenga cuidado si mantuvo referencias al antiguo iterador, ese iterador avanzará. Tienes que usar el nuevo iterador visible a partir de ese momento. Realmente, sin embargo, peekable espera ser el único fragmento de código que modifique ese antiguo iterador, por lo que no debería mantener referencias al antiguo iterador de todos modos.

Qué pasa:

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__ estima la longitud de list(it)su método privado, aunque:

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

Este es un contenedor de iterador exagerado que generalmente permite verificar si hay un elemento siguiente (a través de la conversión a booleano). Por supuesto bastante ineficiente.

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)

Salida:

False
[]
True
[1, 2, 3]

Un poco tarde, pero ... podría convertir el iterador en una lista y luego trabajar con esa lista:

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