python stack overflow_翻译|Stack Overflow上关于Python的高票问答（一）

Stackoverflow是一个非常优秀的与程序相关的IT技术问答的英文网站。无论你处在什么状态，当你编程碰到问题的时候你总能找到你想要的答案。学习编程专栏打算翻译这一系列的问答计划进行的方向如下。

翻译Stack Overflow上关于Python的高票问答(Java)(JavaScript)(Php)(C#)每一种语言都会出两到三篇文章，每一篇会有一到三个问题。

感谢朋友@挠米 在翻译过程中给出的帮助。

问题描述：

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!

>>> for i in mygenerator:

... print(i)

0

1

4

看看上面这个例子，这个例子说明：createGeneraor()函数将会返回一个值的集合，你仅仅需要去遍历一次这个集合就可以得到你想要的结果了。

为了精通 yield ,你必须要理解：当你调用这个函数的时候，函数内部的代码并不立马执行 ，这个函数只是返回一个生成器对象，这有点蹊跷不是吗。那么，函数内的代码什么时候执行呢？当你使用for进行迭代的时候.(感谢@Nicolas-L 提供的译文。)【原来的翻译是：要完全的理解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())

>>> wall_street_atm = hsbc.create_atm() # it's even true for new ATMs

>>> print(wall_street_atm.next())

>>> hsbc.crisis = False # 问题是, 尽管是经济危机之后，ATM还是空的。

>>> print(corner_street_atm.next())

>>> 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)

>>> 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)]

More about it in this article about how does the for loop work.

希望你们喜欢，如果可以，等待下一期)