問
比如，我試著理解下面一段代碼：
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
如果有什么寫錯了，你來打我啊！
