理解 Python 中的 for 循环

译者注：

• 本文翻译自 Trey Hunner 于 2019 年 6 月 18 日发表的文章 Loop Better: a deeper look at iteration in Python
• 文中括号或者引用块中的 斜体字 为对应的英文原文或者我自己注释的话（会标明「译者注」），否则为原文中本来就有的话
• 文中的「我」均指原作者 Trey Hunner
• 目录保留英文原文
• 一些术语及特殊用语保留英文原文
• 本人水平有限，如有错误欢迎指出
• 能力尚可建议阅读英文原文
• 本文同步发表在我的个人独立博客：理解 Python 中的 for 循环 · Lee’s Space Station

Python 中 for 循环的工作方式和其他编程语言的不太一样。本文中我们将会深入探索 Python 的 for 循环来了解他们是如何工作的，以及为什么这么是这种工作方式。

Note：本文基于我的 Loop Better 演讲，原本发表在 opensource.com。

Looping Gotchas

我们将通过一些「gotchas」（陷阱）来开始今天的旅程。等我们知道 Python 中的 for 循环的原理时，我们再回过头来看这些 gotchas，并解释原因。

Gotcha 1: Looping Twice

假设我们有一个数字 list（列表）以及一个生成这些数字的平方的 generator（生成器）：

>>> numbers = [1, 2, 3, 5, 7]
>>> squares = (n**2 for n in numbers)

我们可以将我们的 generator 对象传给

tuple

>>> tuple(squares)
(1, 4, 9, 25, 49)

之后如果我们将同样的 generator 对象传给

sum

>>> sum(squares)
0

但是我们得到的是

0

Gotcha 2: Containment Checking

我们还用上面相同的数字 list 和 generator 对象：

>>> numbers = [1, 2, 3, 5, 7]
>>> squares = (n**2 for n in numbers)

如果我们问

9

squares

>>> 9 in squares
True>>> 9 in squares
False

我们把一个问题问了两遍，但是 Python 给了两个不同的回答。

Gotcha 3: Unpacking

这个 dictionary 有两个键值对：

>>> counts = {'apples': 2, 'oranges': 1}

让我们用 multiple assignment 来解包（unpack）这个 dictionary：

>>> x, y = counts

你可能期望的是当我们解包这个 dictionary 时，我们会得到键值对，或者发生错误。

但是解包 dictionary 并不会有任何错误发生，也没有得到键值对，反而你得到的是键：

>>> x
'apples'

当我们学到这写代码片段背后的逻辑时，我们再回过头来看这些代码。

Review: Python’s for loop

Python 中的 for 循环不是传统的 for 循环。为了解释我的意思，我们来看一下其他语言的 for 循环是怎么写的。

这是一个用 JavaScript 写的传统的 C 风格的 for 循环：

let numbers = [1, 2, 3, 5, 7];
for (let i = 0; i < numbers.length; i += 1) {
print(numbers[i])
}

JavaScript、C、C++、Java、PHP 以及其他一大堆都是这种 C 风格的 for 循环，但是 Python 不是。

Python 没有 C 风格的 for 循环，但是的确有 for 循环，但是原理类似于 foreach 循环。

这是 Python 的 for 循环风格：

numbers = [1, 2, 3, 5, 7]
for n in numbers:
print(n)

不像传统的 C 风格的 for 循环，Python 的 for 循环没有索引变量。没有索引初始化、边界检查和索引增加。Python 的 for 循环都把这些工作为我们做了。

所以在 Python 中确实有 for 循环，但不是传统的 C 风格的 for 循环。我们称之为 for 循环的东西的工作方式很不一样。

Definitions: Iterables and Sequences

现在我们已经知道 Python 的 for 循环没有索引，接下来先让我们做一些定义。

Python 中任何你可以通过 for 循环来循环的东西都是一个 iterable（可迭代对象）。iterable 可以被循环，任何可被循环的东西都是一个 iterable。

for item in some_iterable:
print(item)

Sequences 是一种非常常见的 iterable 类型。 Lists、tuples、和 strings 都是 sequences。

>>> numbers = [1, 2, 3, 5, 7]
>>> coordinates = (4, 5, 7)
>>> words = "hello there"

Sequences 是具有一组特定特征的 iterable。他们可以从

0

>>> numbers[0]
1
>>> coordinates[2]
7
>>> words[4]
'o'

Python 中许多东西都是 iterable，但并不是所有的 iterable 都是 sequences。Sets（集合）、dictionaries、files 和 generators 都是 iterable，但他们都不是 sequences。

>>> my_set = {1, 2, 3}
>>> my_dict = {'k1': 'v1', 'k2': 'v2'}
>>> my_file = open('some_file.txt')
>>> squares = (n**2 for n in my_set)

所以任何可以用 for 循环来循环的东西都是一个 iterable，sequences 是一种 iterable 类型，但是 Python 也有许多其他类型的 iterable。

Python’s for loops don’t use indexes

你可能会认为 Python 的 for 循环本质上还是用的索引。下面我们使用 while 循环和索引来遍历一个 iterable：

numbers = [1, 2, 3, 5, 7]
i = 0
while i < len(numbers):
print(numbers[i])
i += 1

这种方式适合 lists，但是不是任何对象都可以这么用。这种方式只适合 sequences。

如果我们试图对一个 set 进行上述遍历，我们会得到一个错误：

>>> fruits = {'lemon', 'apple', 'orange', 'watermelon'}
>>> i = 0
>>> while i < len(fruits):
...     print(fruits[i])
...     i += 1
...
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
TypeError: 'set' object does not support indexing

Sets 不是 sequences，所以他们不支持索引。

Python 中我们不能使用索引来遍历每一个 iterable。这对于非 sequences 的 iterable 不起作用。

Iterators power for loops

目前为止我们已经看到 Python 不可能使用索引来进行循环。相反，Python 的 for 循环使用 iterator（迭代器）。

Iterators 就是增强 iterable 的东西。你可以从任何一个 iterable 得到一个 iterator。你可以使用 iterator 手动遍历一个 iterable。

让我们看看怎么实现。

这里有三个 iterable：一个 set，一个 tuple，一个 string：

>>> numbers = {1, 2, 3, 5, 7}
>>> coordinates = (4, 5, 7)
>>> words = "hello there"

我们可以使用 Python 的内置函数

iter

iter

>>> iter(numbers)
<set_iterator object at 0x7f2b9271c860>
>>> iter(coordinates)
<tuple_iterator object at 0x7f2b9271ce80>
>>> iter(words)
<str_iterator object at 0x7f2b9271c860>

一旦我们有了一个 iterator，我们就可以使用内置的

next

>>> numbers = [1, 2, 3]
>>> my_iterator = iter(numbers)
>>> next(my_iterator)
1
>>> next(my_iterator)
2

Iterators 是有状态的，意味着一旦你消耗了一项那这项就消失了。

如果你用

next

StopIteration

>>> next(iterator)
3
>>> next(iterator)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration

所以你可以从每一个 iterable 得到一个 iterator。对于 iterator 你可以做得唯一的一件事就是使用

next

StopIteration

Looping without a for loop

现在我们已经学习了 iterator 以及

next

iter

我们尝试将 for 循环转成 while 循环：

def funky_for_loop(iterable, action_to_do):
for item in iterable:
action_to_do(item)

要做到这一点，我们将：

1. 从给定的 iterable 获得一个 iterator
2. 从得到的 iterator 中重复获取下一项
3. 如果成功获取到下一项，执行 for 循环的主体
4. 如果得到一个

   StopIteration

   错误，停止循环

def funky_for_loop(iterable, action_to_do):
iterator = iter(iterable)
done_looping = False
while not done_looping:
try:
item = next(iterator)
except StopIteration:
done_looping = True
else:
action_to_do(item)

我们刚刚只是用 while 循环和 iterator 重新发明了一个 for 循环。

上面的代码很好的展现了 Python 中的循环是如何工作的。如果你理解了内置函数

iter

next

事实上相比理解 for 循环的工作方式，你会了解的更多。所有循环都是这么工作的。

Iterator protocol（迭代器协议）描述了 Python 中循环的工作方式。它本质上是

iter

next

for 循环使用的就是 iterator protocol（就像我们所看到的）：

for n in numbers:
print(n)

Multiple assignment 也使用 iterator protocol：

x, y, z = coordinates

Star expressions（星号表达式）也使用 iterator protocol：

a, b, *rest = numbers
print(*numbers)

还有许多内置函数都依赖 iterator protocol：

unique_numbers = set(numbers)

Python 中与 iterable 一起使用的任何东西都可能以某种方式使用 iterator protocol。每当你在 Python 中循环迭代时，你就依赖于 iterator protocol。

Generators are iterators

你可能会想：iterators 很厉害，但是他们好像只是一种实现细节，作为 Python 用户我们似乎并不关心这个。

我可以告诉你的是：在 Python 中直接使用 iterator 是很常见的。

这里的

squares

>>> numbers = [1, 2, 3]
>>> squares = (n**2 for n in numbers)

Generators 就是一种 iterators，意味着你可以使用

next

>>> next(squares)
1
>>> next(squares)
4

如果你之前使用过 generators，那么你就知道你可以使用循环来遍历他们：

>>> squares = (n**2 for n in numbers)
>>> for n in squares:
...     print(n)
...
1
4
9

在 Python 中如果一个对象可以被循环，那么这就是一个 iterable。（目前为止作者好像已经提了很多次 ?）

所以 generators 是 iterator，但 generators 也是 iterable。为什么？

I lied to you

当我之前解释 iterator 是如何工作的时候，我跳过了一个重要的细节。

Iterators 是 iterable.

我再说一遍：Python 中每一个 iterator 也是一个 iterable，意味着你可以遍历他们。

由于 iterator 也是 iterable，你也可以使用

iter

>>> numbers = [1, 2, 3]
>>> iterator1 = iter(numbers)
>>> iterator2 = iter(iterator1)

记住当我们将一个 iterable 穿给

iter

当我们将 iterator 传给

iter

>>> iterator1 is iterator2
True

Iterators 都是 iterable，所有的 iterator 都是他们自己的 iterators。

有点迷是吗？

让我们回顾下这些术语。

你可以遍历一个 iterable，而 iterator 就是实际执行遍历操作的代理。

另外，Python 中 iterator 也是 iterable，而且他们也是自己的 iterators。（我真的不想再说这个了。。。）

所以 iterator 是 iterable，但是他们没有一些 iterable 所拥有的特性。

Iterators 没有长度，他们不能使用索引：

>>> numbers = [1, 2, 3, 5, 7]
>>> iterator = iter(numbers)
>>> len(iterator)
TypeError: object of type 'list_iterator' has no len()
>>> iterator[0]
TypeError: 'list_iterator' object is not subscriptable

作为 Python 程序员的我们来说，iterators 唯一有用的是可以使用

next

>>> next(iterator)
1
>>> list(iterator)
[2, 3, 5, 7]

如果我们对一个 iterator 遍历第二次，那么我们什么也得不到：

>>> list(iterator)
[]

你可以把 iterator 看成是 lazy iterable，只能用一次，也就是只能遍历一次。

正如上面的真值表所展示的，iterable 不总是 iterators，但是 iterator 总是 iterable。

The iterator protocol, in full

让我们从 Python 的角度定义 iterator 是如何工作的。

iterable 可以作为参数传入

iter

Iterators：

1. 可以作为参数传入

   next

   函数来获取下一项，当没有元素时抛出

   StopIteration

   异常
2. 可以作为参数传入

   iter

   函数，返回他们本身

这些命题的逆命题也同样成立：

1. 任何可以传入

   iter

   并没有抛出

   TypeError

   异常的对象都是 iterable
2. 任何可以传入

   next

   并没有抛出

   TypeError

   异常的对象都是 iterator
3. 任何可以传入

   iter

   并返回他们本身的对象都是 iterator

这就是 Python 中的 iterator protocol。

Iterators enable laziness

Iterators 允许我们创建并使用 lazy iterable，在我们要求获取下一项之前他们不会做任何事。由于我们可以创建 lazy iterable，我们可以创建无限长的 iterable。我们也可以创建保有系统资源（are conservative with system resources）的 iterable，可以为我们节省内存和 CPU 时间。

Iterators are everywhere

在 Python 中你已经见过很多 iterator 了。我之前已经提到 generator 就是 iterator 了。许多 Python 的内置类也是 iterator。例如

enumerate

reversed

>>> letters = ['a', 'b', 'c']
>>> e = enumerate(letters)
>>> e
<enumerate object at 0x7f112b0e6510>
>>> next(e)
(0, 'a')

在 Python 3 中，

zip

map

filter

>>> numbers = [1, 2, 3, 5, 7]
>>> letters = ['a', 'b', 'c']
>>> z = zip(numbers, letters)
>>> z
<zip object at 0x7f112cc6ce48>
>>> next(z)
(1, 'a')

而且文件对象也是 iterator。

>> next(open('hello.txt'))
'hello world\n'

Python 中有许多内置的 iterator，第三方包中也有许多。这些 iterator 就像 lazy iterable，他们不会做任何事，直到你要求获取下一项。

Creating your own iterator

你可能已经在使用 iterator 了，但是我想让你知道的是你可以创建你自己的 iterator 和 lazy iterable。

下面这个类创建了一个 iterator，接受一个数字的 iterable 作为输入，并且当循环的时候输出每一个数字的平方。

class square_all:
def __init__(self, numbers):
self.numbers = iter(numbers)
def __next__(self):
return next(self.numbers) ** 2
def __iter__(self):
return self

但是任何事情都不会发生直到我们开始循环该类的实例。

这里我们有一个无限长的 iterable

count

square_all

count

count

>>> from itertools import count
>>> numbers = count(5)
>>> squares = square_all(numbers)
>>> next(squares)
25
>>> next(squares)
36

这个 iterator 类是没问题的，但是通常我们不会这么写。通常当我们想要创建一个自定义 iterator 的时候，我们会创建一个 generator 函数：

def square_all(numbers):
for n in numbers:
yield n**2

这个 iterator 函数和上面的类是等价的，工作方式也是一样的。

这个

yield

yield

next

yield

实现上述相同的 iterator 的另一种方式是使用 generator expression（生成器表达式）。

def square_all(numbers):
return (n**2 for n in numbers)

这个和 generator 函数是一样的，只是语法类似于 list comprehension（列表推导式）。如果你的代码中需要 lazy iterable，可以考虑下用 generator 函数或者 generator expression 来创建一个 iterator。

How iterators can improve your code

一旦你接受了在代码中使用 lazy iterable 的思想，那么你就会发现很多时候都可以创建一个帮助函数来协助循环和处理数据。

Laziness and summing

这是个 Django 的查询集（queryset）用于对所有计费小时数（billable hours）求和的

for

hours_worked = 0
for event in events:
if event.is_billable():
hours_worked += event.duration

下面是 generator expression 版本：

billable_times = (
event.duration
for event in events
if event.is_billable()
)

hours_worked = sum(billable_times)

注意到代码已经发生了很大变化。

上面这种使用 lazy iterable 的方式允许我们命名之前没有命名的东西（

billable_times

sum

sum

Laziness and breaking out of loops

下面的代码输出一个日志文件的前 10 行：

for i, line in enumerate(log_file):
if i >= 10:
break
print(line)

下面的代码实现了同样的功能，但是我们使用了

itertools.islice

from itertools import islice

first_ten_lines = islice(log_file, 10)
for line in first_ten_lines:
print(line)

我们这里创建的

first_ten_lines

first_ten_lines

此外我们也不用再写

break

islice

你可以在内置库

itertools

Creating your own iteration helpers

你可以再内置库或者第三方库中找到一些 iterator 的帮助函数，但是你也可以自己写！

下面的代码用于计算一个序列中相邻两个数字的差，返回一个 list。

current = readings[0]
for next_item in readings[1:]:
differences.append(next_item - current)
current = next_item

注意这个代码需要在每一次循环中额外的给一个变量赋值。同时这个代码也只适用于有索引功能的对象，比如 sequence。如果

readings

让我们来写一个帮助函数来修复这个问题。

这是一个 generator 函数，对于一个 iterable，在每次循环中输出当前项和下一项：

def with_next(iterable):
"""Yield (current, next_item) tuples for each item in iterable."""
iterator = iter(iterable)
current = next(iterator)
for next_item in iterator:
yield current, next_item
current = next_item

这里我们手动从 iterable 得到了一个 iterator，使用

next

下面的代码使用上面的

with_next

next_item

differences = []
for current, next_item in with_next(readings):
differences.append(next_item - current)

注意我们不必在循环中略显笨拙地对

next_item

with_next

同时这个代码也足够紧凑，如果需要的话我们甚至可以转换成一个 list comprehension。

differences = [
(next_item - current)
for current, next_item in with_next(readings)
]

Looping Gotchas: Revisited

此时我们可以回到刚开始我们提到的那些奇怪的问题，让我们来搞清楚发生了什么。

Gotcha 1: Exhausting an Iterator

这里我们有一个 generator 对象，

squares

>>> numbers = [1, 2, 3, 5, 7]
>>> squares = (n**2 for n in numbers)

如果把他传入

tuple

>>> numbers = [1, 2, 3, 5, 7]
>>> squares = (n**2 for n in numbers)>>> tuple(squares)
(1, 4, 9, 25, 49)

然后如果我们计算这个 generator 中所有数字的和，那么结果就会是

0

>>> sum(squares)
0

因为此时这个 generator 已经是空的了，我们已经消耗完了（译者注：遍历完了）。如果我们再次使用

tuple

>>> tuple(squares)
()

Genetor 是一种 iterator，iterator 是只能使用一次的 iterable。

Gotcha 2: Partially-Consuming an Iterator

同样我们有一个 generator 对象，

squares

>>> numbers = [1, 2, 3, 5, 7]
>>> squares = (n**2 for n in numbers)

如果我们要查询

9

True

>>> 9 in squares
True

但如果我们再查一次，就会得到

False

>>> 9 in squares
False

当我们第一次查询

9

>>> numbers = [1, 2, 3, 5, 7]
>>> squares = (n**2 for n in numbers)>>> 9 in squares
True>>> list(squares)
[25, 49]

查询某对象是否在一个 iterator 中的时候会部分消耗（译者注：遍历）这个 iterator。如果不循环我们是没办法知道一个对象是否在 iterator 中的。

Gotcha 3: Unpacking is iteration

当你遍历 dict 的时候得到的是 key：

>>> counts = {'apples': 2, 'oranges': 1}>>> for key in counts:
...     print(key)
...
apples
oranges

当你解包（unpack）一个 dict 的时候，你得到的也是 key：

>>> x, y = counts>>> x, y
('apples', 'oranges')

循环依赖于 iterator protocol。解包 iterable 同样依赖于 iterator protocol。解包 dict 和遍历 dict 是一样的，都是使用的 iterator protocol，所以得到的结果是一样的。

Recap and related resources

Sequence 是 iterable，但不是所有的 iterable 都是 sequence。当某个人说 「iterable」的时候，你可以假定他说的是「你可以遍历的东西」，但是不要假定你可以遍历两次，查询长度或者索引。

Iterator 是 Python 中最基本的 iterable 形式。如果你在代码中想要一个 lazy iterable，那么考虑 iterator，创建一个 generator 函数或者 generator expression。

最后请记住，Python 中的每种类型的遍历都依赖于 iterator protocol，因此理解 iterator protocol 是了解 Python 中循环的关键。

这里是我推荐的一些相关文章和视频：

• Loop Like a Native，Ned Batchelder 在 PyCon 2013 上的演讲
• Loop Better，这篇文章对应的演讲【YouTube】
• The Iterator Protocol: How For Loops Work，我写的关于 iterator protocol 的一篇短文
• Comprehensible Comprehensions，我关于 comprehension 和 generator expression 的演讲【YouTube】
• Python: range is not an iterator，我的关于 range 和 iterator 的文章
• Looping Like a Pro in Python，DB 在 PyCon 2017 上的演讲

译者后记：

• 按照译者理解，iterable、iterator 和 generator 的范围大小是：iterable > iterator > generator，generator 是 iterator 的子类型，详细参见 Python Generators vs Iterators - Comparison Between Python Iterators and Generators - DataFlair

• 点赞 3
• 收藏
• 分享
• 文章举报