问
比如，我试着理解下面一段代码：
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
如果有什么写错了，你来打我啊！
