(转载)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（生成器），这有几个优点：
- 你不要再次去读取这些值
- 可能有很多子节点，你不想让他们存在内存中
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)]
