这是stackoverflow上的一个问题，这里翻译的是它得票最多的一个答案
#问题
Python关键字yield的作用是什么？用来干什么的？
比如，我正在试图理解下面的代码:
def node._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的时候发生了什么？返回了一个列表？返回了一个元素？被重复调用了么？ 什么时候这个调用结束呢？
#回答
为了理解什么是 yield,你必须理解什么是生成器。在理解生成器之前，我们需要先理解迭代。
##可迭代对象
当你建立了一个列表，你可以逐项地读取这个列表，这叫做一个可迭代对象:
>>> 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 ..语法的叫做一个迭代器：列表，字符串，文件对象……这些可迭代对象易于操作，你可以如你所愿的读取其中的元素。但是你把所有的值都存储到了内存中，如果你有大量数据的话这个方式并不是你想要的。
##生成器
生成器是可以迭代的，但是你只可以读取它一次，因为它并不把所有的值放在内存中，它是实时地生成数据:
>>> 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关键字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 条件。
##解释你的代码
生成器:
# 在这里定义node对象的方法来返回生成器
def node._get_child_candidates(self, distance, min_dist, max_dist):
# 每一次你使用生成器对象都会调用这里的代码:
# 如果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
# 如果函数运行到了这里，生成器就是空的
# 不可能有除了“左孩子”和“右孩子”之外的值
调用者:
# 建立一个空列表和一个元素是当前对象引用的列表
result, candidates = list(), [self]
# candidates循环 (一开始只拥有一个元素)
while candidates:
# 获取最后一个candidate并将其从列表中删除
node = candidates.pop()
# 获取obj和这个candidate之间的距离
distance = node._get_dist(obj)
# 如果距离ok，追加到result
if distance <= max_dist and distance >= min_dist:
result.extend(node._values)
# 将candidate的孩子添加到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只希望它是可以迭代的，所以这个参数可以是列表，元组，字符串，生成器… 这叫做 duck typing,这也是为何Python如此棒的原因之一，但这已经是另外一个故事了…
你可以在这里停下，或者来看看生成器的一些高级用法:
##控制生成器的穷尽
>>> 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
...
对于控制一些资源的访问来说这很有用。
##Itertools,你最好的朋友
itertools包含了很多特殊的迭代方法。是不是曾想过复制一个迭代器?串联两个迭代器？把嵌套的列表分组？不用创造一个新的列表的 zip/map?
只要 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__()方法)的过程。可迭代对象是你可以从其获取到一个迭代器的任一对象。迭代器是那些允许你迭代可迭代对象的对象。
更多见这个文章 for循环是怎么工作的