Una riga per verificare se un iteratore produce almeno un elemento?

Attualmente sto facendo questo:

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

Ma vorrei un'espressione che posso inserire in una semplice ifdichiarazione. C'è qualcosa di integrato che renderebbe questo codice meno goffo?

any()restituisce Falsese un iterabile è vuoto, ma potenzialmente itererà su tutti gli elementi se non lo è. Mi serve solo per controllare il primo elemento.

Qualcuno mi chiede cosa sto cercando di fare. Ho scritto una funzione che esegue una query SQL e produce i suoi risultati. A volte, quando chiamo questa funzione, voglio solo sapere se la query ha restituito qualcosa e prendere una decisione in base a ciò.

anynon andrà oltre il primo elemento se è vero. Nel caso in cui l'iteratore produca qualcosa di falso, puoi scrivere any(True for _ in iterator).

In Python 2.6+, se name sentinelè vincolato a un valore che l'iteratore non può produrre,

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

Se non hai idea di cosa potrebbe produrre l'iteratore, crea la tua sentinella (ad esempio all'inizio del modulo) con

sentinel = object()

Altrimenti, potresti usare, nel ruolo di sentinella, qualsiasi valore che "conosci" (in base a considerazioni sull'applicazione) che l'iteratore non può cedere.

Questo non è molto più pulito, ma mostra un modo per impacchettarlo in una funzione senza perdite:

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

Questo non è realmente pitonico e, per casi particolari, ci sono probabilmente soluzioni migliori (ma meno generali), come il prossimo default.

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

Questo non è generale perché Nessuno può essere un elemento valido in molti iterabili.

Puoi usare:

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

ma è un po 'poco esplicativo per il lettore di codice

Il modo migliore per farlo è con un peekablefrom more_itertools.

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

Fai solo attenzione se hai mantenuto i riferimenti al vecchio iteratore, quell'iteratore diventerà avanzato. Da quel momento in poi dovrai utilizzare il nuovo iteratore visualizzabile. In realtà, però, peekable si aspetta di essere l'unico bit di codice che modifica quel vecchio iteratore, quindi non dovresti comunque mantenere i riferimenti al vecchio iteratore in giro.

Che dire:

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__ stima la durata di list(it)- è un metodo privato, però:

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

Questo è un wrapper iteratore eccessivo che generalmente consente di verificare se c'è un elemento successivo (tramite la conversione in booleano). Ovviamente piuttosto inefficiente.

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)

Produzione:

False
[]
True
[1, 2, 3]

Un po 'tardi, ma ... potresti trasformare l'iteratore in una lista e poi lavorare con quella 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.