One-liner para verificar se um iterador produz pelo menos um elemento?

Atualmente estou fazendo isso:

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

Mas gostaria de uma expressão que pudesse colocar dentro de uma ifdeclaração simples . Existe algo integrado que tornaria este código menos desajeitado?

any()retorna Falsese um iterável estiver vazio, mas irá potencialmente iterar sobre todos os itens se não estiver. Eu só preciso verificar o primeiro item.

Alguém pergunta o que estou tentando fazer. Escrevi uma função que executa uma consulta SQL e produz seus resultados. Às vezes, quando chamo essa função, só quero saber se a consulta retornou algo e tomar uma decisão com base nisso.

anynão irá além do primeiro elemento se for True. No caso de o iterador gerar algo falso, você pode escrever any(True for _ in iterator).

No Python 2.6+, se o nome sentinelestiver vinculado a um valor que o iterador não pode produzir,

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

Se você não tem ideia do que o iterador pode produzir, faça seu próprio sentinela (por exemplo, no topo do seu módulo) com

sentinel = object()

Caso contrário, você poderia usar, na função de sentinela, qualquer valor que você "saiba" (com base nas considerações do aplicativo) que o iterador não pode produzir.

Isso não é realmente mais limpo, mas mostra uma maneira de empacotá-lo em uma função sem perdas:

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

Isso não é realmente pythônico e, para casos particulares, provavelmente existem soluções melhores (mas menos gerais), como o próximo padrão.

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

Isso não é geral porque None pode ser um elemento válido em muitos iteráveis.

você pode usar:

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

mas é um pouco não explicativo para o leitor de código

A melhor maneira de fazer isso é com um peekablede more_itertools.

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

Apenas tome cuidado se você mantiver as referências para o iterador antigo, pois ele se tornará avançado. Você tem que usar o novo iterador peekable a partir de então. Na verdade, porém, peekable espera ser o único pedaço de código modificando aquele antigo iterador, então você não deve manter referências para o antigo iterador por aí.

A respeito:

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 a duração de list(it)- é um método privado, embora:

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 é um invólucro de iterador exagerado que geralmente permite verificar se há um próximo item (via conversão para booleano). Claro, muito 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)

Resultado:

False
[]
True
[1, 2, 3]

Um pouco tarde, mas ... Você poderia transformar o iterador em uma lista e depois trabalhar com essa 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.