详解 Python中yield关键字的用法

朱雀 2020-10-17 17:44 899阅读 0赞

# 1.1 提问者的问题 #

Python关键字yield的作用是什么？它被用来干什么的？

比如，我正在尝试理解下面的代码时:

>     def _get_child_candidates(self, distance, min_dist, max_dist):
>         if self._leftchild and distance - max_dist < self._median:
>             yield self._leftchild
>         if self._rightchild and distance + max_dist >= self._median:
>             yield self._rightchild

下面的是调用:

result, candidates = list(), [self]
    while candidates:
        node = candidates.pop()
        distance = node._get_dist(obj)
        if distance <= max_dist and distance >= min_dist:
            result.extend(node._values)
        candidates.extend(node._get_child_candidates(distance, min_dist, max_dist))
    return result

当调用 `_get_child_candidates` 的时候发生了什么？返回了一个列表？返回了一个元素？被重复调用了么？ 什么时候这个调用结束呢？

# 1.2 回答部分 #

为了理解什么是 `yield`,你必须理解什么是生成器。在理解生成器之前，让我们先了解什么是迭代。

# 1.3 可迭代对象 #

当你建立了一个列表，你可以逐项地读取这个列表，这叫做一个可迭代对象:

>>> mylist = [1, 2, 3]
    >>> for i in mylist:
    ...    print(i)
    1
    2
    3

`mylist` 是一个可迭代的对象。当你使用一个列表生成式来建立一个列表的时候，就建立了一个可迭代的对象:

>>> mylist = [x*x for x in range(3)]
    >>> for i in mylist :
    ...    print(i)
    0
    1
    4

所有你可以使用 `for .. in ..` 语法的叫做一个迭代器：列表，字符串，文件……你经常使用它们是因为你可以如你所愿的读取其中的元素，但是你把所有的值都存储到了内存中，如果你有大量数据的话这个方式并不是你想要的。

# 1.4 生成器 #

生成器是可以迭代的，但是你 **只可以读取它一次** ，因为它并不把所有的值放在内存中，它是实时地生成数据:

>>> mygenerator = (x*x for x in range(3))
    >>> for i in mygenerator:
    ...    print(i)
    0
    1
    4

看起来除了把 `[]` 换成 `()` 外没什么不同。但是，你不可以再次使用 `for i in mygenerator` , 因为生成器只能被迭代一次：先计算出0，然后继续计算1，然后计算4，一个接着一个的…

# 1.5 yield关键字 #

`yield` 是一个类似 `return` 的关键字，只是这个函数返回的是个生成器。

>>> def createGenerator():
    ...    mylist = range(3)
    ...    for i in mylist:
    ...        yield i*i
    ...
    >>> mygenerator = createGenerator() # create a generator
    >>> print(mygenerator) # mygenerator is an object!
    <generator object createGenerator at 0xb7555c34>
    >>> for i in mygenerator:
    ...     print(i)
    0
    1
    4

这个例子没什么用途，但是它让你知道，这个函数会返回一大批你只需要读一次的值.

为了熟练掌握 `yield` ,你必须要理解：**当你调用这个函数的时候，函数内部的代码并不立马执行** ，这个函数只是返回一个生成器对象，这有点蹊跷不是吗。

那么，函数内的代码什么时候执行呢？当你使用for进行迭代的时候.

现在到了关键点了！

第一次迭代中你的函数会执行，从开始到达 `yield` 关键字，然后返回 `yield` 后的值作为第一次迭代的返回值. 然后，每次执行这个函数都会继续执行你在函数内部定义的那个循环的下一次，再返回那个值，直到没有可以返回的。

如果生成器内部没有定义 `yield` 关键字，那么这个生成器被认为成空的。这种情况可能因为是循环进行没了，或者是没有满足 `if/else` 条件。

# 1.6 回到你的代码 #

# Here you create the method of the node object that will return the generator
    def _get_child_candidates(self, distance, min_dist, max_dist):
    
        # Here is the code that will be called each time you use the generator object:
    
        # If there is still a child of the node object on its left
        # AND if distance is ok, return the next child
        if self._leftchild and distance - max_dist < self._median:
            yield self._leftchild
    
        # If there is still a child of the node object on its right
        # AND if distance is ok, return the next child
        if self._rightchild and distance + max_dist >= self._median:
            yield self._rightchild
    
        # If the function arrives here, the generator will be considered empty
        # there is no more than two values: the left and the right children

调用者:

# Create an empty list and a list with the current object reference
    result, candidates = list(), [self]
    
    # Loop on candidates (they contain only one element at the beginning)
    while candidates:
    
        # Get the last candidate and remove it from the list
        node = candidates.pop()
    
        # Get the distance between obj and the candidate
        distance = node._get_dist(obj)
    
        # If distance is ok, then you can fill the result
        if distance <= max_dist and distance >= min_dist:
            result.extend(node._values)
    
        # Add the children of the candidate in the candidates list
        # so the loop will keep running until it will have looked
        # at all the children of the children of the children, etc. of the candidate
        candidates.extend(node._get_child_candidates(distance, min_dist, max_dist))
    
    return result

这个代码包含了几个小部分：

*  我们对一个列表进行迭代，但是迭代中列表还在不断的扩展。它是一个迭代这些嵌套的数据的简洁方式，即使这样有点危险，因为可能导致无限迭代。 `candidates.extend(node._get_child_candidates(distance, min_dist, max_dist))`穷尽了生成器的所有值，但 `while` 不断地在产生新的生成器，它们会产生和上一次不一样的值，既然没有作用到同一个节点上.
 *  `extend()` 是一个迭代器方法，作用于迭代器，并把参数追加到迭代器的后面。

通常我们传给它一个列表参数:

>>> a = [1, 2]
    >>> b = [3, 4]
    >>> a.extend(b)
    >>> print(a)
    [1, 2, 3, 4]

但是在你的代码中的是一个生成器，这是不错的，因为：

*  你不必读两次所有的值
 *  你可以有很多子对象，但不必叫他们都存储在内存里面。

并且这很奏效，因为Python不关心一个方法的参数是不是个列表。Python只希望它是个可以迭代的，所以这个参数可以是列表，元组，字符串，生成器... 这叫做 `ducktyping`,这也是为何Python如此棒的原因之一，但这已经是另外一个问题了...

你可以在这里停下，来看看生成器的一些高级用法:

# 1.7 控制生成器的穷尽 #

>>> 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 # The 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
    ...

**Note:** 对于 Python 3来说, 应该使用`print(corner_street_atm.__next__())` 或者 `print(next(corner_street_atm))`

对于控制一些资源的访问来说这很有用。

# 1.8`yield` 表达式 #

如前所述，如果一个函数定义中包含 `yield` 表达式，那么该函数是一个生成器函数（而非普通函数）。实际上，`yield` 仅能用于定义生成器函数。

与普通函数不同，生成器函数被调用后，其函数体内的代码并不会立即执行，而是返回一个生成器（generator-iterator）。当返回的生成器调用成员方法时，相应的生成器函数中的代码才会执行。

def square():
        for x in range(4):
            yield x ** 2
    square_gen = square()
    for x in square_gen:
        print(x)

前面说到，`for` 循环会调用 `iter()` 函数，获取一个生成器；而后调用 `next()` 函数，将生成器中的下一个值赋值给 `x`；再执行循环体。因此，上述 `for` 循环基本等价于：

genitor = square_gen.__iter__()
    while True:
        x = geniter.next() # Python 3 是 __next__()
        print(x)

注意到，`square` 是一个生成器函数；作为它的返回值，`square_gen` 已经是一个迭代器；迭代器的 `__iter__()` 返回它自己。因此 `geniter` 对应的生成器函数，即是 `square`。

每次执行到 `x = geniter.next()` 时，`square` 函数会从上一次暂停的位置开始，一直执行到下一个 `yield` 表达式，将 `yield` 关键字后的表达式列表返回给调用者，并再次暂停。注意，**每次从暂停恢复时，生成器函数的内部变量、指令指针、内部求值栈等内容和暂停时完全一致**。

如果你还是不太能理解生成器函数，那么大致上你可以这样去理解。

*  在函数开始处，加入 `result = list()`；
 *  将每个 `yield` 表达式 `yield expr` 替换为 `result.append(expr)`；
 *  在函数末尾处，加入 `return result`。