# Python 循环

> 原文： [https://javabeginnerstutorial.com/python-tutorial/python3-loops-2/](https://javabeginnerstutorial.com/python-tutorial/python3-loops-2/)

Python 循环允许循环遍历程序代码并重复代码块，直到满足或不满足给定条件。 重复的代码称为循环的主体。

Python 有两种循环类型：`for`循环和`while`循环。

循环中的变量会在每次执行循环主体时更改其值，这些变量必须用作循环头部或主体中的条件以中断流程。

如果循环中没有终止条件，则可能会遇到无限循环或永无止境的循环，永不终止，您必须手动终止应用。 这些循环大多数是通过`while`构造实现的。 让我向您展示示例：

```java
while True:
   print('I love Python!')

i = 0
while i < 1:
   print('I love Python!')
```

在第一个示例中，循环的开头有一个条件，条件始终为`True`，因此程序将永远将“我爱 Python”打印到控制台。 此循环永远不会终止。

第二个循环比较棘手，因为我在循环的开头使用了一个变量。 如果`i`的值一次大于 1，则该循环最终将终止。 但是，由于循环的主体只会在控制台上打印，因此永远不会发生。

让我们详细研究一下循环类型，以了解循环的工作方式以及如何避免无限循环。

**还有一个关于循环的**好事：如果不再满足循环头中的条件，它们可以处理`else`块，该块将被执行。 这是一个新的编程结构，对于经典的编程语言的程序员来说似乎很奇怪，因为经典的编程语言的循环没有其他部分。

## 修改循环主体中的控制流

在深入探讨循环之前，我们需要了解两种可修改循环控制流程的构造。 这些是突破并继续。 让我们看一下它们的总体工作原理，然后在有关循环本身的部分中使用示例。

### `break`

顾名思义，`break`语句会跳出循环。 大多数情况下，如果不应再继续循环，则在条件块内停止循环。

此语句立即结束循环，因此不再执行任何语句-在`break`语句和循环的`else`部分之后不在循环体内，也未执行。

```java
while / for some_condition:
   execute_this
   do_this
   break
   this_does_not_executed
   this_neither
else:
   this_is_leaved_behind
   this_too
```

在上面的示例中，我没有包括任何有条件的突破循环来演示语句的工作的条件。

### `continue`

与`break`语句平行，您可以告诉循环再次从头继续执行。 这意味着`continue`语句后面的任何其他语句都不会执行，但是，循环将继续，直到循环头部的条件计算为`False`为止。 在这种情况下，循环的`else`块在循环结束时执行。

```java
while / for some_condition:
   execute_this
   do_this
   continue
   this_does_not_executed
   this_neither
else:
   this_is_executed_at_the_end
   this_too
```

现在，我们准备通过示例看一下循环本身。 你准备好了吗？ 为什么不？

## `for`循环

`for`循环旨在遍历集合或在有限的时间内执行循环主体。 循环的一般语法如下所示：

```java
for variable in sequence:
   statement_1
   statement_2
   ...
   statement_n
else:
   else_statement_1
   else_statement_2
   ...
   else_statement_m
```

当然，`else`块是可选的，因为在`for`循环的主体中仅需要一个语句。

让我们举一个真实的例子：

```java
>>> for m in menu:
...     print(m)
... else:
...   print("What do you want?")
...
eggs
sausage
bacon
spam
What do you want?
```

在上面的示例中，for 循环遍历列表中的元素，并将每个元素输出到控制台。 循环完成后，else 块将执行一次。

### 范围

在上面的示例中，一次又一次地定义数字列表似乎很麻烦。 这是 Python，因此必须有一些可利用开发人员的构造方法。 这是范围功能。

该函数需要一个参数：停止值； 和两个可选参数：`start`和`step`。

如果提供了唯一停靠点，则范围功能会生成一个从数字 0 到停靠点数字（不包括停靠点数字）的范围，步长为 1。

```java
>>> for i in range(10):
...     print(i)
...
0
1
2
3
4
5
6
7
8
9
```

如您在上面的示例中看到的那样，数字以 0 到 9 的步长打印从 0 到 9。

如果提供了起始参数，则范围功能会在起始编号和终止编号之间创建一个范围（同样，终止编号是唯一的）。

如果起始编号大于或等于终止编号，则不执行循环。

```java
>>> for i in range(15,20):
...   print(i)
...
15
16
17
18
19
>>> for i in range(25,10):
...   print(i)
...
```

该步骤定义了要忽略的元素数，或者即使起始编号大于终止编号也要跳过起始和终止之间的编号。 在这种情况下，您必须提供步骤 -1。

```java
>>> for i in range(1,10,2):
...   print(i)
...
1
3
5
7
9
>>> for i in range(10,1,-1):
...   print(i)
...
10
9
8
7
6
5
4
3
2
```

如您所见，范围函数用于执行循环有限的次数。

### 循环中断和继续

现在我们了解了`for`循环的基础，让我们添加已知的控制流修改：中断并继续。

正如我之前告诉您的，如果您使用`break`，则整个循环将终止。 您还记得从本节开始的`for`循环示例吗？ 现在，我们向其添加一个条件，以便在我们迭代通过的元素为“垃圾邮件”时打破该条件：

```java
>>> menu = ['eggs', 'sausage', 'bacon', 'spam']
>>> for m in menu:
...     if m == 'spam':
...         break
...     print(m)
... else:
...   print("What do you want?")
...
eggs
sausage
bacon

>>> menu = ['eggs', 'sausage', 'bacon', 'spam']
>>> for m in menu:
...     print(m)
...     break
... else:
...   print("What do you want?")
...
eggs
```

如果是`for`循环，`Continue`跳回到循环的开头，它跳到集合的下一个元素。 如果集合为空，则循环结束，然后执行`else`循环。 我们再来看两个例子：一个带有条件继续，另一个带有自己的继续。

```java
>>> menu = ['eggs', 'sausage', 'bacon', 'spam']
>>> for m in menu:
...    if m == 'spam':
...         continue
...     print(m)
... else:
...   print("What do you want?")
...
eggs
sausage
bacon
What do you want?

>>> menu = ['eggs', 'sausage', 'bacon', 'spam']
>>> for m in menu:
...     continue
...     print(m)
... else:
...   print("What do you want?")
...
What do you want?
```

如您所见，`continue`和`break`之间的主要区别在于循环的流程：第一个循环返回并遍历其余元素，第二个循环终止整个循环。 当然，您可以将两者结合在一起以拥有自己的正确控制流程。

### 有副作用的循环

当然，将`for`循环与列表一起使用时，您会产生副作用。 这是因为您要遍历的集合不是一成不变的，因此您可以在循环期间更改其值，这可能导致意外行为。 让我们来看一个例子：

```java
>>> l = ['eggs']
>>> for e in l:
...     if e == 'eggs':
...         l += ['sausage']
...     if e == 'sausage':
...         l += 'spam'
...     print(e)
...
eggs
sausage
s
p
a
m
>>> l
['eggs', 'sausage', 's', 'p', 'a', 'm']
```

如您所见，我们在`for`循环执行期间修改了列表，因此当循环结束并返回到头进行求值时，它在列表中找到了新元素，因此循环继续执行。

为了避免这种情况，我们可以使用列表的副本在循环中进行迭代：

```java
>>> l = ['eggs']
>>> for e in l[:]:
...     if e == 'eggs':
...         l += ['sausage']
...     if e == 'sausage':
...         l += 'spam'
...     print(e)
...
eggs
```

## `while`循环

`while`循环旨在无限期地执行循环的主体，直到达到条件为止。 使用`for`循环，您只能执行有限数量的音调（取决于列表或您提供给它的范围）。

并且由于`while`循环需要条件语句，因此您可以轻松地创建无限循环（如循环简介中所述）。

让我们看看`while`循环是如何建立的：

```java
while condition_evaluates_to_True:
   statement_1
   statement_2
   ...
   statement_n
else:
   else_statement_1
   else_statement_2
   ...
   else_statement_m
```

如您所见，该结构与`for`循环几乎相同，但是在这里，您需要一个布尔条件，即计算结果为`True`。 `else`块是相同的，并在循环正常终止时执行。 如果在循环主体中遇到中断，则不会执行`else`块。

```java
>>> i = 0
>>> while i < 10:
...     i += 1
... else:
...     print("Finished loop, i has the value of ", i)
...
Finished loop, i has the value of 10
```

`while`循环的主要用法是在具有用户交互作用的游戏或应用中，例如，您需要获取特定类型的输入（例如数字）或要执行逻辑直到游戏结束。 让我们看一个简单的示例，在该示例中，我们要求用户输入数字。

```java
while True:
   try:
       a = int(input('Enter a number: '))
   except ValueError:
       print("This was not a number!")
       continue
   break

print("You entered: ", a)
```

如本例所示，如果用户未输入数字，则应用将打印出“这不是数字！” 由于执行了`continue`语句，它再次执行了循环。 如果输入可以转换为数字，则`break`语句将终止无尽的`while`循环。

如果您运行该应用，则可能会得到以下信息：

```java
Enter a number: enter
This was not a number!
Enter a number: a
This was not a number!
Enter a number: number
This was not a number!
Enter a number: 23j
This was not a number!
Enter a number: 42
You entered: 42
```

### while 循环中断并继续

```java
>>> i = 0
>>> while i < 10:
...     continue
...     i += 1
... else:
...     print("Finished loop, i has the value of ", i)
...
```

这段代码不会停止，因为我永远不会递增，因此在继续调用表达式`i < 10`之后，它会被一次又一次地赋值为`False`，因此循环将无限执行。 如果启动了上面的示例，则可以通过按键盘上的`CTRL-C`来停止它。

```java
>>> i = 0
>>> while i < 10:
...     break
...     i += 1
... else:
...     print("Finished loop, i has the value of ",i)
...
>>> i
0
```

如您所见，使用`break`时，`else`块不会执行。 在上面的示例中，`i`的值完全没有变化。

自然，这些只是带有`break`和`Continue`的基本示例，大多数时候，您在条件表达式中使用它们。

