Python中的yield关键字

朱雀 2022-06-17 10:48 235阅读 0赞

# **Yield**？ #

总的来说，`yield`关键字和`return`关键字有相似之处，但其工作机制却大相径庭。想要完整地理解`yield`的工作机制，我们首先需要明白什么是`generator`。而为了明白什么是`generator`，我们需要明白什么是`iterable`。

本文接下来将首先给出一种理解含`yield`关键字的函数/代码的便捷方法。然后讨论`iterable`和`generator`。接着在此基础上讨论`yield`的工作机制。

## 理解`yield`关键字的葵花宝典 ##

在遇到一段含有yield的函数的代码时，使用如下方法我们就可以轻松的读懂这个函数。

> 1.  在函数开头插入`result = []`
> 2.  将所有的`yield表达式`替换成`result.append(表达式)`
> 3.  在函数结尾插入`return result`
> 4.  此时这段代码已经变为不含`yield`的普通代码， 重读一遍代码就可以轻松理解该函数了
> 5.  和原代码对比一下，理解yield的意义是什么

通过这种方法我们可以理解函数的逻辑是什么，但是实际上`yield`的工作机制和用`list`替换实现的工作机制是非常不同的。在某些情况下，使用`yield`关键字从内存和运行时间角度看都更加高效。在另外一些情况下，即使原本的代码工作良好，使用本方法替换`yield`却可能会导致死循环的产生。

## *iterable*和*iterator* ##

for ele in mylist:
        loop body

在Python中，任何可以使用`for ... in ...`模式进行循环的对象都是`iterable`。例如`list, string, file`等。或者说，在Python中，实现了`__iter()__`方法的类实例都是`iterable`。`__iter()__`方法需要返回一个`iterator`。`iterator`指的是实现了`next()`方法的对象。在一个类中同时实现`__iter()__`和`next()`是合法的。这种情况下`__iter()__`只需要返回`self`即可。在简单的应用中这样做没有问题。但是如果我们想要同时使用两个或两个以上的`iterator`同时循环同一个对象，这种模式就无法满足要求了。

换句话说，`iterable`是任何你能通过调用`iter()`方法得到`iterator`的对象。而`iterator`是你用来循环`iterable`对象的对象。

`for ele in mylist`在Python中的工作模式如下：  
1. 得到一个`mylist`的`iterator`：调用`iter(mylist)`–>该方法返回一个实现了`next()`方法（Python3中为`__next()__`）的对象（`iterator`)。  
2. 使用该`iterator`逐个循环`mylist`中的项目：不断调用`iterator`中的`next()`方法。`next()`方法的返回值被赋给`ele`，然后执行`loop body`中的语句。如果`iterator`中所有元素都已被循环，则`next()`方法抛出`StopIteration`异常，意味着循环结束。

事实上，Python在任何执行循环的时候都会执行以上两部——可能是在显式地`for`循环中，也可能是`otherlist.extend(mylist)`这样含有隐式循环的操作（其中`otherlist`是一个`list`）。

所以Python中的`iterable`有如下几种：  
1. Python中可使用`for ... in ...`循环的对象：`list, dict, string, files`。  
2. 用户自定义的实现了`iter()`方法的类实例。  
3. `Generator`。

需要注意的是，Python中的`for`循环并不关心它处理的是以上哪一种情况。只要其处理的是可以通过`next()`方法逐个调用元素的`iterator`，`for`循环就可以正常工作。例如我们使用`for`循环逐个访问`list`中的元素，`dict`中的`key`，`file`中的行，等等。

## *generator* ##

`generator`的功能实际上同`iterator`完全相同，但其与`iterator`的区别在于`generator`中的元素只能被循环一次。这是因为`generator`不会在内存中存储全部的元素，而是动态地产生下一个将被循环的元素。

# 这是一个iterator
    >>> mylist = [x * x for x in range(3)]
    >>> for ele in mylist:
    ...     print(ele)
    0
    1
    4
    
    # 这是一个generator
    >>> mylist = (x * x for x in range(3))
    >>> for ele in mylist:
    ...     print(ele)
    0
    1
    4

可以看出，只需要将`[]`换成`()`我们就得到了一个`generator`。与`iterator`不同的是，对于`generator`，我们只能调用一次`for ele in mylist`。因为`generator`将先计算0，然后删除这部分内容；再计算1，然后再删除这部分内容，等等。也就是说`generator`不会在内存中保存任何之前已经循环过的元素的值。

## *yield* ##

`yield`关键字的用法类似于`return`，但是区别在于`yield`关键使得函数返回一个`generator`对象。看如下示例代码。

def createGenerator():
        yield 1
        yield 2
        yield 3
    
    myGenerator = createGenerator()
    print(myGenerator) #(1)
    
    for ele in myGenerator:
        print(ele) #(2)
    
    print(myGenerator.next())

上述代码的三个输出结果分别为：

<generator object createGenerator at 0x1010b1960> #(1)
    
    1
    2
    3
    #(2)
    
    Traceback (most recent call last):
      File "<stdin>", line 12, in <module>
    StopIteration
    #(3)

从输出结果我们可以看出，yield关键字返回了一个`generator`，且`generator`只能被循环一次。

当`createGenerator()`被调用的时候，事实上其不会返回`yield`语句中的任何值。该函数返回的其实是一个`generator`对象。并且函数事实上也并没有退出，而是处于一种暂停的状态。当我们使用`for`循环来遍历`generator`的时候，函数将会从暂停的状态恢复，并继续执行之前最后执行的`yield`语句后面的代码。在`createGenerator()`中也就是下一行`yield`语句，然后将`yield`中的值返回给`for`循环。这个过程会持续到函数执行至结尾退出之前（函数退出，或者说`generator`为空意味着函数持续运行但无法发现`yield`语句。这可能是由于函数已经执行至结尾，也可能是因为我们的函数中包含的`if/else`条件无法被继续满足）。此时`generator`会抛出`StopIteration`异常，`for`循环结束。需要注意的是，在`for`循环第一次调用`generator`时，函数将会从开头执行至第一个`yield`并返回该语句中的值。

相反，如果我们用`return`代替`createGenerator()`中的`yield`，则函数中只有第一行会被执行，函数返回`1`后就会结束。

从某种程度上来说，`generator`的作用类似于一个适配器。一方面其`next()`方法使得`for`循环能够逐个取得下一个值。另一方面，它将函数执行至恰好取得下一个值的部分，然后将函数重新置为暂停状态。

## 为什么使用*generator*? ##

通常情况下，我们可以写出不使用`generator`但是实现完全相同的逻辑的代码。方法之一就是使用前面替换`yield`关键字的`list`方法。但这种方法并不是永远都有效。比如当我们有无限长的循环的时候；并且如果`list`非常大的话，这种方法对内存的利用效率非常低。

另一种方法是实现另一个`iterable`类并利用这个类中的实例成员记录状态。利用这个类中实现的`next()`方法（Python3中的`__next()__`）来实现逐个循环的操作。根据逻辑设计的需要，`next()`中的代码块可能会非常复杂并且容易产生bug。这种情况下，使用`generator`也可以提供干净利落的解决方法。

## 控制*generator*元素的耗尽 ##

>>> class Bank(): # let's create a bank, building ATMs
    ...    crisis = False
    ...    def create_atm(self):
    ...        while not self.crisis:
    ...            yield "$100"
    >>> hsbc = Bank() # when everything's ok the ATM gives you as much as you want
    >>> corner_street_atm = hsbc.create_atm()
    >>> print(corner_street_atm.next())
    $100
    >>> print(corner_street_atm.next())
    $100
    >>> print([corner_street_atm.next() for cash in range(5)])
    ['$100', '$100', '$100', '$100', '$100']
    >>> hsbc.crisis = True # crisis is coming, no more money!
    >>> print(corner_street_atm.next())
    <type 'exceptions.StopIteration'>
    >>> wall_street_atm = hsbc.create_atm() # it's even true for new ATMs
    >>> print(wall_street_atm.next())
    <type 'exceptions.StopIteration'>
    >>> hsbc.crisis = False # trouble is, even post-crisis the ATM remains empty
    >>> print(corner_street_atm.next())
    <type 'exceptions.StopIteration'>
    >>> brand_new_atm = hsbc.create_atm() # build a new one to get back in business
    >>> for cash in brand_new_atm:
    ...    print cash
    $100
    $100
    $100
    $100
    $100
    $100
    $100
    $100
    $100
    ...

在某些需要控制对某个资源的获取的时候，这个方法可能会有用。