Làm thế nào để tôi biết nếu một máy phát điện trống từ đầu?

Có một cách đơn giản để kiểm tra nếu máy phát điện không có mặt hàng, như peek, hasNext, isEmpty, một cái gì đó dọc theo những đường?

Câu trả lời đơn giản cho câu hỏi của bạn: không, không có cách nào đơn giản. Có rất nhiều công việc xung quanh.

Thực sự không nên có một cách đơn giản, bởi vì các trình tạo là gì: một cách để tạo ra một chuỗi các giá trị mà không giữ chuỗi trong bộ nhớ . Vì vậy, không có truyền thống lạc hậu.

Bạn có thể viết hàm has_next hoặc thậm chí có thể đưa nó vào trình tạo như một phương thức với trình trang trí lạ mắt nếu bạn muốn.

Gợi ý:

def peek(iterable):
    try:
        first = next(iterable)
    except StopIteration:
        return None
    return first, itertools.chain([first], iterable)

Sử dụng:

res = peek(mysequence)
if res is None:
    # sequence is empty.  Do stuff.
else:
    first, mysequence = res
    # Do something with first, maybe?
    # Then iterate over the sequence:
    for element in mysequence:
        # etc.

Một cách đơn giản là sử dụng tham số tùy chọn cho next () được sử dụng nếu trình tạo hết (hoặc trống). Ví dụ:

iterable = some_generator()

_exhausted = object()

if next(iterable, _exhausted) == _exhausted:
    print('generator is empty')

Chỉnh sửa: Khắc phục sự cố được chỉ ra trong nhận xét của mehtunguh.

next(generator, None) is not None

Hoặc thay thế Nonenhưng bất kỳ giá trị nào bạn biết nó không có trong máy phát điện của bạn.

Chỉnh sửa : Có, điều này sẽ bỏ qua 1 mục trong trình tạo. Tuy nhiên, thường thì tôi kiểm tra xem một trình tạo có trống chỉ cho mục đích xác nhận hay không, sau đó không thực sự sử dụng nó. Hoặc nếu không tôi làm một cái gì đó như:

def foo(self):
    if next(self.my_generator(), None) is None:
        raise Exception("Not initiated")

    for x in self.my_generator():
        ...

Đó là, điều này hoạt động nếu trình tạo của bạn đến từ một chức năng , như trong generator().

Cách tiếp cận tốt nhất, IMHO, sẽ là tránh một bài kiểm tra đặc biệt. Hầu hết các lần, sử dụng máy phát điện là thử nghiệm:

thing_generated = False

# Nothing is lost here. if nothing is generated, 
# the for block is not executed. Often, that's the only check
# you need to do. This can be done in the course of doing
# the work you wanted to do anyway on the generated output.
for thing in my_generator():
    thing_generated = True
    do_work(thing)

Nếu điều đó không đủ tốt, bạn vẫn có thể thực hiện một bài kiểm tra rõ ràng. Tại thời điểm này, thingsẽ chứa giá trị cuối cùng được tạo. Nếu không có gì được tạo, nó sẽ không được xác định - trừ khi bạn đã xác định biến. Bạn có thể kiểm tra giá trị của thing, nhưng điều đó không đáng tin cậy một chút. Thay vào đó, chỉ cần đặt cờ trong khối và kiểm tra nó sau đó:

if not thing_generated:
    print "Avast, ye scurvy dog!"

Tôi ghét đưa ra một giải pháp thứ hai, đặc biệt là giải pháp mà tôi sẽ không sử dụng cho mình, nhưng, nếu bạn hoàn toàn phải làm điều này và không tiêu thụ máy phát điện, như trong các câu trả lời khác:

def do_something_with_item(item):
    print item

empty_marker = object()

try:
     first_item = my_generator.next()     
except StopIteration:
     print 'The generator was empty'
     first_item = empty_marker

if first_item is not empty_marker:
    do_something_with_item(first_item)
    for item in my_generator:
        do_something_with_item(item)

Bây giờ tôi thực sự không thích giải pháp này, vì tôi tin rằng đây không phải là cách sử dụng máy phát điện.

Tôi nhận ra rằng bài đăng này đã 5 tuổi vào thời điểm này, nhưng tôi đã tìm thấy nó trong khi tìm kiếm một cách thành ngữ để làm điều này, và không thấy giải pháp của tôi được đăng. Vì vậy, cho hậu thế:

import itertools

def get_generator():
    """
    Returns (bool, generator) where bool is true iff the generator is not empty.
    """
    gen = (i for i in [0, 1, 2, 3, 4])
    a, b = itertools.tee(gen)
    try:
        a.next()
    except StopIteration:
        return (False, b)
    return (True, b)

Tất nhiên, như tôi chắc chắn rằng nhiều nhà bình luận sẽ chỉ ra, đây là hacky và chỉ hoạt động ở tất cả các tình huống hạn chế nhất định (ví dụ như các máy phát điện không có tác dụng phụ). YMMV.

Xin lỗi vì cách tiếp cận rõ ràng, nhưng cách tốt nhất sẽ là:

for item in my_generator:
     print item

Bây giờ bạn đã phát hiện ra rằng trình tạo trống trong khi bạn đang sử dụng nó. Tất nhiên, mục sẽ không bao giờ được hiển thị nếu trình tạo trống.

Điều này có thể không hoàn toàn phù hợp với mã của bạn, nhưng đây là thành ngữ của trình tạo là: lặp đi lặp lại, vì vậy có lẽ bạn có thể thay đổi cách tiếp cận của mình một chút hoặc hoàn toàn không sử dụng trình tạo.

Tất cả những gì bạn cần làm để xem máy phát điện có trống không là cố gắng để có kết quả tiếp theo. Tất nhiên nếu bạn chưa sẵn sàng sử dụng kết quả đó thì bạn phải lưu nó để trả lại sau.

Đây là một lớp bao bọc có thể được thêm vào một trình vòng lặp hiện có để thêm một __nonzero__bài kiểm tra, vì vậy bạn có thể xem liệu trình tạo có trống không với một đơn giản if. Nó có lẽ cũng có thể được biến thành một trang trí.

class GenWrapper:
    def __init__(self, iter):
        self.source = iter
        self.stored = False

    def __iter__(self):
        return self

    def __nonzero__(self):
        if self.stored:
            return True
        try:
            self.value = next(self.source)
            self.stored = True
        except StopIteration:
            return False
        return True

    def __next__(self):  # use "next" (without underscores) for Python 2.x
        if self.stored:
            self.stored = False
            return self.value
        return next(self.source)

Đây là cách bạn sử dụng nó:

with open(filename, 'r') as f:
    f = GenWrapper(f)
    if f:
        print 'Not empty'
    else:
        print 'Empty'

Lưu ý rằng bạn có thể kiểm tra sự trống rỗng bất cứ lúc nào, không chỉ khi bắt đầu lặp lại.

Được nhắc nhở bởi Mark Ransom, đây là một lớp mà bạn có thể sử dụng để bọc bất kỳ trình vòng lặp nào để bạn có thể nhìn trộm phía trước, đẩy các giá trị trở lại luồng và kiểm tra trống. Đó là một ý tưởng đơn giản với cách thực hiện đơn giản mà trước đây tôi thấy rất tiện dụng.

class Pushable:

    def __init__(self, iter):
        self.source = iter
        self.stored = []

    def __iter__(self):
        return self

    def __bool__(self):
        if self.stored:
            return True
        try:
            self.stored.append(next(self.source))
        except StopIteration:
            return False
        return True

    def push(self, value):
        self.stored.append(value)

    def peek(self):
        if self.stored:
            return self.stored[-1]
        value = next(self.source)
        self.stored.append(value)
        return value

    def __next__(self):
        if self.stored:
            return self.stored.pop()
        return next(self.source)

Chỉ cần rơi vào chủ đề này và nhận ra rằng một câu trả lời rất đơn giản và dễ đọc đã bị thiếu:

def is_empty(generator):
    for item in generator:
        return False
    return True

Nếu chúng ta không giả sử tiêu thụ bất kỳ vật phẩm nào thì chúng ta cần phải tiêm lại vật phẩm đầu tiên vào máy phát điện:

def is_empty_no_side_effects(generator):
    try:
        item = next(generator)
        def my_generator():
            yield item
            yield from generator
        return my_generator(), False
    except StopIteration:
        return (_ for _ in []), True

Thí dụ:

>>> g=(i for i in [])
>>> g,empty=is_empty_no_side_effects(g)
>>> empty
True
>>> g=(i for i in range(10))
>>> g,empty=is_empty_no_side_effects(g)
>>> empty
False
>>> list(g)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> gen = (i for i in [])
>>> next(gen)
Traceback (most recent call last):
  File "<pyshell#43>", line 1, in <module>
    next(gen)
StopIteration

Khi kết thúc trình tạo StopIterationđược nâng lên, vì trong trường hợp của bạn kết thúc ngay lập tức, ngoại lệ được đưa ra. Nhưng thông thường, bạn không nên kiểm tra sự tồn tại của giá trị tiếp theo.

một điều khác bạn có thể làm là:

>>> gen = (i for i in [])
>>> if not list(gen):
    print('empty generator')

Nếu bạn cần biết trước khi sử dụng trình tạo, thì không, không có cách nào đơn giản. Nếu bạn có thể đợi cho đến khi bạn sử dụng trình tạo, có một cách đơn giản:

was_empty = True

for some_item in some_generator:
    was_empty = False
    do_something_with(some_item)

if was_empty:
    handle_already_empty_generator_case()

Đơn giản chỉ cần bọc trình tạo bằng itertools.chain , đặt một cái gì đó sẽ đại diện cho phần cuối của lần lặp là lần lặp thứ hai, sau đó chỉ cần kiểm tra xem.

Ví dụ:

import itertools

g = some_iterable
eog = object()
wrap_g = itertools.chain(g, [eog])

Bây giờ tất cả những gì còn lại là để kiểm tra giá trị đó mà chúng tôi đã thêm vào cuối của lần lặp, khi bạn đọc nó thì điều đó sẽ biểu thị sự kết thúc

for value in wrap_g:
    if value == eog: # DING DING! We just found the last element of the iterable
        pass # Do something

Trong trường hợp của tôi, tôi cần phải biết liệu một loạt các máy phát điện có được đưa vào hay không trước khi tôi chuyển nó sang một hàm, hợp nhất các mục, tức là , zip(...). Giải pháp tương tự, nhưng đủ khác nhau, từ câu trả lời được chấp nhận:

Định nghĩa:

def has_items(iterable):
    try:
        return True, itertools.chain([next(iterable)], iterable)
    except StopIteration:
        return False, []

Sử dụng:

def filter_empty(iterables):
    for iterable in iterables:
        itr_has_items, iterable = has_items(iterable)
        if itr_has_items:
            yield iterable


def merge_iterables(iterables):
    populated_iterables = filter_empty(iterables)
    for items in zip(*populated_iterables):
        # Use items for each "slice"

Vấn đề cụ thể của tôi có thuộc tính là các iterables trống hoặc có chính xác cùng số lượng mục nhập.

Tôi chỉ tìm thấy giải pháp này khi làm việc cho các lần lặp trống.

def is_generator_empty(generator):
    a, b = itertools.tee(generator)
    try:
        next(a)
    except StopIteration:
        return True, b
    return False, b

is_empty, generator = is_generator_empty(generator)

Hoặc nếu bạn không muốn sử dụng ngoại lệ cho việc này hãy thử sử dụng

def is_generator_empty(generator):
    a, b = itertools.tee(generator)
    for item in a:
        return False, b
    return True, b

is_empty, generator = is_generator_empty(generator)

Trong giải pháp được đánh dấu, bạn không thể sử dụng nó cho các trình tạo trống như

def get_empty_generator():
    while False:
        yield None 

generator = get_empty_generator()

Đây là một câu hỏi cũ và đã được trả lời, nhưng như chưa có ai trình bày trước đây, nên đây là:

for _ in generator:
    break
else:
    print('Empty')

Bạn có thể đọc thêm ở đây

Đây là cách tiếp cận đơn giản của tôi mà tôi sử dụng để tiếp tục trả về một trình vòng lặp trong khi kiểm tra xem có cái gì mang lại không, tôi chỉ kiểm tra xem vòng lặp có chạy không:

        n = 0
        for key, value in iterator:
            n+=1
            yield key, value
        if n == 0:
            print ("nothing found in iterator)
            break

Đây là một trình trang trí đơn giản bao bọc trình tạo, vì vậy nó trả về Không nếu trống. Điều này có thể hữu ích nếu mã của bạn cần biết liệu trình tạo sẽ tạo ra bất cứ thứ gì trước khi lặp qua nó.

def generator_or_none(func):
    """Wrap a generator function, returning None if it's empty. """

    def inner(*args, **kwargs):
        # peek at the first item; return None if it doesn't exist
        try:
            next(func(*args, **kwargs))
        except StopIteration:
            return None

        # return original generator otherwise first item will be missing
        return func(*args, **kwargs)

    return inner

Sử dụng:

import random

@generator_or_none
def random_length_generator():
    for i in range(random.randint(0, 10)):
        yield i

gen = random_length_generator()
if gen is None:
    print('Generator is empty')

Một ví dụ trong đó điều này hữu ích là trong mã tạo khuôn mẫu - tức là jinja2

{% if content_generator %}
  <section>
    <h4>Section title</h4>
    {% for item in content_generator %}
      {{ item }}
    {% endfor %
  </section>
{% endif %}

bằng cách sử dụng islice, bạn chỉ cần kiểm tra lần lặp đầu tiên để khám phá nếu nó trống.

từ itertools nhập islice

def isempty (iterable):
    danh sách trả về (islice (iterable, 1)) == []

Điều gì về việc sử dụng bất kỳ ()? Tôi sử dụng nó với máy phát điện và nó hoạt động tốt. Ở đây có anh chàng giải thích một chút về điều này

Sử dụng chức năng peek trong cytoolz.

from cytoolz import peek
from typing import Tuple, Iterable

def is_empty_iterator(g: Iterable) -> Tuple[Iterable, bool]:
    try:
        _, g = peek(g)
        return g, False
    except StopIteration:
        return g, True

Trình lặp được trả về bởi hàm này sẽ tương đương với hàm ban đầu được truyền vào dưới dạng đối số.

Tôi đã giải quyết nó bằng cách sử dụng hàm sum. Xem bên dưới để biết ví dụ tôi đã sử dụng với global.iglob (trả về một trình tạo).

def isEmpty():
    files = glob.iglob(search)
    if sum(1 for _ in files):
        return True
    return False

* Điều này có thể sẽ không hoạt động cho các trình tạo HUGE nhưng sẽ hoạt động tốt cho các danh sách nhỏ hơn