From 05f75c63aaf91ad6a0084e0d30704ef2debab876 Mon Sep 17 00:00:00 2001 From: "Xingyu.Wang" Date: Sat, 26 May 2018 08:06:41 +0800 Subject: [PATCH] PRF:20180327 Loop better- A deeper look at iteration in Python.md @MjSeven --- ...r- A deeper look at iteration in Python.md | 360 +++++------------- 1 file changed, 105 insertions(+), 255 deletions(-) diff --git a/translated/tech/20180327 Loop better- A deeper look at iteration in Python.md b/translated/tech/20180327 Loop better- A deeper look at iteration in Python.md index 32cd9842e7..e5de0dea0c 100644 --- a/translated/tech/20180327 Loop better- A deeper look at iteration in Python.md +++ b/translated/tech/20180327 Loop better- A deeper look at iteration in Python.md @@ -1,9 +1,11 @@ -Loop better：更深入的理解Python 中的迭代 +更深入的理解 Python 中的迭代 ==== +> 深入探讨 Python 的 `for` 循环来看看它们在底层如何工作，以及为什么它们会按照它们的方式工作。 + ![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/pez-candy.png?itok=tRoOn_iy) -Python 的 `for` 循环不会像其他语言中的 `for` 循环那样工作。在这篇文章中，我们将深入探讨 Python 的 `for` 循环来看看它们如何在底层工作，以及为什么它们会按照它们的方式工作。 +Python 的 `for` 循环不会像其他语言中的 `for` 循环那样工作。在这篇文章中，我们将深入探讨 Python 的 `for` 循环来看看它们在底层如何工作，以及为什么它们会按照它们的方式工作。 ### 循环的问题 @@ -12,27 +14,24 @@ Python 的 `for` 循环不会像其他语言中的 `for` 循环那样工作。 #### 问题 1：循环两次 假设我们有一个数字列表和一个生成器，生成器会返回这些数字的平方： + ``` >>> numbers = [1, 2, 3, 5, 7] - >>> squares = (n**2 for n in numbers) - ``` 我们可以将生成器对象传递给 `tuple` 构造器，从而使其变为一个元组： + ``` >>> tuple(squares) - (1, 4, 9, 25, 49) - ``` -如果我们使用相同的生成器对象并将其传给 `sum` 函数，我们可能会期望得到这些数的和，即 88。 +如果我们使用相同的生成器对象并将其传给 `sum` 函数，我们可能会期望得到这些数的和，即 `88`。 + ``` >>> sum(squares) - 0 - ``` 但是我们得到了 `0`。 @@ -40,6 +39,7 @@ Python 的 `for` 循环不会像其他语言中的 `for` 循环那样工作。 #### 问题 2：包含的检查 让我们使用相同的数字列表和相同的生成器对象： + ``` >>> numbers = [1, 2, 3, 5, 7] @@ -48,15 +48,12 @@ Python 的 `for` 循环不会像其他语言中的 `for` 循环那样工作。 ``` 如果我们询问 `9` 是否在 `squares` 生成器中，Python 将会告诉我们 9 在 `squares` 中。但是如果我们再次询问相同的问题，Python 会告诉我们 9 不在 `squares` 中。 + ``` >>> 9 in squares - True - >>> 9 in squares - False - ``` 我们询问相同的问题两次，Python 给了两个不同的答案。 @@ -64,57 +61,51 @@ False #### 问题 3 ：拆包 这个字典有两个键值对： + ``` >>> counts = {'apples': 2, 'oranges': 1} - ``` 让我们使用多个变量来对这个字典进行拆包： + ``` >>> x, y = counts - ``` 你可能会期望当我们对这个字典进行拆包时，我们会得到键值对或者得到一个错误。 但是解包字典不会引发错误，也不会返回键值对。当你解包一个字典时，你会得到键： + ``` >>> x - 'apples' - ``` -### 回顾：Python 的 __for__ 循环 +### 回顾：Python 的 for 循环 在我们了解一些关于这些 Python 片段的逻辑之后，我们将回到这些问题。 Python 没有传统的 `for` 循环。为了解释我的意思，让我们看一看另一种编程语言的 `for` 循环。 这是一种传统 C 风格的 `for` 循环，用 JavaScript 编写： + ``` let numbers = [1, 2, 3, 5, 7]; - for (let i = 0; i < numbers.length; i += 1) { -     print(numbers[i]) - } - ``` -JavaScript, C, C++, Java, PHP, 和一大堆其他编程语言都有这种风格的 `for` 循环，但是 Python **确实没**。 +JavaScript、 C、 C++、 Java、 PHP 和一大堆其他编程语言都有这种风格的 `for` 循环，但是 Python **确实没有**。 -Python **确实没** 有传统 C 风格的 `for` 循环。在 Python 中确实有一些我们称之为 `for` 循环的东西，但是它的工作方式类似于 [foreach loop][1]。 +Python **确实没有** 传统 C 风格的 `for` 循环。在 Python 中确实有一些我们称之为 `for` 循环的东西，但是它的工作方式类似于 [foreach 循环][1]。 这是 Python 的 `for` 循环的风格： + ``` numbers = [1, 2, 3, 5, 7] - for n in numbers: -     print(n) - ``` 与传统 C 风格的 `for` 循环不同，Python 的 `for` 循环没有索引变量，没有索引变量初始化，边界检查，或者索引递增。Python 的 `for` 循环完成了对我们的 `numbers` 列表进行遍历的所有工作。 @@ -126,98 +117,75 @@ for n in numbers: 既然我们已经解决了 Python 世界中无索引的 `for` 循环，那么让我们在此之外来看一些定义。 **可迭代**是任何你可以用 Python 中的 `for` 循环遍历的东西。可迭代意味着可以遍历，任何可以遍历的东西都是可迭代的。 + ``` for item in some_iterable: -     print(item) - ``` 序列是一种非常常见的可迭代类型，列表，元组和字符串都是序列。 + ``` >>> numbers = [1, 2, 3, 5, 7] - >>> coordinates = (4, 5, 7) - >>> words = "hello there" - ``` 序列是可迭代的，它有一些特定的特征集。它们可以从 `0` 开始索引，以小于序列的长度结束，它们有一个长度并且它们可以被切分。列表，元组，字符串和其他所有序列都是这样工作的。 + ``` >>> numbers[0] - 1 - >>> coordinates[2] - 7 - >>> words[4] - 'o' - ``` -Python 中很多东西都是可迭代的，但不是所有可迭代的东西都是序列。集合，字典，文件和生成器都是可迭代的，但是它们都不是序列。 +Python 中很多东西都是可迭代的，但不是所有可迭代的东西都是序列。集合、字典、文件和生成器都是可迭代的，但是它们都不是序列。 + ``` >>> 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` 循环遍历的东西都是可迭代的，序列只是一种可迭代的类型，但是 Python 也有许多其他种类的迭代器。 -### Python 的 __for__ 循环不使用索引 +### Python 的 for 循环不使用索引 + +你可能认为，Python 的 `for` 循环在底层使用了索引进行循环。在这里我们使用 `while` 循环和索引手动遍历： -你可能认为，在 hood 下的 `for` 循环中使用索引进行循环。在这里我们使用 `while` 循环和索引手动遍历： ``` numbers = [1, 2, 3, 5, 7] - i = 0 - while i < len(numbers): -     print(numbers[i]) -     i += 1 - ``` 这适用于列表，但它不会对所有东西都起作用。这种循环方式**只适用于序列**。 如果我们尝试用索引去手动遍历一个集合，我们会得到一个错误： + ``` >>> fruits = {'lemon', 'apple', 'orange', 'watermelon'} - >>> i = 0 - >>> while i < len(fruits): - ...     print(fruits[i]) - ...     i += 1 - ... - Traceback (most recent call last): - File "", line 2, in - TypeError: 'set' object does not support indexing - ``` 集合不是序列，所以它们不支持索引。 我们不能使用索引手动对 Python 中的每一个迭代对象进行遍历。对于那些不是序列的迭代器来说，这是行不通的。 -### 迭代器驱动 __for__ 循环 +### 迭代器驱动 for 循环 因此，我们已经看到，Python 的 `for` 循环在底层不使用索引。相反，Python 的 `for` 循环使用**迭代器**。 @@ -226,148 +194,116 @@ TypeError: 'set' object does not support indexing 让我们来看看它是如何工作的。 这里有三个可迭代对象：一个集合，一个元组和一个字符串。 + ``` >>> numbers = {1, 2, 3, 5, 7} - >>> coordinates = (4, 5, 7) - >>> words = "hello there" - ``` 我们可以使用 Python 的内置 `iter` 函数来访问这些迭代器，将一个迭代器传递给 `iter` 函数总会给我们返回一个迭代器，无论我们正在使用哪种类型的迭代器。 + ``` >>> iter(numbers) - - >>> iter(coordinates) - - >>> iter(words) - - ``` 一旦我们有了迭代器，我们可以做的事情就是通过将它传递给内置的 `next` 函数来获取它的下一项。 ``` >>> numbers = [1, 2, 3] - >>> my_iterator = iter(numbers) - >>> next(my_iterator) - 1 - >>> next(my_iterator) - 2 - ``` 迭代器是有状态的，这意味着一旦你从它们中消耗了一项，它就消失了。 如果你从迭代器中请求 `next` 项，但是其中没有更多的项了，你将得到一个 `StopIteration` 异常： + ``` >>> next(my_iterator) - 3 - >>> next(my_iterator) - Traceback (most recent call last): -   File "", line 1, in - StopIteration - ``` 所以你可以从每个迭代中获得一个迭代器，迭代器唯一能做的事情就是用 `next` 函数请求它们的下一项。如果你将它们传递给 `next`，但它们没有下一项了，那么就会引发 `StopIteration` 异常。 -你可以将迭代器想象成 Pez 分配器（译注：Pez 是一个结合玩具的独特复合式糖果），不能重新分配。你可以把 Pez 拿出去，但是一旦 Pez 被移走，它就不能被放回去，一旦分配器空了，它就没用了。 +你可以将迭代器想象成 Pez 分配器（LCTT 译注：Pez 是一个结合玩具的独特复合式糖果），不能重新分配。你可以把 Pez 拿出去，但是一旦 Pez 被移走，它就不能被放回去，一旦分配器空了，它就没用了。 -### 没有 __for__ 的循环 +### 没有 for 的循环 既然我们已经了解了迭代器和 `iter` 以及 `next` 函数，我们将尝试在不使用 `for` 循环的情况下手动遍历迭代器。 我们将通过尝试将这个 `for` 循环变为 `while` 循环： + ``` def funky_for_loop(iterable, action_to_do): -     for item in iterable: -         action_to_do(item) - ``` 为了做到这点，我们需要： + 1. 从给定的可迭代对象中获得迭代器 2. 反复从迭代器中获得下一项 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` 循环和迭代器重新定义了 `for` 循环。 上面的代码基本上定义了 Python 在底层循环的工作方式。如果你理解内置的 `iter` 和 `next` 函数的遍历循环的工作方式，那么你就会理解 Python 的 `for` 循环是如何工作的。 -事实上，你不仅仅会理解 `for` 循环在 Python 中式如何工作的，所有形式的遍历一个可迭代对象都是这样工作的。 +事实上，你不仅仅会理解 `for` 循环在 Python 中是如何工作的，所有形式的遍历一个可迭代对象都是这样工作的。 -**迭代器协议** 是一种很好的方式，它表示 "在 Python 中遍历迭代器是如何工作的"。它本质上是对 `iter` 和 `next` 函数在 Python 中是如何工作的定义。Python 中所有形式的迭代都是由迭代器协议驱动的。 +迭代器协议iterator protocol 是一种很好表示 “在 Python 中遍历迭代器是如何工作的”的方式。它本质上是对 `iter` 和 `next` 函数在 Python 中是如何工作的定义。Python 中所有形式的迭代都是由迭代器协议驱动的。 迭代器协议被 `for` 循环使用（正如我们已经看到的那样）： + ``` for n in numbers: -     print(n) - ``` 多重赋值也使用迭代器协议： + ``` x, y, z = coordinates - ``` 星型表达式也是用迭代器协议： + ``` a, b, *rest = numbers - print(*numbers) - ``` 许多内置函数依赖于迭代器协议： + ``` unique_numbers = set(numbers) - ``` 在 Python 中任何与迭代器一起工作的东西都可能以某种方式使用迭代器协议。每当你在 Python 中遍历一个可迭代对象时，你将依赖于迭代器协议。 @@ -379,41 +315,31 @@ unique_numbers = set(numbers) 我有消息告诉你：在 Python 中直接使用迭代器是很常见的。 这里的 `squares` 对象是一个生成器： + ``` >>> numbers = [1, 2, 3] - >>> squares = (n**2 for n in numbers) - ``` 生成器是迭代器，这意味着你可以在生成器上调用 `next` 来获得它的下一项： + ``` >>> next(squares) - 1 - >>> next(squares) - 4 - ``` 但是如果你以前用过生成器，你可能也知道可以循环遍历生成器： + ``` >>> squares = (n**2 for n in numbers) - >>> for n in squares: - ...     print(n) - ... - 1 - 4 - 9 - ``` 如果你可以在 Python 中循环遍历某些东西，那么它就是**可迭代的**。 @@ -424,90 +350,84 @@ unique_numbers = set(numbers) 所以在我之前解释迭代器如何工作时，我跳过了它们的某些重要的细节。 -**生成器是可迭代的。** +#### 生成器是可迭代的 我再说一遍：Python 中的每一个迭代器都是可迭代的，意味着你可以循环遍历迭代器。 因为迭代器也是可迭代的，所以你可以使用内置 `next` 函数从可迭代对象中获得迭代器： + ``` >>> numbers = [1, 2, 3] - >>> iterator1 = iter(numbers) - >>> iterator2 = iter(iterator1) - ``` 请记住，当我们在可迭代对象上调用 `iter` 时，它会给我们返回一个迭代器。 当我们在迭代器上调用 `iter` 时，它会给我们返回它自己： + ``` >>> iterator1 is iterator2 - True - ``` 迭代器是可迭代的，所有的迭代器都是它们自己的迭代器。 + ``` def is_iterator(iterable): -     return iter(iterable) is iterable - ``` 迷惑了吗？ 让我们回顾一些这些措辞。 + * 一个**可迭代对象**是你可以迭代的东西 -* 一个**可迭代对象**是一种可以迭代遍历迭代的代理 -（这句话不是很理解） +* 一个**迭代对象器**是一种实际上遍历可迭代对象的代理 此外，在 Python 中迭代器也是可迭代的，它们充当它们自己的迭代器。 所以迭代器是可迭代的，但是它们没有一些可迭代对象拥有的各种特性。 迭代器没有长度，它们不能被索引： + ``` >>> 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 程序员的角度来看，你可以使用迭代器来做的唯一有用的事情是将其传递给内置的 `next` 函数，或者对其进行循环遍历： + ``` >>> next(iterator) - 1 - >>> list(iterator) - [2, 3, 5, 7] - ``` 如果我们第二次循环遍历迭代器，我们将一无所获： + ``` >>> list(iterator) - [] - ``` 你可以把迭代器看作是**惰性迭代器**，它们是**一次性使用**，这意味着它们只能循环遍历一次。 正如你在下面的真值表中所看到的，可迭代对象并不总是迭代器，但是迭代器总是可迭代的： -可迭代对象？迭代器？可迭代的？ ✔️ ❓ 迭代器 ✔️ ✔️ 生成器 ✔️ ✔️ 列表 ✔️ ❌ + +对象 | 可迭代？ | 迭代器？ +---------|---------|------ +可迭代对象 | V | ? +迭代器 | V | V +生成器 | V | V +列表 | V | X + ### 全部的迭代器协议 @@ -535,45 +455,33 @@ TypeError: 'list_iterator' object is not subscriptable ### 迭代器无处不在 你已经在 Python 中看到过许多迭代器，我也提到过生成器是迭代器。Python 的许多内置类型也是迭代器。例如，Python 的 `enumerate` 和 `reversed` 对象就是迭代器。 + ``` >>> letters = ['a', 'b', 'c'] - >>> e = enumerate(letters) - >>> e - - >>> next(e) - (0, 'a') - ``` 在 Python 3 中，`zip`, `map` 和 `filter` 也是迭代器。 + ``` >>> numbers = [1, 2, 3, 5, 7] - >>> letters = ['a', 'b', 'c'] - >>> z = zip(numbers, letters) - >>> z - - >>> next(z) - (1, 'a') - ``` -Python 中的 文件对象也是迭代器。 +Python 中的文件对象也是迭代器。 + ``` >>> next(open('hello.txt')) - 'hello world\n' - ``` 在 Python 标准库和第三方库中内置了大量的迭代器。这些迭代器首先惰性迭代器一样，延迟工作直到你请求它们下一项。 @@ -584,51 +492,37 @@ Python 中的 文件对象也是迭代器。 知道你已经在使用迭代器是很有用的，但是我希望你也知道，你可以创建自己的迭代器和你自己的惰性迭代器。 下面这个类构造了一个迭代器接受一个可迭代的数字，并在循环结束时提供每个数字的平方。 + ``` class square_all: -     def __init__(self, numbers): -         self.numbers = iter(numbers) -     def __next__(self): -         return next(self.numbers) * 2 -     def __iter__(self): -         return self - ``` 但是在我们开始对该类的实例进行循环遍历之前，没有任何工作要做。 这里，我们有一个无限长的可迭代对象 `count`，你可以看到 `square_all` 接受 `count` 而不用完全循环遍历这个无限长的迭代： + ``` >>> from itertools import count - >>> numbers = count(5) - >>> squares = square_all(numbers) - >>> next(squares) - 25 - >>> next(squares) - 36 - ``` 这个迭代器类是有效的，但我们通常不会这样做。通常，当我们想要做一个定制的迭代器时，我们会生成一个生成器函数： + ``` def square_all(numbers): - for n in numbers: - yield n**2 - ``` 这个生成器函数等价于我们上面所做的类，它的工作原理是一样的。 @@ -636,14 +530,13 @@ def square_all(numbers): 这种 `yield` 语句似乎很神奇，但它非常强大：`yield` 允许我们在调用 `next` 函数之间暂停生成器函数。`yield` 语句是将生成器函数与常规函数分离的东西。 另一种实现相同迭代器的方法是使用生成器表达式。 + ``` def square_all(numbers): - return (n**2 for n in numbers) - ``` -这和我们的生成器函数确实是一样的，但是它使用的语法看起来[像列表一样容易理解][2]。如果你需要在代码中使用惰性迭代，请考虑迭代器，并考虑使用生成器函数或生成器表达式。 +这和我们的生成器函数确实是一样的，但是它使用的语法看起来[像是一个列表推导一样][2]。如果你需要在代码中使用惰性迭代，请考虑迭代器，并考虑使用生成器函数或生成器表达式。 ### 迭代器如何改进你的代码 @@ -652,33 +545,24 @@ def square_all(numbers): #### 惰性求和 这是一个 `for` 循环，它对 Django queryset 中的所有工作时间求和： + ``` hours_worked = 0 - for event in events: - if event.is_billable(): - hours_worked += event.duration - ``` 下面是使用生成器表达式进行惰性评估的代码： + ``` billable_times = ( - event.duration - for event in events - if event.is_billable() - ) - - hours_worked = sum(billable_times) - ``` 请注意，我们代码的形状发生了巨大变化。 @@ -688,27 +572,21 @@ hours_worked = sum(billable_times) #### 惰性和打破循环 这段代码打印出日志文件的前 10 行： + ``` for i, line in enumerate(log_file): - if i >= 10: - break - print(line) - ``` 这段代码做了同样的事情，但是我们使用的是 `itertools.islice` 函数来惰性地抓取文件中的前 10 行： + ``` 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`)。命名事物可以使我们的代码更具描述性，更具可读性。 @@ -722,15 +600,12 @@ for line in first_ten_lines: 你可以在标准库和第三方库中找到用于循环的辅助函数，但你也可以自己创建！ 这段代码列出了序列中连续值之间的差值列表。 + ``` current = readings[0] - for next_item in readings[1:]: - differences.append(next_item - current) - current = next_item - ``` 请注意，这段代码中有一个额外的变量，我们每次循环时都要指定它。还要注意，这段代码只适用于我们可以切片的东西，比如序列。如果 `readings` 是一个生成器，一个 zip 对象或其他任何类型的迭代器，那么这段代码就会失败。 @@ -738,47 +613,36 @@ for next_item in readings[1:]: 让我们编写一个辅助函数来修复代码。 这是一个生成器函数，它为给定的迭代中的每个项目提供了当前项和下一项： + ``` 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 - ``` 我们从可迭代对象中手动获取一个迭代器，在它上面调用 `next` 来获取第一项，然后循环遍历迭代器获取后续所有的项目，跟踪后一个项目。这个函数不仅适用于序列，而且适用于任何类型迭代。 -这段代码和以前代码是一样的，但是我们使用的是辅助函数而不是手动跟踪 `next_item`: +这段代码和以前代码是一样的，但是我们使用的是辅助函数而不是手动跟踪 `next_item`： + ``` differences = [] - for current, next_item in with_next(readings): - differences.append(next_item - current) - ``` 请注意，这段代码不会挂在我们循环周围的 `next_item` 上，`with_next` 生成器函数处理跟踪 `next_item` 的工作。 -还要注意，这段代码已足够紧凑，如果我们愿意，我们甚至可以[将方法复制到列表中来理解][2]。 +还要注意，这段代码已足够紧凑，如果我们愿意，我们甚至可以[将方法复制到列表推导中来][2]。 + ``` differences = [ - (next_item - current) - for current, next_item in with_next(readings) - ] - ``` ### 再次回顾循环问题 @@ -787,40 +651,34 @@ differences = [ #### 问题 1：耗尽的迭代器 -这里我们有一个生成器对象 `squares`: +这里我们有一个生成器对象 `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) - ``` -如果我们试着计算这个生成器中数字的和，使用 `sum`,我们就会得到 `0`: +如果我们试着计算这个生成器中数字的和，使用 `sum`,我们就会得到 `0`： + ``` >>> sum(squares) - 0 - ``` 这个生成器现在是空的：我们已经把它耗尽了。如果我们试着再次创建一个元组，我们会得到一个空元组： + ``` >>> tuple(squares) - () - ``` 生成器是迭代器，迭代器是一次性的。它们就像 Hello Kitty Pez 分配器那样不能重新加载。 @@ -828,43 +686,35 @@ differences = [ #### 问题 2：部分消耗一个迭代器 再次使用那个生成器对象 `squares`： + ``` >>> numbers = [1, 2, 3, 5, 7] - >>> squares = (n**2 for n in numbers) - ``` -如果我们询问 `9` 是否在 `squares` 生成器中，我们会得到 `True`: +如果我们询问 `9` 是否在 `squares` 生成器中，我们会得到 `True`： + ``` >>> 9 in squares - True - ``` -但是我们再次询问相同的问题，我们会得到 `False`: +但是我们再次询问相同的问题，我们会得到 `False`： + ``` >>> 9 in squares - False - ``` 当我们询问 `9` 是否在迭代器中时，Python 必须对这个生成器进行循环遍历来找到 `9`。如果我们在检查了 `9` 之后继续循环遍历，我们只会得到最后两个数字，因为我们已经在找到 9 之前消耗了这些数字： + ``` >>> numbers = [1, 2, 3, 5, 7] - >>> squares = (n**2 for n in numbers) - >>> 9 in squares - True - >>> list(squares) - [25, 49] - ``` 询问迭代器中是否包含某些东西将会部分地消耗迭代器。如果没有循环遍历迭代器，那么是没有办法知道某个东西是否在迭代器中。 @@ -872,36 +722,29 @@ True #### 问题 3：拆包是迭代 当你在字典上循环时，你会得到键： + ``` >>> counts = {'apples': 2, 'oranges': 1} - >>> for key in counts: - ... print(key) - ... - apples - oranges - ``` 当你对一个字典进行拆包时，你也会得到键： + ``` >>> x, y = counts - >>> x, y - ('apples', 'oranges') - ``` 循环依赖于迭代器协议，可迭代对象拆包也依赖于有迭代器协议。拆包一个字典与在字典上循环遍历是一样的，两者都使用迭代器协议，所以在这两种情况下都得到相同的结果。 ### 回顾 -序列是迭代器，但是不是所有的迭代器都是序列。当有人说“迭代器”这个词时，你只能假设他们的意思是“你可以迭代的东西”。不要假设迭代器可以被循环遍历两次，询问它们的长度，或者索引。 +序列是迭代器，但是不是所有的迭代器都是序列。当有人说“迭代器”这个词时，你只能假设他们的意思是“你可以迭代的东西”。不要假设迭代器可以被循环遍历两次、询问它们的长度或者索引。 迭代器是 Python 中最基本的可迭代形式。如果你想在代码中做一个惰性迭代，请考虑迭代器，并考虑使用生成器函数或生成器表达式。 @@ -909,8 +752,15 @@ oranges 这里有一些我推荐的相关文章和视频： -本文是基于作者去年在 [DjangoCon AU][6], [PyGotham][7] 和 [North Bay Python][8] 中发表的 Loop Better 演讲。有关更多内容，请参加将于 2018 年 5 月 9 日至 17 日在 Columbus, Ohio 举办的 [PYCON][9]。 +- [Loop Like a Native](https://nedbatchelder.com/text/iter.html)， Ned Batchelder 在 PyCon 2013 的讲演 +- [Loop Better](https://www.youtube.com/watch?v=V2PkkMS2Ack) ，这篇文章是基于这个讲演的 +- [The Iterator Protocol: How For Loops Work](http://treyhunner.com/2016/12/python-iterator-protocol-how-for-loops-work/)，我写的关于迭代器协议的短文 +- [Comprehensible Comprehensions](https://www.youtube.com/watch?v=5_cJIcgM7rw)，关于推导和迭代器表达器的讲演 +- [Python: Range is Not an Iterator](http://treyhunner.com/2018/02/python-range-is-not-an-iterator/)，我关于范围和迭代器的文章 +- [Looping Like a Pro in Python](https://www.youtube.com/watch?v=u8g9scXeAcI)，DB 的 PyCon 2017 讲演 + +本文是基于作者去年在 [DjangoCon AU][6]、 [PyGotham][7] 和 [North Bay Python][8] 中发表的 Loop Better 演讲。有关更多内容，请参加将于 2018 年 5 月 9 日至 17 日在 Columbus， Ohio 举办的 [PYCON][9]。 -------------------------------------------------------------------------------- @@ -919,7 +769,7 @@ via: https://opensource.com/article/18/3/loop-better-deeper-look-iteration-pytho 作者：[Trey Hunner][a] 译者：[MjSeven](https://github.com/MjSeven) -校对：[校对者ID](https://github.com/校对者ID) +校对：[wxy](https://github.com/wxy) 本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出