ฉันจะรู้ได้อย่างไรว่าตัวกำเนิดนั้นว่างเปล่าตั้งแต่เริ่มต้น?

มีวิธีที่ง่ายของการทดสอบถ้าเครื่องกำเนิดไฟฟ้าไม่มีรายการเช่น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!"

ฉันเกลียดที่จะเสนอทางออกที่สองโดยเฉพาะอย่างยิ่งที่ฉันจะไม่ใช้ตัวเอง แต่ถ้าคุณต้องทำอย่างนี้และไม่กินเครื่องกำเนิดไฟฟ้าเช่นเดียวกับคำตอบอื่น ๆ :

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

ตอนนี้คุณตรวจพบแล้วว่าตัวกำเนิดนั้นว่างเปล่าในขณะที่คุณกำลังใช้งาน แน่นอนว่ารายการจะไม่ปรากฏหากตัวกำเนิดนั้นว่างเปล่า

สิ่งนี้อาจไม่ตรงกับรหัสของคุณ แต่นี่คือสิ่งที่สำนวนของเครื่องกำเนิดไฟฟ้าสำหรับ: ซ้ำดังนั้นบางทีคุณอาจเปลี่ยนวิธีการของคุณเล็กน้อยหรือไม่ใช้เครื่องกำเนิดไฟฟ้าเลย

สิ่งที่คุณต้องทำเพื่อดูว่าตัวกำเนิดนั้นว่างเปล่าคือพยายามรับผลการค้นหาถัดไป แน่นอนถ้าคุณยังไม่พร้อมที่จะใช้ผลลัพธ์นั้นคุณต้องเก็บมันไว้เพื่อส่งคืนอีกครั้งในภายหลัง

นี่คือคลาสของ wrapper ที่สามารถเพิ่มลงในตัววนซ้ำที่มีอยู่เพื่อเพิ่มการ__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ใส่สิ่งที่จะแสดงจุดสิ้นสุดของ iterable เป็น iterable ตัวที่สองจากนั้นเพียงตรวจสอบสิ่งนั้น

Ex:

import itertools

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

ตอนนี้สิ่งที่เหลืออยู่คือการตรวจสอบค่าที่เราผนวกเข้ากับส่วนท้ายของ iterable เมื่อคุณอ่านแล้วมันจะหมายถึงจุดสิ้นสุด

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"

ปัญหาเฉพาะของฉันมีคุณสมบัติที่ iterables ว่างเปล่าหรือมีจำนวนรายการเท่ากันทุกประการ

ฉันพบโซลูชันนี้เฉพาะสำหรับการทำซ้ำที่ว่างเปล่าเช่นกัน

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

ตัวอย่างหนึ่งที่สิ่งนี้มีประโยชน์คือในรหัสการสร้างเทมเพลต - เช่น jinja2

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

ใช้ islice คุณต้องตรวจสอบซ้ำครั้งแรกเพื่อดูว่าว่างหรือไม่

จาก itertools นำเข้า islice

def isempty (iterable):
    รายการส่งคืน (islice (iterable, 1)) == []

แล้วการใช้ใด ๆ () ฉันใช้กับเครื่องกำเนิดไฟฟ้าและมันก็ใช้ได้ดีที่นี่มีคนอธิบายเล็ก ๆ น้อย ๆ เกี่ยวกับเรื่องนี้

ใช้แอบฟังก์ชั่นใน 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

ตัววนซ้ำที่ส่งคืนโดยฟังก์ชันนี้จะเทียบเท่ากับต้นฉบับที่ส่งผ่านเป็นอาร์กิวเมนต์

ฉันแก้ไขมันโดยใช้ฟังก์ชั่นผลรวม ดูตัวอย่างด้านล่างที่ฉันใช้กับ glob.iglob (ซึ่งส่งคืนตัวกำเนิด)

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

* สิ่งนี้อาจไม่ทำงานสำหรับเครื่องกำเนิดไฟฟ้าขนาดใหญ่ แต่ควรทำงานได้ดีกับรายการขนาดเล็ก