ジェネレーターが最初から空であるかどうかはどうすればわかりますか？

発電機は何のアイテムを持っていない場合と同様に、テストする簡単な方法がありpeek、hasNext、isEmptyこれらの線に沿って何かが？

あなたの質問に対する簡単な答え：いいえ、簡単な方法はありません。回避策はたくさんあります。

ジェネレータとは何かという理由から、実際には単純な方法はありません。シーケンスをメモリに保持せずに値のシーケンスを出力する方法。したがって、逆方向のトラバーサルはありません。

必要に応じて、has_next関数を記述したり、ファンシーなデコレータを持つメソッドとしてジェネレータにスラップしたりすることもできます。

提案：

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

使用法：

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.

簡単な方法は、ジェネレータが使い果たされた（または空の）場合に使用されるnext（）のオプションパラメータを使用することです。例えば：

iterable = some_generator()

_exhausted = object()

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

編集：mehtunguhのコメントで指摘された問題を修正しました。

next(generator, None) is not None

または置き換えますが、ジェネレータにないNoneことがわかっている値はすべて置き換えます。

編集：はい、ジェネレーターで1項目をスキップします。ただし、検証の目的でのみジェネレータが空であるかどうかを確認し、実際には使用しないことがよくあります。あるいは、私は次のようなことをします：

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

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

つまり、これは、のように、ジェネレーターが関数からのものである場合に機能しgenerator()ます。

最良のアプローチであるIMHOは、特別なテストを回避することです。ほとんどの時間、発電機の使用があるテスト：

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)

それでも十分でない場合でも、明示的なテストを実行できます。この時点で、thing生成された最後の値が含まれます。何も生成されなかった場合、変数はすでに定義されていない限り、未定義になります。の値を確認することもできますがthing、これは少し信頼できません。代わりに、ブロック内にフラグを設定し、後で確認するだけです。

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

私は自分自身を使用しないこと、特に1秒のソリューションを、提供することを嫌い、しかし、あなたは絶対にあれば持っていたこれを行うにし、他の回答のように、発電機を消費しないために：

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)

これがジェネレーターの使用方法ではないと私が信じているので、今、私はこのソリューションが本当に好きではありません。

この投稿は現時点で5年前のものであることに気づきましたが、これを行う慣用的な方法を探しているときに見つけ、解決策が投稿されていませんでした。後世のために：

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)

もちろん、多くのコメンテーターが指摘するように、これはハックであり、特定の限られた状況（例えば、ジェネレーターに副作用がない場合）でのみ機能します。YMMV。

明らかなアプローチで申し訳ありませんが、最善の方法は次のようにすることです：

for item in my_generator:
     print item

これで、使用中にジェネレーターが空であることを検出しました。もちろん、ジェネレーターが空の場合、アイテムは表示されません。

これはコードに正確に適合しない場合がありますが、これはジェネレーターのイディオムの目的です：反復するため、アプローチを少し変更するか、ジェネレーターをまったく使用しない可能性があります。

ジェネレータが空かどうかを確認するために必要なのは、次の結果を取得することです。もちろん、その結果を使用する準備ができていない場合は、後で再び返すために保存する必要があります。

これは、既存のイテレータに追加して__nonzero__テストを追加できるラッパークラスですif。シンプルなでジェネレータが空かどうかを確認できます。それはおそらくデコレータにもなります。

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)

使用方法は次のとおりです。

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

反復の開始時だけでなく、いつでも空をチェックできることに注意してください。

Mark Ransomによって促されたクラスを次に示します。イテレータをラップして、先に調べ、値をストリームにプッシュして戻し、空を確認できるようにします。これは、過去に非常に便利だと思ったシンプルな実装のシンプルなアイデアです。

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)

このスレッドに落ちて、非常にシンプルで読みやすい答えが欠けていることに気づきました：

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

アイテムを消費することを想定していない場合は、最初のアイテムをジェネレーターに再注入する必要があります。

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

例：

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

ジェネレータの最後で発生StopIterationします。あなたの場合、すぐに終わりに到達するので、例外が発生します。しかし、通常、次の値の存在を確認するべきではありません。

あなたができる別のことは：

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

ジェネレータを使用する前に知っておく必要がある場合は、いいえ、簡単な方法はありません。あなたがされるまで待つことができる場合は後に、あなたが発電機を使用している、簡単な方法があります：

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

単にジェネレーターをitertools.chainでラップし、イテラブルの終わりを表すものを2番目のイテラブルとして置き、それをチェックするだけです。

例：

import itertools

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

あとは、イテラブルの最後に追加した値を確認するだけです。それを読んだら、それが終わりを示します。

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

私の場合、アイテムをマージする関数に渡す前に、ジェネレータのホストが設定されているかどうかを知る必要がありましたzip(...)。解決策は似ていますが、受け入れられた回答とは十分に異なります。

定義：

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

使用法：

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"

私の特定の問題には、反復可能オブジェクトが空であるか、まったく同じ数のエントリがあるという特性があります。

このソリューションだけが空の反復でも機能することがわかりました。

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)

または、これに例外を使用したくない場合は、使用してみてください

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)

でマークソリューション次のような空の発電機のためにそれを使用することはできません

def get_empty_generator():
    while False:
        yield None 

generator = get_empty_generator()

これは古くて答えられた質問ですが、誰もそれを以前に示したことがないので、ここに行きます：

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

あなたはここでもっと読むことができます

これは、何かが生成されたかどうかを確認しながらイテレータを返し続けるために使用する私の単純なアプローチです。ループが実行されるかどうかを確認するだけです。

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

ジェネレータをラップする単純なデコレータを次に示します。空の場合はNoneを返します。これは、ジェネレーターがループする前にジェネレーターが何かを生成するかどうかをコードが知る必要がある場合に役立ちます。

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

使用法：

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

これが有用な1つの例は、コードをテンプレート化することです-すなわちjinja2

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

isliceを使用すると、最初の反復までチェックして、空かどうかを確認するだけで済みます。

itertools import isliceから

def isempty（iterable）：
    return list（islice（iterable、1））== []

any（）の使用についてはどうですか？私はジェネレーターでそれを使用し、それはうまくいきます。ここでこれについて少し説明している男がいます

サイトールズのピーク関数を使用します。

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

この関数が返すイテレータは、引数として渡された元のイテレータと同じです。

sum関数で解決しました。ジェネレーターを返すglob.iglobで使用した例については、以下を参照してください。

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

*これはおそらく巨大なジェネレーターでは機能しませんが、小さなリストではうまく機能するはずです。