3.1. 提問者的問題
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 的時候發生了什麼？返回了一個鏈表？返回了一個元素？被重複調用了麼？ 什麼時候這個調用結束呢？
3.2. 回答部分
爲了理解什麼是 yield,你必須理解什麼是生成器。在理解生成器之前，讓我們先走近迭代。
3.3. 可迭代對象
當你建立了一個列表，你可以逐項地讀取這個列表，這叫做一個可迭代對象:
>>> 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 .. 語法的叫做一個迭代器：鏈表，字符串，文件……你經常使用它們是因爲你可以如你所願的讀取其中的元素，但是你把所有的值都存儲到了內存中，如果你有大量數據的話這個方式並不是你想要的。
3.4. 生成器
生成器是可以迭代的，但是你 只可以讀取它一次 ，因爲它並不把所有的值放在內存中，它是實時地生成數據:
>>> mygenerator = (x*x for x in range(3))
>>> for i in mygenerator :
... print(i)
0
1
4
看起來除了把 [] 換成 () 外沒什麼不同。但是，你不可以再次使用 for i inmygenerator , 因爲生成器只能被迭代一次：先計算出0，然後繼續計算1，然後計算4，一個跟一個的…
3.5. 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 條件。
3.6. 回到你的代碼
(譯者注:這是回答者對問題的具體解釋)
生成器:
# Here you create the method of the node object that will return the generator
def node._get_child_candidates(self, distance, min_dist, max_dist):
# Here is the code that will be called each time you use the generator object :
# If there is still a child of the node object on its left
# AND if distance is ok, return the next child
if self._leftchild and distance - max_dist < self._median:
yield self._leftchild
# If there is still a child of the node object on its right
# AND if distance is ok, return the next child
if self._rightchild and distance + max_dist >= self._median:
yield self._rightchild
# If the function arrives here, the generator will be considered empty
# there is no more than two values : the left and the right children
調用者:
# Create an empty list and a list with the current object reference
result, candidates = list(), [self]
# Loop on candidates (they contain only one element at the beginning)
while candidates:
# Get the last candidate and remove it from the list
node = candidates.pop()
# Get the distance between obj and the candidate
distance = node._get_dist(obj)
# If distance is ok, then you can fill the result
if distance <= max_dist and distance >= min_dist:
result.extend(node._values)
# Add the children of the candidate in the candidates list
# so the loop will keep running until it will have looked
# at all the children of the children of the children, etc. of the 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如此棒的原因之一，但這已經是另外一個問題了...
你可以在這裏停下，來看看生成器的一些高級用法:
3.7. 控制生成器的窮盡
>>> 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
...
對於控制一些資源的訪問來說這很有用。
3.8. 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)]
3.9. 瞭解迭代器的內部機理
迭代是一個實現可迭代對象(實現的是 __iter__() 方法)和迭代器(實現的是__next__() 方法)的過程。可迭代對象是你可以從其獲取到一個迭代器的任一對象。迭代器是那些允許你迭代可迭代對象的對象。