(转载)Python中关键词yield怎么用？

原文: https://stackoverflow.com/questions/231767/what-does-the-yield-keyword-do

译文: https://zhuanlan.zhihu.com/p/23276711?refer=passer

英文ok的同学可以原文译文都读一下

问题描述：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这个方法被调用的时候，到底发生了什么？是返回一个list，还是返回一个单个元素？后续的调用将在什么时候终止？

[1]上述代码来自 Jochen Schulz (jrschulz)，他做了一个度量空间的Python库。以下是代码的完整链接：Module mspace.

要理解yield是什么，它干什么。首先你要了解可迭代对象(Iterable)，然后再去了解生成器（generators），最后你才能了解yield。

当你定义了一个list之后，你可以一个一个的读取其中的元素。遍历list中的元素这个动作我们就把它称做：迭代(Iteration)。

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

以上的 mylist是一个可迭代对象(Iterable)，当你使用列表推导式（list comprehension）创建一个list，相当于创建了一个可迭代对象(Iterable)。

[1]不理解列表推导式（list comprehension）可以点击这里：Python 学习笔记 02

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

像lists, strings, files...这种任何一个可以用for... in...遍历的对象都称作可迭代对象(Iterable)。使用这些可迭代对象是非常方便的，因为你可以随时随地的去取出你想要的值。但是这些值都是存在内存中的，所以当你有很多值的时候，很可能将会产生不好的效果。

生成器（generators）是一种迭代器（iterators），但是你仅仅可以对他们进行一次迭代，这是因为它们并没有把所有的值存在内存中，而是在运行时生成值。

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

除了在迭代器（iterators）使用“[]”，而在 生成器（generators）中使用“()”这一点不同之外，生成器（generators）是和迭代器（iterators）几乎是一模一样的，但是你永远不能进行第二次“for i in mygenerator”操作，因为一个生成器（generators）只能被使用一次：生成器中的内容，访问一次之后就不能在访问第二次。

Yield关键词的用法与return的用法几乎一致，他们只有一个区别： 当某个函数使用Yield时，该函数将返回一个生成器（generators）

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

看看上面这个例子，这个例子说明：createGeneraor()函数将会返回一个值的集合，你仅仅需要去遍历一次这个集合就可以得到你想要的结果了。

为了精通 yield ,你必须要理解：当你调用这个函数的时候，函数内部的代码并不立马执行 ，这个函数只是返回一个生成器对象，这有点蹊跷不是吗。那么，函数内的代码什么时候执行呢？当你使用for进行迭代的时候【原来的翻译是：要完全的理解yield，你必须搞明白下面这段话：当使用yield的时候，写在yield后面的代码并不会执行，它仅仅会返回一个生成器（generators），这段代码只会在你遍历这个返回的生成器的时候开始运行。】

现在到了最难理解的地方了：

第一次，for在遍历上述方法中创建的mylist的时候，循环体内的代码将从头开始运行一直到它碰到yield关键词，它将返回循环内的第一个值，然后再次执行循环体内代码，返回循环内产生的第二个值，一直到这个循环结束。

下面开始讲解你给出的代码。

Generator（生成器）

# 在这里，你给node对象创建了一个方法，这个方法将会返回一个生成器。
def node._get_child_candidates(self, distance, min_dist, max_dist):

  #在你每次使用生成器（generators）时候会调用下面这段代码。

  #如果node对象还有左子节点，并且深度距离符合下述条件，那么返回下一个子节点。
  if self._leftchild and distance - max_dist < self._median:
      yield self._leftchild

  # 如果node对象还有右子节点，并且深度距离符合下述条件，那么返回下一个子节点。
  if self._rightchild and distance + max_dist >= self._median:
      yield self._rightchild

  # 如果函数运行到了这里，说明Generator（生成器）此时已经为空了。

Caller（调用）:

# 创建一个空的list和一个当前对象的引用list
result, candidates = list(), [self]

# 遍历candidates，一开始他仅仅包含一个元素
while candidates:

    # 获取并删除list中最后位置上的candidate
    node = candidates.pop()

    # 获取candidate到obj之间的距离
    distance = node._get_dist(obj)

    # 如果距离符合下述条件，则把candidate附加到result里面
    if distance <= max_dist and distance >= min_dist:
        result.extend(node._values)

    #把candidates list中所有candidate对象的所有子节点都添加到candidates中
    candidates.extend(node._get_child_candidates(distance, min_dist, max_dist))

return result

其实到这里问题已经有了一个比较明确的回答了==

上面的代码有小部分要说明的：

• extend（）是list对象的方法，用于在列表末尾一次性追加另一个序列中的多个值。

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

在你的代码中使用的是一个generator（生成器），这有几个优点：

1. 你不要再次去读取这些值
2. 可能有很多子节点，你不想让他们存在内存中

Python不关心某个方法的参数是不是一个列表list，Python预想它是一个可迭代对象(Iterable)，所以当这个参数是strings、lists或者generators的时候可以正确执行！这就被称作duck typing[1]

[1]：Duck typing：是动态类型的一种风格。在这种风格中，一个对象有效的语义，不是由继承自特定的类或实现特定的接口，而是由当前方法和属性的集合决定。在 Duck typing中，关注的不是对象的类型本身，而是它是如何使用的。

我们这里可以先暂停，进一步了解一下generator的用法：

控制一个 generator防止它被耗尽。

>>> class Bank(): # 我们建造一个银行，并且修建一些ATMs
...    crisis = False
...    def create_atm(self):
...        while not self.crisis:
...            yield "$100"
>>> hsbc = Bank() # 不出意外的时候，ATM可以任你取钱。
>>> 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 # 经济危机来了，你不能再取钱了。
>>> 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 # 问题是, 尽管是经济危机之后，ATM还是空的。
>>> print(corner_street_atm.next())
<type 'exceptions.StopIteration'>
>>> brand_new_atm = hsbc.create_atm() # 建造一个新的ATM，并使用。
>>> for cash in brand_new_atm:
...    print cash
$100
$100
$100
$100
$100
$100
$100
$100
$100
...

它是非常有用的比如用来控制资源的访问。

Python的内建模块itertools提供了非常有用的用于操作迭代对象的函数。你曾经有做过一个generator？关联两个generators？并为此感到厌烦吗？

你只需要import itertools.（导入itertools）（有关于Itertools的更多用法，大家可以访问：itertools - 廖雪峰的官方网站）

让我们看个例子：

>>> horses = [1, 2, 3, 4]
>>> races = itertools.permutations(horses)
>>> print(races)
<itertools.permutations object at 0xb754f1dc>
>>> print(list(itertools.permutations(horses)))
[(1, 2, 3, 4),
 (1, 2, 4, 3),
 (1, 3, 2, 4),
 (1, 3, 4, 2),
 (1, 4, 2, 3),
 (1, 4, 3, 2),
 (2, 1, 3, 4),
 (2, 1, 4, 3),
 (2, 3, 1, 4),
 (2, 3, 4, 1),
 (2, 4, 1, 3),
 (2, 4, 3, 1),
 (3, 1, 2, 4),
 (3, 1, 4, 2),
 (3, 2, 1, 4),
 (3, 2, 4, 1),
 (3, 4, 1, 2),
 (3, 4, 2, 1),
 (4, 1, 2, 3),
 (4, 1, 3, 2),
 (4, 2, 1, 3),
 (4, 2, 3, 1),
 (4, 3, 1, 2),
 (4, 3, 2, 1)]