Python3中生成器介绍

Posted 2021-09-27 fengbingchun

      生成器(generator)：一个返回生成器迭代器的函数。它看起来像一个普通函数，除了它包含用于生成一系列可在for循环中使用的值的yield表达式或者可以使用next函数一次检索一个值。

      在Python中，使用了yield的函数被称为生成器。跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作。生成器函数一般是通过for循环调用，for循环自带next方法。

      生成器迭代器(generator iterator)：由生成器函数(generator function)创建的对象。每个yield暂时挂起处理，记住位置执行状态(包括局部变量和挂起的try语句)。当生成器迭代器恢复时，它从停止的地方开始(与每次调用都重新开始的函数相反)。

      生成器表达式(generator expression)：返回迭代器的表达式。它看起来像一个普通表达式，后跟一个定义循环变量、范围和可选if子句的for子句。

      yield 表达式(yield expression)：用在定义生成器函数或异步生成器函数，它只能在函数定义体中使用。在函数体中使用yield表达式会使该函数成为生成器。

      当一个生成器函数被调用时，它返回一个称为生成器的迭代器。该生成器控制生成器函数的执行。当调用生成器的任一方法时，执行开始。此时，继续执行第一个yield表达式，在那里它再次挂起，将expression_list的值返回给生成器的调用者。挂起是指保留所有局部状态，包括局部变量的当前绑定、指令指针、内部计算堆栈以及任何异常处理的状态。当通过调用生成器的任一方法恢复执行时，该函数可以像yield表达式被另一个外部调用继续执行。恢复后的yield表达式的值取决于恢复执行的方法。如果使用__next()__(通常通过for或next()内置函数)，则结果为None。否则，如果使用send()，则结果将是传递给该方法的值。

      在try结构中的任何地方都允许使用yield表达式。如果生成器在完成之前没有恢复，生成器迭代器的close()方法将被调用，允许任何挂起的finally子句执行。

      当使用yield from <expr>时，提供的表达式必须是可迭代的。迭代产生的值直接传递给当前生成器方法的调用者。如果底层迭代器有适当的方法，任何用send()传入的值和用throw()传入的任何异常都被传递给底层迭代器。如果不是这种情况，则send()将触发AttributeError或TypeError，而throw()将立即触发传入的异常。当底层迭代器完成时，触发的StopIteration实例的value属性成为yield表达式的值。它可以在触发StopIteration时显式设置，也可以在子迭代器是生成器时自动设置。

      yield语句：在语义上等同于yield表达式。yield表达式和语句仅用在定义生成器函数中。在函数中使用yield便会创建生成器函数。

      yield语句暂停函数的执行并将一个值发送回调用者，但保留足够的状态以使函数能够从停止的地方恢复。恢复后，该函数会在最后一次yield运行后立即继续执行。这允许它的代码随着时间的推移产生一系列值，而不是一次计算它们并像列表一样发送它们。

      当yield表达式是赋值语句右侧的唯一表达式时，可以省略括号。

      生成器迭代器方法：它们可用于控制生成器函数的执行。当生成器已经在执行时调用下面的任何生成器方法都会触发ValueError异常。

      (1).generator.__next__()：开始执行生成器函数或在最后一次执行的yield表达式处继续执行。当使用__next__()方法恢复生成器函数时，当前的yield表达式总是计算为None。然后继续执行下一个yield表达式，在那里生成器再次挂起，并且expression_list的值返回给__next__()的调用者。如果生成器退出而没有产生另一个值，则会触发StopIteration异常。此方法通常被隐式调用，例如通过for循环或内置的next()函数。

      (2).generator.send(value)：恢复执行并将value ”sends”到生成器函数中。value参数成为当前yield表达式的结果。send()方法返回生成器生成的下一个值，或者如果生成器退出而没有生成另一个值则触发StopIteration。当调用send()来启动生成器时，必须以None作为参数调用它，因为没有可以接收值的yield表达式。

      (3).generator.throw(type[, value[, traceback]])：在生成器暂停时触发类型的异常，并返回生成器函数产生的下一个值。如果生成器退出而没有产生另一个值，则会触发StopIteration异常。如果生成器函数没有捕获传入的异常，或者触发不同的异常，则该异常会传递给调用者。

      (4).generator.close()：在生成器函数暂停的位置触发GeneratorExit。如果生成器函数随后正常退出、已关闭或触发GeneratorExit，则close返回到其调用者。如果生成器产生一个值，则会触发RuntimeError。如果生成器触发任何其它异常，则会将其传递给调用者。如果生成器由于异常或正常退出而退出，则close()不执行任何操作。

      以上内容主要翻译于：7. Simple statements — Python 3.9.7 documentation

     测试代码如下：

var = 1
if var == 1:
    # reference: https://docs.python.org/3/reference/expressions.html#yieldexpr
    def echo(value=None):
        print("Execution starts when 'next()' is called for the first time.")
        try:
            while True:
                try:
                    value = (yield value)
                    print("value:", value)
                except Exception as e:
                    value = e
        finally:
            print("Don't forget to clean up when 'close()' is called.")

    generator = echo(1) # 此处echo函数并未真的执行,返回generator对象
    print("object:", generator)
    print(next(generator)) # 当调用next或__next__时,echo函数才正式开始执行
    print(next(generator))
    print("start send"); print(generator.send(10)); print("end send")
    generator.throw(TypeError, "spam")
    generator.close()
elif var == 2:
    # reference: https://stackoverflow.com/questions/231767/what-does-the-yield-keyword-do
    mylist = [x*x for x in range(3)]  # mylist is an iterable,  you store all the values in memory
    for i in mylist:
        print(i)

    # Generators are iterators, a kind of iterable you can only iterate over once.
    # Generators do not store all the values in memory, they generate the values on the fly
    mygenerator = (x*x for x in range(3))
    for i in mygenerator:
        print(i)
    for i in mygenerator:
        print(i) # 第二次for in不会有任何值输出, generators can only be used once

    # yield is a keyword that is used like return, except the function will return a generator
    def create_generator():
        print("start ...")
        mylist = range(3)
        for i in mylist:
            yield i*i

    mygenerator2 = create_generator() # create a generator
    print("object:", mygenerator2) # mygenerator2 is an object
    print("value:", mygenerator2.__next__())
    for i in mygenerator2:
        print(i)
    for i in mygenerator2:
        print(i) # 第二次for in不会有任何值输出

    # To master yield, you must understand that when you call the function, the code you have
    # written in the function body does not run. The function only returns the generator object.
    # Then, your code will continue from where it left off each time for uses the generator.
elif var == 3:
    # reference: https://www.geeksforgeeks.org/use-yield-keyword-instead-return-keyword-python/
    # The yield statement suspends function’s execution and sends a value back to the caller, but retains enough
    # state to enable function to resume where it is left off. When resumed, the function continues execution
    # immediately after the last yield run.
    def simpleGeneratorFun():
        yield 1
        yield 2
        yield 3

    for value in simpleGeneratorFun():
        print(value)

    # An infinite generator function that prints next square number. It starts with 1
    def nextSquare():
        i = 1
        # An Infinite loop to generate squares
        while True:
            yield i*i
            i += 1 # Next execution resumes from this point

    print("object:", nextSquare())
    for num in nextSquare():
        if num > 100:
            break
        print(num) # the first value is 1

    print("go on:")
    print("object:", nextSquare())
    for num in nextSquare():
        if num > 200:
            break
        print(num) # note: the first value is still 1, instead of 121

print("test finish")

      GitHub：https://github.com/fengbingchun/Python_Test