Bagaimana saya tahu jika generator kosong dari awal?

Apakah ada cara sederhana untuk menguji jika generator memiliki item, seperti peek, hasNext, isEmpty, sesuatu sepanjang garis?

Jawaban sederhana untuk pertanyaan Anda: tidak, tidak ada cara sederhana. Ada banyak pekerjaan di sekitar.

Seharusnya tidak ada cara yang sederhana, karena apa itu generator: cara untuk menghasilkan urutan nilai tanpa memegang urutan dalam memori . Jadi tidak ada traversal mundur.

Anda bisa menulis fungsi has_next atau bahkan mungkin menamparnya ke generator sebagai metode dengan dekorator mewah jika Anda mau.

Saran:

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

Pemakaian:

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.

Cara sederhana adalah dengan menggunakan parameter opsional untuk next () yang digunakan jika generator habis (atau kosong). Sebagai contoh:

iterable = some_generator()

_exhausted = object()

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

Sunting: Memperbaiki masalah yang ditunjukkan dalam komentar mehtunguh.

next(generator, None) is not None

Atau ganti Nonetetapi nilai apa pun yang Anda tahu itu tidak ada di generator Anda.

Sunting : Ya, ini akan melewati 1 item dalam generator. Namun, sering kali saya memeriksa apakah generator kosong hanya untuk keperluan validasi, maka jangan benar-benar menggunakannya. Atau kalau tidak, saya melakukan sesuatu seperti:

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

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

Artinya, ini berfungsi jika generator Anda berasal dari suatu fungsi , seperti pada generator().

Pendekatan terbaik, IMHO, akan menghindari tes khusus. Sering kali, penggunaan generator adalah tes:

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)

Jika itu tidak cukup baik, Anda masih dapat melakukan tes eksplisit. Pada titik ini, thingakan berisi nilai terakhir yang dihasilkan. Jika tidak ada yang dihasilkan, itu tidak akan ditentukan - kecuali Anda sudah mendefinisikan variabel. Anda bisa memeriksa nilainya thing, tapi itu agak tidak bisa diandalkan. Alih-alih, cukup atur bendera di dalam blok dan periksa setelahnya:

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

Saya benci untuk menawarkan solusi kedua, terutama yang saya tidak akan menggunakan sendiri, tetapi, jika Anda benar - benar harus melakukan ini dan tidak mengkonsumsi generator, seperti dalam jawaban lain:

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)

Sekarang saya benar-benar tidak menyukai solusi ini, karena saya percaya ini bukan bagaimana generator harus digunakan.

Saya menyadari bahwa pos ini sudah berusia 5 tahun pada saat ini, tetapi saya menemukannya saat mencari cara idiomatis untuk melakukan ini, dan tidak melihat solusi saya diposting. Jadi untuk anak cucu:

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)

Tentu saja, karena saya yakin banyak komentator akan menunjukkan, ini adalah hacky dan hanya berfungsi sama sekali dalam situasi terbatas tertentu (misalnya generator bebas efek samping, misalnya). YMMV.

Maaf atas pendekatan yang jelas, tetapi cara terbaik adalah melakukan:

for item in my_generator:
     print item

Sekarang Anda telah mendeteksi bahwa generator kosong saat Anda menggunakannya. Tentu saja, item tidak akan pernah ditampilkan jika generator kosong.

Ini mungkin tidak cocok dengan kode Anda, tetapi ini adalah ungkapan untuk generator: iterasi, jadi mungkin Anda mungkin sedikit mengubah pendekatan Anda, atau tidak menggunakan generator sama sekali.

Yang perlu Anda lakukan untuk melihat apakah generator kosong adalah mencoba untuk mendapatkan hasil selanjutnya. Tentu saja jika Anda tidak siap untuk menggunakan hasil itu maka Anda harus menyimpannya untuk mengembalikannya lagi nanti.

Berikut kelas pembungkus yang dapat ditambahkan ke iterator yang ada untuk menambahkan __nonzero__tes, sehingga Anda dapat melihat apakah generator kosong dengan sederhana if. Mungkin juga bisa diubah menjadi dekorator.

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)

Begini cara Anda menggunakannya:

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

Perhatikan bahwa Anda dapat memeriksa kekosongan setiap saat, tidak hanya pada awal iterasi.

Diminta oleh Mark Ransom, inilah kelas yang bisa Anda gunakan untuk membungkus iterator apa pun sehingga Anda bisa mengintip ke depan, mendorong nilai kembali ke aliran dan memeriksa kosong. Ini adalah ide sederhana dengan implementasi sederhana yang saya temukan sangat berguna di masa lalu.

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)

Hanya jatuh di utas ini dan menyadari bahwa jawaban yang sangat sederhana dan mudah dibaca hilang:

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

Jika kita tidak seharusnya mengkonsumsi item apa pun maka kita perlu menyuntikkan item pertama ke generator:

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

Contoh:

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

Pada akhir generator StopIterationdinaikkan, karena dalam kasus Anda akhir tercapai segera, pengecualian dinaikkan. Tetapi biasanya Anda tidak harus memeriksa keberadaan nilai berikutnya.

hal lain yang dapat Anda lakukan adalah:

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

Jika Anda perlu tahu sebelum menggunakan generator, maka tidak, tidak ada cara sederhana. Jika Anda bisa menunggu sampai setelah menggunakan generator, ada cara sederhana:

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

Cukup bungkus generator dengan itertools.chain , letakkan sesuatu yang akan mewakili akhir iterable sebagai iterable kedua, kemudian cukup periksa untuk itu.

Ex:

import itertools

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

Sekarang yang tersisa adalah untuk memeriksa nilai yang kita tambahkan ke akhir iterable, ketika Anda membacanya maka itu akan menandakan akhir

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

Dalam kasus saya, saya perlu tahu apakah sejumlah generator sudah diisi sebelum saya meneruskannya ke fungsi, yang menggabungkan item, yaitu zip(...),. Solusinya mirip, tetapi cukup berbeda, dari jawaban yang diterima:

Definisi:

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

Pemakaian:

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"

Masalah khusus saya memiliki properti bahwa iterables kosong atau memiliki jumlah entri yang persis sama.

Saya hanya menemukan solusi ini berfungsi untuk iterasi kosong juga.

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)

Atau jika Anda tidak ingin menggunakan pengecualian untuk ini coba gunakan

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)

Dalam solusi yang ditandai Anda tidak dapat menggunakannya untuk generator kosong seperti

def get_empty_generator():
    while False:
        yield None 

generator = get_empty_generator()

Ini adalah pertanyaan lama dan terjawab, tetapi karena tidak ada yang menunjukkan sebelumnya, ini dia:

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

Anda dapat membaca lebih lanjut di sini

Berikut ini adalah pendekatan sederhana saya yang saya gunakan untuk terus mengembalikan iterator sambil memeriksa apakah ada sesuatu yang dihasilkan. Saya hanya memeriksa apakah loop berjalan:

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

Berikut adalah dekorator sederhana yang membungkus generator, sehingga tidak menghasilkan apa-apa jika kosong. Ini bisa berguna jika kode Anda perlu tahu apakah generator akan menghasilkan sesuatu sebelum mengulanginya.

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

Pemakaian:

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

Salah satu contoh di mana ini berguna adalah dalam templating code - ie jinja2

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

menggunakan islice Anda hanya perlu memeriksa hingga iterasi pertama untuk mengetahui apakah isinya kosong.

dari itertools import islice

def isempty (iterable):
    daftar kembali (islice (iterable, 1)) == []

Bagaimana dengan menggunakan ()? Saya menggunakannya dengan generator dan berfungsi dengan baik. Di sini ada seorang pria yang menjelaskan sedikit tentang ini

Gunakan fungsi mengintip di 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

Iterator yang dikembalikan oleh fungsi ini akan sama dengan yang asli yang diteruskan sebagai argumen.

Saya menyelesaikannya dengan menggunakan fungsi penjumlahan. Lihat di bawah untuk contoh yang saya gunakan dengan glob.iglob (yang mengembalikan generator).

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

* Ini mungkin tidak akan berfungsi untuk generator BESAR tetapi harus berkinerja baik untuk daftar yang lebih kecil