问

比如，我试着理解下面一段代码：

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吗，它会再次调用吗，什么时候会停止？

答

要明白 yield 关键字的作用，你得明白迭代生成器的原理，它是如何能够被迭代的。

可迭代 iterable

当你创建一个list，你可以一个挨着一个地读里面的每一个元素，每一次读元素的操作叫做一次迭代。

>>> 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 ..." 的对象都是一个可迭代对象（iterable）。

生成器（Generators）

生成器是迭代器（iterators），不过你只能对每个元素迭代一次 。这是因为生成器并不会把所有数值存在内存中，生成器是运行的时候才生成相应的数值的。

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

用()而不是[]，输出有同样的结果。但你不能第二次使用for i in mygenerator，因为生成器的元素只能被迭代一次。它计算0，然后忘掉前面的结果，再计算1，最后在计算4的时候结束，一个接着一个。

Yield

yiled 使用跟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 迭代生成器的时候，那里面的代码才会执行。

好，现在来看难的部分：

第一次使用for 调用生成器对象的时候，生成器会执行它里面的代码，直到遇到了yield，并返回for循环的第一个元素。然后，for循环的每一次循环的开始，生成器会返回下一个元素，直到没有元素可以返回。当生成器函数找不到yield的结果时，生成器可以看做是空的了，因为已经没有元素可以迭代。

如何解释你的代码

生成器:

# 这个方法会返回一个生成器对象
def _get_child_candidates(self, distance, min_dist, max_dist):

    #当你每次调用生成器对象返回一个元素的时候，这些代码才会执行:

    # 如果还有左子节点
    # 并且距离OK，返回左子节点
    if self._leftchild and distance - max_dist < self._median:
        yield self._leftchild

    # 如果还有右子节点
    # 并且距离OK，返回右子节点
    if self._rightchild and distance + max_dist >= self._median:
        yield self._rightchild

    # 函数执行到这儿，生成器可以看做是空的了
    # 没有满足的左子节点，右子节点

调用者：

# 创建两个列表，一个是空列表，一个列表的初始元素是对象自己。
result, candidates = list(), [self]

# candidates的循环。（循环的开始，只有对象自己，后面要把自己的子节点加进去）
while candidates:

    # 推栈，得到最上面一个节点
    node = candidates.pop()

    # 计算距离
    distance = node._get_dist(obj)

    # 如果距离OK，那把这个节点的值加到result
    if distance <= max_dist and distance >= min_dist:
        result.extend(node._values)

    # 把这个节点的子节点加到candidates.extend列表
    # 所以这个循环会一直执行，直到没有任何子节点
    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()方法是list的一个方法，它接收一个可迭代对象，并把它的值加到列表中。

通常，我们把列表作为参数：

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

但在你的代码中，接收了一个生成器，这没有关系，因为：

你不会两次读取元素。
你有很多子节点，并不想存到内存当中。

这样子有效，因为Python并不会管你的参数是否为list，Python预测参数类型为可迭代对象，那strings，list，tuple和生成器都可以作为参数传递的。这叫做鸭子类型（duck typing）🦆，这是Python的一个特色，好吧话题扯远了。

看到这里就差不多把问题回答了，现在来看看一些高级特性。

控制生成器的耗尽（Controlling a generator exhaustion）

>>> class Bank(): # 创建一个银行，建设一些ATM
...    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() #新的ATM也是这样
>>> 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
...

这种方法在很多方面都有用，比如控制访问资源。

Itertools 你最好的朋友

Itertools 模块有两个特别的函数来操作可迭代对象。有没有想过要复制生成器？链接两个生成器？用一行代码组合数据在一个嵌套列表？Map / Zip而不创建另外一个list？

那就 import itertools吧。
作为例子，我们试着打印赛马比赛4个马到达次序的组合。

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

理解迭代的机制

可迭代对象都实现了__iter__()方法，迭代器实现了__next__()方法。
迭代是实现了next()的对象操作那些实现了iter()对象的过程。
(原文是说迭代器是用来迭代可迭代对象的对象，绕不饶？）

无负责翻译自：https://stackoverflow.com/questions/231767/what-does-the-yield-keyword-do
如果有什么写错了，你来打我啊！

python 的 yield 关键字有什么作用？(stackoverflow精品问答)