Jedna linijka, aby sprawdzić, czy iterator daje co najmniej jeden element?

Obecnie robię to:

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

Ale chciałbym wyrażenia, które mogę umieścić w prostym ifstwierdzeniu. Czy jest coś wbudowanego, co sprawiłoby, że ten kod wyglądałby mniej niezgrabnie?

any()zwraca, Falsejeśli element iterowalny jest pusty, ale potencjalnie będzie iterował po wszystkich elementach, jeśli tak nie jest. Potrzebuję go tylko do sprawdzenia pierwszej pozycji.

Ktoś pyta, co próbuję zrobić. Napisałem funkcję, która wykonuje zapytanie SQL i daje jej wyniki. Czasami, gdy wywołuję tę funkcję, chcę tylko wiedzieć, czy zapytanie zwróciło cokolwiek, i na tej podstawie podjąć decyzję.

anynie wykroczy poza pierwszy element, jeśli to prawda. W przypadku, gdy iterator daje coś fałszywego, możesz napisać any(True for _ in iterator).

W Pythonie 2.6+, jeśli nazwa sentineljest powiązana z wartością, której iterator nie może uzyskać,

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

Jeśli nie masz pojęcia, co może dać iterator, stwórz swój własny wartownik (np. Na górze modułu) z

sentinel = object()

W przeciwnym razie możesz użyć w roli wartownika dowolnej wartości, którą „znasz” (na podstawie rozważań aplikacji), a której iterator nie może uzyskać.

Nie jest to naprawdę czystsze, ale pokazuje sposób na bezstratne spakowanie go w funkcję:

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

To nie jest do końca Pythonowe, aw niektórych przypadkach prawdopodobnie istnieją lepsze (ale mniej ogólne) rozwiązania, takie jak następne domyślne.

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

Nie jest to ogólne, ponieważ None może być prawidłowym elementem w wielu iterowalnych.

możesz użyć:

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

ale jest to trochę niewyjaśnione dla czytnika kodów

Najlepszym sposobem na to jest użycie peekableod more_itertools.

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

Po prostu uważaj, jeśli zachowałeś odniesienia do starego iteratora, że ​​iterator będzie zaawansowany. Od tego momentu musisz używać nowego iteratora podglądu. Naprawdę jednak, peekable spodziewa się, że będzie jedynym fragmentem kodu modyfikującym ten stary iterator, więc i tak nie powinieneś przechowywać referencji do starego iteratora.

Co powiesz na:

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__ szacuje długość list(it)- to jednak metoda prywatna:

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

Jest to overkill iterator wrapper, który generalnie pozwala sprawdzić, czy istnieje następny element (poprzez konwersję na boolean). Oczywiście dość nieefektywne.

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)

Wynik:

False
[]
True
[1, 2, 3]

Trochę późno, ale ... Możesz zmienić iterator w listę, a następnie pracować z tą listą:

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