Một lớp lót để kiểm tra xem một trình lặp có mang lại ít nhất một phần tử hay không?

Hiện tại tôi đang làm việc này:

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

Nhưng tôi muốn một biểu thức mà tôi có thể đặt bên trong một ifcâu lệnh đơn giản . Có điều gì được tích hợp sẵn sẽ làm cho mã này trông bớt vụng về hơn không?

any()trả về Falsenếu một mục có thể lặp lại trống, nhưng nó sẽ có khả năng lặp lại trên tất cả các mục nếu không. Tôi chỉ cần nó để kiểm tra mục đầu tiên.

Ai đó hỏi tôi đang cố gắng làm gì. Tôi đã viết một hàm thực thi truy vấn SQL và thu được kết quả của nó. Đôi khi khi tôi gọi hàm này, tôi chỉ muốn biết liệu truy vấn có trả lại bất kỳ điều gì hay không và đưa ra quyết định dựa trên đó.

anysẽ không vượt ra ngoài yếu tố đầu tiên nếu nó Đúng. Trong trường hợp trình lặp cho ra kết quả sai, bạn có thể viết any(True for _ in iterator).

Trong Python 2.6+, nếu tên sentinelđược liên kết với một giá trị mà trình lặp không thể mang lại,

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

Nếu bạn không biết trình lặp có thể mang lại kết quả gì, hãy tạo trạm gác của riêng bạn (ví dụ: ở đầu mô-đun của bạn) với

sentinel = object()

Nếu không, bạn có thể sử dụng, trong vai trò giám sát, bất kỳ giá trị nào mà bạn "biết" (dựa trên các cân nhắc ứng dụng) mà trình lặp không thể mang lại.

Điều này không thực sự rõ ràng hơn, nhưng nó cho thấy một cách để đóng gói nó trong một chức năng một cách dễ dàng:

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

Điều này không thực sự khó hiểu và đối với những trường hợp cụ thể, có lẽ có những giải pháp tốt hơn (nhưng ít chung chung hơn), như mặc định tiếp theo .

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

Điều này không chung chung vì Không có có thể là một phần tử hợp lệ trong nhiều vòng lặp.

bạn có thể dùng:

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

nhưng nó hơi phi lý đối với trình đọc mã

Cách tốt nhất để làm điều đó là với peekabletừ more_itertools.

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

Chỉ cần lưu ý nếu bạn giữ các tham chiếu đến trình lặp cũ, trình lặp đó sẽ được nâng cao. Từ đó trở đi, bạn phải sử dụng trình lặp có thể nhìn thấy mới. Tuy nhiên, thực sự, peekable hy vọng sẽ là bit mã duy nhất sửa đổi trình lặp cũ đó, vì vậy bạn không nên giữ các tham chiếu cho trình lặp cũ nằm xung quanh.

Thế còn:

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__ ước tính độ dài của list(it)- đó là phương pháp riêng tư, mặc dù:

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

Đây là một trình bao bọc trình lặp quá mức cần thiết thường cho phép kiểm tra xem có mục tiếp theo hay không (thông qua chuyển đổi sang boolean). Tất nhiên là khá kém hiệu quả.

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)

Đầu ra:

False
[]
True
[1, 2, 3]

Hơi muộn, nhưng ... Bạn có thể biến trình lặp thành một danh sách và sau đó làm việc với danh sách đó:

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