学习如何以及何时在 Lua 中使用 while 和 repeat until 循环。控制结构是编程语言的一个重要特征，因为它们使你能够根据通常在程序运行时动态建立的条件来指导程序的流程。不同的语言提供了不同的控制，在 Lua 中，有 while 循环、for 循环和 repeat until 循环。这篇文章涵盖了 while 和 repeat until 循环。由于它们的灵活性，我在一篇 单独的文章 中介绍 for 循环。条件是由一个使用运算符的表达式来定义的，运算符是你在数学课上可能认识的符号的一个花哨的术语。Lua 中有效的运算符有：== 等于~=不等于< 小于> 大于⇐小于或等于>= 大于或等于这些被称为关系运算符，因为它们比较两个值之间的关联。还有一些逻辑运算符，其含义与英语中的含义相同，可以纳入条件中，进一步描述你想检查的状态：andor下面是一些条件的例子：foo > 3：变量 foo 是否大于 3？foo 必须是 4 或更大才能满足这个条件。foo >= 3：foo 是否大于或等于 3？foo 必须是 3 或更大才能满足这个条件。foo > 3 and bar < 1：foo 是否大于 3 而 bar 小于 1？要满足这个条件，foo 变量必须在 bar 为 0 的同时为 4 或更大。foo> 3 or bar < 1：foo 是否大于 3？或者，bar 是否小于 1？如果 foo 是 4 或更大，或者 bar 是 0，那么这个条件就是真的。如果 foo 是 4 或更大，而 bar 是 0，会怎样？答案出现在本文的后面。While 循环只要满足某个条件，while 循环就会执行指令。例如，假设你正在开发一个应用来监测正在进行的僵尸末日。当没有剩余的僵尸时，就不再有僵尸末日了：zombie = 1024 while (zombie > 0) do print(zombie) zombie = zombie-1 end if zombie == 0 then print("No more zombie apocalypse!") end 运行代码，看僵尸消失：$ lua ./while.lua 1024 1023 [...] 3 2 1 No more zombie apocalypse! until 循环Lua 还有一个 repeat until 循环结构，本质上是一个带有 catch 语句的 while 循环。假设你在从事园艺工作，你想追踪还剩下什么可以收获的东西：mytable = { "tomato", "lettuce", "brains" } bc = 3 repeat print(mytable[bc]) bc = bc - 1 until( bc == 0 ) 运行代码：$ lua ./until.lua brains lettuce tomato 这很有帮助!无限循环一个无限循环有一个永远无法满足的条件，所以它无限地运行。这通常是一个由错误逻辑或你的程序中的意外状态引起的错误。例如，在本文的开头，我提出了一个逻辑难题。如果一个循环被设定为 foo > 3 or bar < 1 运行 ，那么当 foo 为 4 或更大而 bar 为 0 时，会发生什么？下面是解决这个问题的代码，为了以防万一，还使用了 break 语句安全捕获：foo = 9 bar = 0 while ( foo > 3 or bar < 1 ) do print(foo) foo = foo-1 -- safety catch if foo < -800000 then break end end 你可以安全地运行这段代码，但它确实模仿了一个意外的无限循环。有缺陷的逻辑是 or 运算符，它允许这个循环在 foo 大于 3 和 bar 小于 1 的情况下继续进行。and 运算符有不同的效果，但我让你去探索。无限循环实际上有其用途。图形应用使用技术上的无限循环来保持应用程序窗口的开放。我们没有办法知道用户打算使用这个程序多久，所以程序无限地运行，直到用户选择退出。在这些情况下使用的简单条件显然是一个总是被满足的条件。下面是一个无限循环的例子，为了方便起见，还是内置了一个安全陷阱：n = 0 while true do print(n) n = n+1 if n > 100 then break end end 条件 while true 总是被满足，因为 true 总是为真。这是比写 while 1 == 1 或类似的永远为真的简洁方式。Lua 中的循环从示例代码中可以看出，尽管有不同的实现方式，但循环基本上都是朝着同一个目标工作。选择一个对你来说有意义的，并且在你需要执行的处理过程中效果最好的。以防万一你需要它：终止失控循环的键盘快捷键是 Ctrl+C。via: https://opensource.com/article/23/2/lua-loops-while-repeat-until作者：Seth Kenlon 选题：lkxed 译者：geekpi 校对：wxy本文由 LCTT 原创编译，Linux中国 荣誉推出
无论你使用的是 while 循环、do/while 循环，还是无限循环，了解循环的工作原理对 Java 编程至关重要。只要某些预定的条件为真，一个 while 循环就会执行一组任务。这被认为是一个控制结构，可以指导程序的流程。它是一种你可以通过定义一个条件来告诉你的代码要做什么的方法，它可以测试它，并根据它发现的情况采取行动。Java 中的两种 while 循环是 while 和 do/while。Java while 循环while 循环的目的是对数据进行迭代，直到某个条件得到满足。要创建一个 while 循环，你需要提供一个可以测试的条件，然后是你想要运行的代码。Java 有几个内置的测试函数，其中最简单的是数学运算符（<, >, ==, 等等）：package com.opensource.example; public class Example { public static void main(String[] args) { int count = 0; while (count < 5) { System.out.printf("%d ", count); count++; } } } 在这个简单的例子中，条件是变量 count 小于 5。因为 count 被实例化为 0，然后在 while 循环的代码中增加 1，所以程序总共迭代了 5 次：$ java ./while.java 0 1 2 3 4 在它进行第六次迭代之前，条件不再是真的，所以循环结束。while 循环的条件语句是至关重要的。弄错了可能意味着你的循环永远不会执行。例如，假设你把 count == 5 作为条件：while (count == 5) { System.out.printf("%d ", count); count++; 当你运行这段代码时，它的构建和运行都很成功，但什么也没有发生：$ java ./while.java $ 循环被跳过了，因为 count 被设置为 0，而且在第一次遇到 while 循环的时候，它还是 0。循环从未开始，count 也从未被递增。与此相反的是，当一个条件开始为真，并且永远不会为假时，这将导致一个无限循环。Java do while 循环与 while 循环相似，do/while 循环在每次迭代结束时测试条件，而不是在开始时测试条件。有了这个循环，循环中的代码至少运行一次，因为没有进入的入口，只有退出的出口:package com.opensource.example; public class Example { public static void main(String[] args) { int count = 9; do { System.out.printf("%d ", count); count++; } while(count == 5); } } 在这个示例代码中，count 被设置为 9。循环重复的条件是 count 等于 5，但是 9 不等于 5。不过，这个检查要到第一次迭代结束时才进行：$ java ./do.java 9 Java 无限循环无限循环，正如它的名字所示，永远不会结束。有时它们是被错误地创建的，但无限循环确实有一个有效的场景。有时你想让一个进程无限地继续下去（在功能上是无限的，因为你不能保证你需要它什么时候停止），因此你可能会把你的条件设置为不可能满足的东西。假设你写了一个应用程序，在僵尸天启期间计算留在你附近的僵尸的数量。为了模拟需要多少个循环才能达到 0 个僵尸的不确定性，我的演示代码从操作系统中检索了一个时间戳，并将计数器（c）的值设置为从该时间戳得出的某个数字。因为这是一个简单的例子，你不会真的想陷入一个无限循环，这段代码倒数到 0，并使用 break 函数来强制结束循环：package com.opensource.example; public class Example { public static void main(String[] args) { long myTime = System.currentTimeMillis(); int c; if ( myTime%2 == 0 ) { c = 128; } else { c = 1024; } while(true) { System.out.printf("%d Zombies\n", c); // break for convenience if ( c <= 0 ) { break; } c--; } } } 你可能要运行几次才能触发不同的僵尸总数，但有时你的程序会迭代 128 次，有时会迭代 1024 次：$ java ./zcount.java 1024 Zombies 1023 Zombies [...] 0 Zombies 你能说出为什么循环的终点是 0 而不是 -1 吗？Java 循环循环使你能够控制程序的执行流程。迭代在编程中很常见，无论你使用 while 循环、do/while 循环还是无限循环，了解循环的工作原理都是至关重要的。via: https://opensource.com/article/23/1/java-loops作者：Seth Kenlon 选题：lkxed 译者：geekpi 校对：wxy本文由 LCTT 原创编译，Linux中国 荣誉推出
在 Linux 中有很多永远循环（或直到你决定停止）的方法，你可以在命令行或脚本中执行此操作。for 和 while 命令使这件事非常容易。关于相应的语法和策略，只有几件事要牢记。使用 while最简单的永远循环之一是使用 while 命令，后面跟上条件 true。 你不必使用诸如 while [ 1 -eq 1 ] 之类的逻辑或类似的测试。 while true 测试表示循环将一直运行，直到你使用 CTRL-C 停止循环、关闭终端窗口或注销为止。这是一个例子：$ while true > do > echo Keep running > sleep 3 > done Keep running Keep running Keep running ^C 你也可以使用 while : 做同样的事情。这里的关键是 : 总是返回成功，因此就像 while true 一样，此测试永远不会失败，并且循环会继续运行：$ while : > do > echo Keep running > sleep 3 > done Keep running Keep running ^C 如果你在脚本中插入了无限循环，并想提醒使用它的人如何退出脚本，那么可以使用 echo 命令添加提示：while : do echo Keep running echo "Press CTRL+C to exit" sleep 1 done 使用 forfor 命令还提供了一种永远循环的简便方法。虽然不如 while true 明显，但语法相当简单。你只需要在有界循环中替换参数即可，它通常类似于 “c 从等于 1 开始递增，直到 5”：$ for (( c=1; c<=5; c++ )) 不指定任何参数的情况下：$ for (( ; ; )) 没有起始值、增量或退出测试，此循环将永远运行或被强制停止：$ for (( ; ; )) > do > echo Keep running > echo “Press CTRL+C to exit” > sleep 2 > done Keep your spirits up Keep your spirits up Keep your spirits up 为什么要永远循环？在现实中，你不会想永远循环下去，但一直运行直到想要回家、工作完成或者遇到问题才退出并不罕见。任何构造为无限循环的循环都可以设置为根据各种情况退出。该脚本将一直处理数据直到下午 5 点，或者说检查发现第一次超过 5 点的时间：#!/bin/bash while true do if [ `date +%H` -ge 17 ]; then exit # exit script fi echo keep running ~/bin/process_data # do some work done 如果要退出循环而不是退出脚本，请使用 break 命令而不是 exit。#!/bin/bash while true do if [ `date +%H` -ge 17 ]; then break # exit loop fi echo keep running ~/bin/process_data done … run other commands here … 总结永远循环很容易。指定要停止循环的条件却需要花费一些额外的精力。via: https://www.networkworld.com/article/3562576/how-to-loop-forever-in-bash-on-linux.html作者：Sandra Henry-Stocker 选题：lujun9972 译者：geekpi 校对：wxy本文由 LCTT 原创编译，Linux中国 荣誉推出
使用循环和查找命令批量自动对多个文件进行一系列的操作。人们希望学习批处理命令的一个普遍原因是要得到批处理强大的功能。如果你希望批量的对文件执行一些指令，构造一个可以重复运行在那些文件上的命令就是一种方法。在编程术语中，这被称作执行控制，for 循环就是其中最常见的一种。for 循环可以详细描述你希望计算机对你指定的每个数据对象（比如说文件）所进行的操作。一般的循环使用循环的一个简单例子是对一组文件进行分析。这个循环可能没什么用，但是这是一个安全的证明自己有能力独立处理文件夹里每一个文件的方法。首先，创建一个文件夹然后拷贝一些文件（例如 JPEG、PNG 等类似的文件）至文件夹中生成一个测试环境。你可以通过文件管理器或者终端来完成创建文件夹和拷贝文件的操作：$ mkdir example $ cp ~/Pictures/vacation/*.{png,jpg} example切换到你刚创建的那个新文件夹，然后列出文件并确认这个测试环境是你需要的：$ cd example $ ls -1 cat.jpg design_maori.png otago.jpg waterfall.png在循环中逐一遍历文件的语法是：首先声明一个变量（例如使用 f 代表文件），然后定义一个你希望用变量循环的数据集。在这种情况下，使用 * 通配符来遍历当前文件夹下的所有文件（通配符 * 匹配所有文件）。然后使用一个分号（;）来结束这个语句。$ for f in * ;取决于你个人的喜好，你可以选择在这里按下回车键。在语法完成前，shell 是不会尝试执行这个循环的。接下来，定义你想在每次循环中进行的操作。简单起见，使用 file 命令来得到 f 变量（使用 $ 告诉 shell 使用这个变量的值，无论这个变量现在存储着什么）所存储着的文件的各种信息：do file $f ;使用另一个分号结束这一行，然后关闭这个循环：done按下回车键启动 shell 对当前文件夹下所有东西的遍历。for 循环将会一个一个的将文件分配给变量 f 并且执行你的命令：$ for f in * ; do > file $f ; > done cat.jpg: JPEG image data, EXIF standard 2.2 design_maori.png: PNG image data, 4608 x 2592, 8-bit/color RGB, non-interlaced otago.jpg: JPEG image data, EXIF standard 2.2 waterfall.png: PNG image data, 4608 x 2592, 8-bit/color RGB, non-interlaced你也可以用这种形式书写命令：$ for f in *; do file $f; done cat.jpg: JPEG image data, EXIF standard 2.2 design_maori.png: PNG image data, 4608 x 2592, 8-bit/color RGB, non-interlaced otago.jpg: JPEG image data, EXIF standard 2.2 waterfall.png: PNG image data, 4608 x 2592, 8-bit/color RGB, non-interlaced对你的 shell 来说，多行和单行的格式没有什么区别，并且会输出完全一样的结果。一个实用的例子下面是一个循环在日常使用中的实用案例。假如你拥有一堆假期拍的照片想要发给你的朋友。但你的照片太大了，无法通过电子邮件发送，上传到图片分享服务也不方便。因此你想为你的照片创建小型的 web 版本，但是你不希望花费太多时间在一个一个的压缩图片体积上。首先，在你的 Linux、BSD 或者 Mac 上使用包管理器安装 ImageMagick 命令。例如，在 Fedora 和 RHEL 上：$ sudo dnf install ImageMagick在 Ubuntu 和 Debian 上：$ sudo apt install ImageMagick在 BSD 上，使用 ports 或者 pkgsrc 安装。在 Mac 上，使用 Homebrew 或者 MacPorts 安装。在你安装了 ImageMagick 之后，你就拥有一系列可以用来操作图片的新命令了。为你将要创建的文件建立一个目标文件夹：$ mkdir tmp使用下面的循环可以将每张图片减小至原来大小的 33%。$ for f in * ; do convert $f -scale 33% tmp/$f ; done然后就可以在 tmp 文件夹中看到已经缩小了的照片了。你可以在循环体中使用任意数量的命令，因此如果你需要对一批文件进行复杂的操作，可以将你的命令放在一个 for 循环的 do 和 done 语句之间。例如，假设你希望将所有处理过的图片拷贝至你的网站所托管的图片文件夹并且在本地系统移除这些文件：$ for f in * ; do convert $f -scale 33% tmp/$f scp -i seth_web tmp/$f seth@example.com:~/public_html trash tmp/$f ; done你的计算机会对 for 循环中处理的每一个文件自动的执行 3 条命令。这意味着假如你仅仅处理 10 张图片，也会省下输入 30 条指令和更多的时间。限制你的循环一个循环常常不需要处理所有文件。在示例文件夹中，你可能需要处理的只是 JPEG 文件：$ for f in *.jpg ; do convert $f -scale 33% tmp/$f ; done $ ls -m tmp cat.jpg, otago.jpg或者，你希望重复特定次数的某个操作而不仅仅只处理文件。for 循环的变量的值是被你赋给它的（不管何种类型的）数据所决定的，所以你可以创建一个循环遍历数字而不只是文件：$ for n in {0..4}; do echo $n ; done 0 1 2 3 4更多循环现在你了解的知识已经足够用来创建自己的循环体了。直到你对循环非常熟悉之前，尽可能的在需要处理的文件的副本上进行操作。使用内置的保护措施可以预防损坏自己的数据和制造不可复现的错误，例如偶然将一个文件夹下的所有文件重命名为同一个名字，就可能会导致他们的相互覆盖。更进一步的 for 循环话题，请继续阅读。不是所有的 shell 都是 Bash关键字 for 是内置在 Bash shell 中的。许多类似的 shell 会使用和 Bash 同样的关键字和语法，但是也有某些 shell ，比如 tcsh，使用不同的关键字，例如 foreach。tcsh 的语法与 Bash 类似，但是它更为严格。例如在下面的例子中，不要在你的终端的第 2、3 行键入 foreach? 。它只是提示你仍处在构建循环的过程中。$ foreach f (*) foreach? file $f foreach? end cat.jpg: JPEG image data, EXIF standard 2.2 design_maori.png: PNG image data, 4608 x 2592, 8-bit/color RGB, non-interlaced otago.jpg: JPEG image data, EXIF standard 2.2 waterfall.png: PNG image data, 4608 x 2592, 8-bit/color RGB, non-interlaced在 tcsh 中，foreach 和 end 都必须单独的在一行中出现。因此你不能像 Bash 或者其他类似的 shell 一样只使用一行命令创建一个 for 循环。for 循环与 find 命令理论上，你可能会用到不支持 for 循环的 shell，或者你只是更想使用其他命令的一些特性来完成和循环一样的工作。使用 find 命令是另一个实现 for 循环功能的途径。这个命令提供了多种方法来定义循环中包含哪些文件的范围以及并行处理的选项。find 命令顾名思义就是帮助你查询存储在硬盘里的文件。它的用法很简单：提供一个你希望它查询的位置的路径，接着 find 就会查询这个路径下面的所有文件和文件夹。$ find . . ./cat.jpg ./design_maori.png ./otago.jpg ./waterfall.png你可以通过添加名称的某些部分来过滤搜索结果：$ find . -name "*jpg" ./cat.jpg ./otago.jpgfind 命令非常好的地方在于你可以通过 -exec 参数标志将它查询到的每一个文件放入循环中。例如，只对存放在你的 example 文件夹下的 PNG 图片进行体积压缩操作：$ find . -name "*png" -exec convert {} -scale 33% tmp/{} \; $ ls -m tmp design_maori.png, waterfall.png在 -exec 短语中，括号 {} 表示的是 find 正在处理的条目（换句话说，每一个被找到的以 PNG 结尾的文件）。-exec 短语必须使用分号结尾，但是 Bash 中常常也会使用分号。为了解决这个二义性问题，你的 结束符 可以使用反斜杠加上一个分号（\;），使得 find 命令可以知道这个结束符是用来标识自己结束使用的。find 命令的操作非常棒，某些情况下它甚至可以表现得更棒。比如说，在一个新的进程中使用同一条命令查找 PNG 文件，你可能就会得到一些错误信息：$ find . -name "*png" -exec convert {} -flip -flop tmp/{} \; convert: unable to open image `tmp/./tmp/design_maori.png': No such file or directory @ error/blob.c/OpenBlob/2643. ...看起来 find 不只是定位了当前文件夹（.）下的所有 PNG 文件，还包括已经处理并且存储到了 tmp 下的文件。在一些情况下，你可能希望 find 查询当前文件夹下再加上其子文件夹下的所有文件。find 命令是一个功能强大的递归工具，特别体现在处理一些文件结构复杂的情境下（比如用来放置存满了音乐人音乐专辑的文件夹），同时你也可以使用 -maxdepth 选项来限制最大的递归深度。只在当前文件夹下查找 PNG 文件（不包括子文件夹）：$ find . -maxdepth 1 -name "*png"上一条命令的最大深度再加 1 就可以查找和处理当前文件夹及下一级子文件夹下面的文件：$ find . -maxdepth 2 -name "*png"find 命令默认是查找每一级文件夹。循环的乐趣与收益你使用的循环越多，你就可以越多的省下时间和力气，并且可以应对庞大的任务。虽然你只是一个用户，但是通过使用循环，可以使你的计算机完成困难的任务。你可以并且应该就像使用其他的命令一样使用循环。在你需要重复处理单个或多个文件时，尽可能的使用这个命令。无论如何，这也算是一项需要被严肃对待的编程活动，因此如果你需要在一些文件上完成复杂的任务，你应该多花点时间在规划自己的工作流上面。如果你可以在一份文件上完成你的工作，接下来将操作包装进 for 循环里就相对简单了，这里面唯一的“编程”的需要只是理解变量是如何工作的并且进行充分的规划工作将已处理过的文件和未处理过的文件分开。经过一段时间的练习，你就可以从一名 Linux 用户升级成一位知道如何使用循环的 Linux 用户，所以开始让计算机为你工作吧！via: https://opensource.com/article/19/6/how-write-loop-bash作者：Seth Kenlon 选题：lujun9972 译者：chunibyo-wly 校对：wxy本文由 LCTT 原创编译，Linux 中国 荣誉推出
深入探讨 Python 的 for 循环来看看它们在底层如何工作，以及为什么它们会按照它们的方式工作。Python 的 for 循环不会像其他语言中的 for 循环那样工作。在这篇文章中，我们将深入探讨 Python 的 for 循环来看看它们在底层如何工作，以及为什么它们会按照它们的方式工作。循环的问题我们将通过看一些“陷阱”开始我们的旅程，在我们了解循环如何在 Python 中工作之后，我们将再次看看这些问题并解释发生了什么。问题 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(squares) 0 但是我们得到了 0。问题 2：包含的检查让我们使用相同的数字列表和相同的生成器对象：>>> numbers = [1, 2, 3, 5, 7] >>> squares = (n**2 for n in numbers) 如果我们询问 9 是否在 squares 生成器中，Python 将会告诉我们 9 在 squares 中。但是如果我们再次询问相同的问题，Python 会告诉我们 9 不在 squares 中。>>> 9 in squares True >>> 9 in squares False 我们询问相同的问题两次，Python 给了两个不同的答案。问题 3 ：拆包这个字典有两个键值对：>>> counts = {'apples': 2, 'oranges': 1} 让我们使用多个变量来对这个字典进行拆包：>>> x, y = counts 你可能会期望当我们对这个字典进行拆包时，我们会得到键值对或者得到一个错误。但是解包字典不会引发错误，也不会返回键值对。当你解包一个字典时，你会得到键：>>> x 'apples' 回顾：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 确实没有。Python 确实没有 传统 C 风格的 for 循环。在 Python 中确实有一些我们称之为 for 循环的东西，但是它的工作方式类似于 foreach 循环。这是 Python 的 for 循环的风格：numbers = [1, 2, 3, 5, 7] for n in numbers: print(n) 与传统 C 风格的 for 循环不同，Python 的 for 循环没有索引变量，没有索引变量初始化，边界检查，或者索引递增。Python 的 for 循环完成了对我们的 numbers 列表进行遍历的所有工作。因此，当我们在 Python 中确实有 for 循环时，我们没有传统 C 风格的 for 循环。我们称之为 for 循环的东西的工作机制与之相比有很大的不同。定义：可迭代和序列既然我们已经解决了 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 中很多东西都是可迭代的，但不是所有可迭代的东西都是序列。集合、字典、文件和生成器都是可迭代的，但是它们都不是序列。>>> 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 循环在底层使用了索引进行循环。在这里我们使用 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 "<stdin>", line 2, in <module> TypeError: 'set' object does not support indexing 集合不是序列，所以它们不支持索引。我们不能使用索引手动对 Python 中的每一个迭代对象进行遍历。对于那些不是序列的迭代器来说，这是行不通的。迭代器驱动 for 循环因此，我们已经看到，Python 的 for 循环在底层不使用索引。相反，Python 的 for 循环使用迭代器。迭代器就是可以驱动可迭代对象的东西。你可以从任何可迭代对象中获得迭代器，你也可以使用迭代器来手动对它的迭代进行遍历。让我们来看看它是如何工作的。这里有三个可迭代对象：一个集合，一个元组和一个字符串。>>> 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> 一旦我们有了迭代器，我们可以做的事情就是通过将它传递给内置的 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 "<stdin>", line 1, in <module> StopIteration 所以你可以从每个迭代中获得一个迭代器，迭代器唯一能做的事情就是用 next 函数请求它们的下一项。如果你将它们传递给 next，但它们没有下一项了，那么就会引发 StopIteration 异常。你可以将迭代器想象成 Pez 分配器（LCTT 译注：Pez 是一个结合玩具的独特复合式糖果），不能重新分配。你可以把 Pez 拿出去，但是一旦 Pez 被移走，它就不能被放回去，一旦分配器空了，它就没用了。没有 for 的循环既然我们已经了解了迭代器和 iter 以及 next 函数，我们将尝试在不使用 for 循环的情况下手动遍历迭代器。我们将通过尝试将这个 for 循环变为 while 循环：def funky_for_loop(iterable, action_to_do): for item in iterable: action_to_do(item) 为了做到这点，我们需要：从给定的可迭代对象中获得迭代器反复从迭代器中获得下一项如果我们成功获得下一项，就执行 for 循环的主体如果我们在获得下一项时得到了一个 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 中是如何工作的，所有形式的遍历一个可迭代对象都是这样工作的。 迭代器协议 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 中遍历一个可迭代对象时，你将依赖于迭代器协议。生成器是迭代器所以你可能会想：迭代器看起来很酷，但它们看起来像一个实现细节，我们作为 Python 的使用者，可能不需要关心它们。我有消息告诉你：在 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 中循环遍历某些东西，那么它就是可迭代的。所以生成器是迭代器，但是生成器也是可迭代的，这又是怎么回事呢？我欺骗了你所以在我之前解释迭代器如何工作时，我跳过了它们的某些重要的细节。生成器是可迭代的我再说一遍：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?迭代器VV生成器VV列表VX全部的迭代器协议让我们从 Python 的角度来定义迭代器是如何工作的。可迭代对象可以被传递给 iter 函数，以便为它们获得迭代器。迭代器：可以传递给 next 函数，它将给出下一项，如果没有下一项，那么它将会引发 StopIteration 异常可以传递给 iter 函数，它会返回一个自身的迭代器这些语句反过来也是正确的：任何可以在不引发 TypeError 异常的情况下传递给 iter 的东西都是可迭代的任何可以在不引发 TypeError 异常的情况下传递给 next 的东西都是一个迭代器当传递给 iter 时，任何返回自身的东西都是一个迭代器这就是 Python 中的迭代器协议。迭代器的惰性迭代器允许我们一起工作，创建惰性可迭代对象，即在我们要求它们提供下一项之前，它们不做任何事情。因为可以创建惰性迭代器，所以我们可以创建无限长的迭代器。我们可以创建对系统资源比较保守的迭代器，可以节省我们的内存，节省 CPU 时间。迭代器无处不在你已经在 Python 中看到过许多迭代器，我也提到过生成器是迭代器。Python 的许多内置类型也是迭代器。例如，Python 的 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') Python 中的文件对象也是迭代器。>>> next(open('hello.txt')) 'hello world\n' 在 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 这个生成器函数等价于我们上面所做的类，它的工作原理是一样的。这种 yield 语句似乎很神奇，但它非常强大：yield 允许我们在调用 next 函数之间暂停生成器函数。yield 语句是将生成器函数与常规函数分离的东西。另一种实现相同迭代器的方法是使用生成器表达式。def square_all(numbers): return (n**2 for n in 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) 请注意，我们代码的形状发生了巨大变化。将我们的计算工作时间变成一个惰性迭代器允许我们能够命名以前未命名（billable_times）的东西。这也允许我们使用 sum 函数，我们以前不能使用 sum 函数是因为我们甚至没有一个可迭代对象传递给它。迭代器允许你从根本上改变你组织代码的方式。惰性和打破循环这段代码打印出日志文件的前 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)。命名事物可以使我们的代码更具描述性，更具可读性。作为奖励，我们还消除了在循环中使用 break 语句的需要，因为 islice 实用函数为我们处理了中断。你可以在标准库中的 itertools 中找到更多的迭代辅助函数，以及诸如 boltons 和 more-itertools 之类的第三方库。创建自己的迭代辅助函数你可以在标准库和第三方库中找到用于循环的辅助函数，但你也可以自己创建！这段代码列出了序列中连续值之间的差值列表。current = readings[0] for next_item in readings[1:]: differences.append(next_item - current) current = next_item 请注意，这段代码中有一个额外的变量，我们每次循环时都要指定它。还要注意，这段代码只适用于我们可以切片的东西，比如序列。如果 readings 是一个生成器，一个 zip 对象或其他任何类型的迭代器，那么这段代码就会失败。让我们编写一个辅助函数来修复代码。这是一个生成器函数，它为给定的迭代中的每个项目提供了当前项和下一项：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：differences = [] for current, next_item in with_next(readings): differences.append(next_item - current) 请注意，这段代码不会挂在我们循环周围的 next_item 上，with_next 生成器函数处理跟踪 next_item 的工作。还要注意，这段代码已足够紧凑，如果我们愿意，我们甚至可以将方法复制到列表推导中来。differences = [ (next_item - current) for current, next_item in with_next(readings) ] 再次回顾循环问题现在我们准备回到之前看到的那些奇怪的例子并试着找出到底发生了什么。问题 1：耗尽的迭代器这里我们有一个生成器对象 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(squares) 0 这个生成器现在是空的：我们已经把它耗尽了。如果我们试着再次创建一个元组，我们会得到一个空元组：>>> tuple(squares) () 生成器是迭代器，迭代器是一次性的。它们就像 Hello Kitty Pez 分配器那样不能重新加载。问题 2：部分消耗一个迭代器再次使用那个生成器对象 squares：>>> numbers = [1, 2, 3, 5, 7] >>> squares = (n**2 for n in numbers) 如果我们询问 9 是否在 squares 生成器中，我们会得到 True：>>> 9 in squares True 但是我们再次询问相同的问题，我们会得到 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] 询问迭代器中是否包含某些东西将会部分地消耗迭代器。如果没有循环遍历迭代器，那么是没有办法知道某个东西是否在迭代器中。问题 3：拆包是迭代当你在字典上循环时，你会得到键：>>> counts = {'apples': 2, 'oranges': 1} >>> for key in counts: ... print(key) ... apples oranges 当你对一个字典进行拆包时，你也会得到键：>>> x, y = counts >>> x, y ('apples', 'oranges') 循环依赖于迭代器协议，可迭代对象拆包也依赖于有迭代器协议。拆包一个字典与在字典上循环遍历是一样的，两者都使用迭代器协议，所以在这两种情况下都得到相同的结果。回顾序列是迭代器，但是不是所有的迭代器都是序列。当有人说“迭代器”这个词时，你只能假设他们的意思是“你可以迭代的东西”。不要假设迭代器可以被循环遍历两次、询问它们的长度或者索引。迭代器是 Python 中最基本的可迭代形式。如果你想在代码中做一个惰性迭代，请考虑迭代器，并考虑使用生成器函数或生成器表达式。最后，请记住，Python 中的每一种迭代都依赖于迭代器协议，因此理解迭代器协议是理解 Python 中的循环的关键。这里有一些我推荐的相关文章和视频：Loop Like a Native， Ned Batchelder 在 PyCon 2013 的讲演Loop Better ，这篇文章是基于这个讲演的The Iterator Protocol: How For Loops Work，我写的关于迭代器协议的短文Comprehensible Comprehensions，关于推导和迭代器表达器的讲演Python: Range is Not an Iterator，我关于范围和迭代器的文章Looping Like a Pro in Python，DB 的 PyCon 2017 讲演本文是基于作者去年在 DjangoCon AU、 PyGotham 和 North Bay Python 中发表的 Loop Better 演讲。有关更多内容，请参加将于 2018 年 5 月 9 日至 17 日在 Columbus， Ohio 举办的 PYCON。via: https://opensource.com/article/18/3/loop-better-deeper-look-iteration-python作者：Trey Hunner 译者：MjSeven 校对：wxy本文由 LCTT 原创编译，Linux中国 荣誉推出