【Python】while、for循环嵌套，break、continue用法详解

逃离我推掉我的手 2022-08-30 06:24 300阅读 0赞

### 循环语句详解 ###

*  while 循环语句
 *  for 循环语句
 *   *  for 循环的具体应用
 *  循环结构中 else 用法
 *  循环嵌套
 *  break 用法
 *  continue的用法

# while 循环语句 #

Python 中，while 循环和 if 条件分支语句类似，即在条件（表达式）为真的情况下，会执行相应的代码块。

不同之处在于，只要条件为真，while 就会一直重复执行那段代码块。

while 语句的语法格式如下：

while 条件表达式：
        代码块

这里的代码块，指的是缩进格式相同的多行代码，不过在循环结构中，它又称为`循环体`。

while 语句执行的具体流程为：

*  首先判断条件表达式的值，其值为真（True）时，则执行代码块中的语句，当执行完毕后，再回过头来重新判断条件表达式的值是否为真，
 *  若仍为真，则继续重新执行代码块…如此循环，直到条件表达式的值为假（False），才终止循环。

![在这里插入图片描述][20210719171257842.png]

例如，打印 1~100 的所有数字，就可以使用 while 循环，实现代码如下：

# 循环的初始化条件
    num = 1
    # 当 num 小于100时，会一直执行循环体
    while num < 100 :
        print("num=", num)
        # 迭代语句
        num += 1
    print("循环结束!")

运行程序会发现，程序只输出了 1~99，却没有输出 100。

这是因为，当循环至 num 的值为 100 时，此时条件表达式为假（100<100），当然就不会再去执行代码块中的语句，因此不会输出 100。

注意，在使用 while 循环时，一定要保证循环条件有变成假的时候（终止条件），否则这个循环将成为一个死循环。

所谓死循环，指的是无法结束循环的循环结构，例如将上面 while 循环中的`num += 1`代码注释掉，再运行程序你会发现，Python 解释器一直在输出"`num= 1`"，永远不会结束（因为 num<100 一直为 True），除非我们强制关闭解释器。

再次强调，只要`位于 while 循环体`中的代码，其必须使用相同的缩进格式（通常缩进 4 个空格），否则 Python 解释器会报 SyntaxError 错误（语法错误）。

例如，将上面程序中`num+=1`语句前移一个空格，再次执行该程序，此时 Python 解释器就会报 SyntaxError 错误。

![在这里插入图片描述][62ccb98e0df86ed57656b629a4338c90.gif_pic_center]

除此之外，while 循环还常用来遍历列表、元组和字符串，因为它们都支持通过下标索引获取指定位置的元素。例如，下面程序演示了如何使用 while 循环遍历一个字符串变量：

my_char = "www.qinjl.com"
    i = 0
    while i < len(my_char):
        print(my_char[i], end="")
        i = i + 1
    
    程序执行结果为：www.qinjl.com

# for 循环语句 #

for 循环，它常用于遍历字符串、列表、元组、字典、集合等序列类型，逐个获取序列中的各个元素。

for 循环的语法格式如下：

for 迭代变量 in 字符串|列表|元组|字典|集合：
        代码块

格式中，迭代变量用于存放从序列类型变量中读取出来的元素，所以一般不会在循环中对迭代变量手动赋值；

代码块指的是具有相同缩进格式的多行代码（和 while 一样），由于和循环结构联用，因此代码块又称为`循环体`。

![在这里插入图片描述][20210719173108417.png]  
下面的程序演示了 for 循环的具体用法：

add = "www.qinjl.com"
    # for循环，遍历 add 字符串
    for ch in add:
        print(ch, end="")
    
    运行结果为：www.qinjl.com

可以看到，使用 for 循环遍历 add 字符串的过程中，迭代变量 ch 会先后被赋值为 add 字符串中的每个字符，并代入循环体中使用。只不过例子中的循环体比较简单，只有一行输出语句。

## for 循环的具体应用 ##

for 循环进行数值循环

在使用 for 循环时，最基本的应用就是进行数值循环。比如说，想要实现从 1 到 100 的累加，可以执行如下代码：

print("计算 1+2+...+100 的结果为：")
    #保存累加结果的变量
    result = 0
    #逐个获取从 1 到 100 这些值，并做累加操作
    for i in range(101):
        result += i
    print(result)
    
    输出结果：5050

for 循环遍历列表和元组

当用 for 循环遍历 `list 列表`或者 `tuple 元组`时，其迭代变量会先后被赋值为列表或元组中的每个元素并执行一次循环体。

下面程序使用 for 循环对列表进行了遍历：

my_list = [1,2,3,4,5]
    for ele in my_list:
        print('ele =', ele)
    
    程序执行结果为：
    ele = 1
    ele = 2
    ele = 3
    ele = 4
    ele = 5

for 循环遍历字典

在使用 for 循环遍历字典时，经常会用到和字典相关的 3 个方法，即 `items()、keys()、values()`。当然，如果使用 for 循环直接遍历字典，则迭代变量会被先后赋值为每个键值对中的键。

my_dic = {
        '小蓝': "20",
              '小红': "22",
              '小绿': "24"}
    for ele in my_dic:
        print('ele =', ele)
    
    输出结果：
    ele = 小蓝
    ele = 小红
    ele = 小绿

> 因此，直接遍历字典，和遍历字典 keys() 方法的返回值是相同的。

除此之外，我们还可以遍历字典 `values()、items()` 方法的返回值。例如：

my_dic = {
        '小蓝': "20",
              '小红': "22",
              '小绿': "24"}
    for ele in my_dic.items():
        print('ele =', ele)
    
    输出结果：
    ele = ('小蓝', '20')
    ele = ('小红', '22')
    ele = ('小绿', '24')

# 循环结构中 else 用法 #

Python 中，无论是 `while 循环`还是 `for 循环`，其后都可以紧跟着一个 `else` 代码块，它的作用是当循环条件为 False 跳出循环时，程序会最先执行 else 代码块中的代码。

以 while 循环为例，下面程序演示了如何为 while 循环添加一个 else 代码块：

add = "www.qinjl.com"
    i = 0
    while i < len(add):
        print(add[i],end="")
        i = i + 1
    else:
        print("\n执行 else 代码块")
    
    输出结果：
    www.qinjl.com
    执行 else 代码块

上面程序中，当`i == len(add)`结束循环时（确切的说，是在结束循环之前），Python 解释器会执行 while 循环后的 else 代码块。

当然，我们也可以为 for 循环添加一个 else 代码块，例如：

add = "www.qinjl.com"
    for i in  add:
        print(i,end="")
    else:
        print("\n执行 else 代码块")
    
    输出结果：
    www.qinjl.com
    执行 else 代码块

# 循环嵌套 #

Python 不仅支持 if 语句相互嵌套，while 和 for 循环结构也支持嵌套。

所谓嵌套（Nest），就是一条语句里面还有另一条语句，例如 for 里面还有 for，while 里面还有 while，甚至 while 中有 for 或者 for 中有 while 也都是允许的。

当 2 个（甚至多个）循环结构相互嵌套时，位于外层的循环结构常简称为`外层循环`或`外循环`，位于内层的循环结构常简称为`内层循环`或`内循环`。

循环嵌套结构的代码，Python 解释器执行的流程为：

1.  当外层循环条件为 `True` 时，则执行外层循环结构中的循环体；
2.  外层循环体中包含了普通程序和内循环，当内层循环的循环条件为 `True` 时会执行此循环中的循环体，直到内层循环条件为 `False`，跳出内循环；
3.  如果此时外层循环的条件仍为 `True`，则返回第 2 步，继续执行外层循环体，直到外层循环的循环条件为 `False`；
4.  当内层循环的循环条件为 `False`，且外层循环的循环条件也为 `False`，则整个嵌套循环才算执行完毕。

![在这里插入图片描述][470858e7f7210c38f99f7f873b51acfc.png]

下面程序演示了 while-for 嵌套结构：

i = 0
    while i<10:
        for j in range(10):
            print("i=",i," j=",j)       
        i=i+1

可以看到，此程序中运用了嵌套循环结构，其中外循环使用的是 while 语句，而内循环使用的是 for 语句。程序执行的流程是：

*  一开始 `i=0`，循环条件 `i<10` 成立，进入 while 外循环执行其外层循环体；
 *  从 `j=0` 开始，由于 `j <10` 成立，因此进入 for 内循环执行内层循环体，直到 `j=10` 不满足循环条件，跳出 for 循环体，继续执行 while 外循环的循环体；
 *  执行 `i=i+1` 语句，如果 `i<10` 依旧成立，则从第 2 步继续执行。直到 i<10 不成立，则此循环嵌套结构才执行完毕。

根据上面的分析，此程序中外层循环将循环 10 次（从 i=0 到 i=9），而每次执行外层循环时，内层循环都从 j = 0 循环执行到 j = 9。因此，该嵌套循环结构将执行 `10*10 = 100` 次。

> 嵌套循环执行的总次数 = 外循环执行次数 \* 内循环执行次数

事实上，if 语句和循环（while、for）结构之间，也可以相互嵌套，举个例子：

i = 0
    if i<10:
        for j in range(5):
            print("i=",i," j=",j)  
    
    输出结果：
    i= 0  j= 0
    i= 0  j= 1
    i= 0  j= 2
    i= 0  j= 3
    i= 0  j= 4

需要指明的是，上面程序演示的仅是 2 层嵌套结构，其实 `if、while、for`之间完全支持多层（ ≥3 ）嵌套。例如：

if ...:
        while ...:
            for ...:
                if ...:
                    ...

也就是说，只要场景需要，判断结构和循环结构之间完全可以相互嵌套，甚至可以多层嵌套。

# break 用法 #

我们知道，在执行 while 循环或者 for 循环时，只要循环条件满足，程序将会一直执行循环体，不停地转圈。

但在某些场景，我们可能希望在循环结束前就强制结束循环，Python 提供了 2 种强制离开当前循环体的办法：

1.  使用 `continue` 语句，可以跳过执行本次循环体中剩余的代码，转而执行下一次的循环。
2.  只用 `break` 语句，可以完全终止当前循环。

break 语句可以立即终止当前循环的执行，跳出当前所在的循环结构。无论是 while 循环还是 for 循环，只要执行 break 语句，就会直接结束当前正在执行的循环体。

> 这就好比在操场上跑步，原计划跑 10 圈，可是当跑到第 2 圈的时候，突然想起有急事要办，于是果断停止跑步并离开操场，这就相当于使用了 break 语句提前终止了循环。

break 语句的语法非常简单，只需要在相应 while 或 for 语句中直接加入即可。例如如下程序：

add = "www.qinjl.com,www.qinjl.com"
    # 一个简单的for循环
    for i in add:
        if i == ',':
            # 终止循环
            break
        print(i, end="")
    print("\n执行循环体外的代码")
    
    输出结果：
    www.qinjl.com
    执行循环体外的代码

分析上面程序不难看出，当循环至 add 字符串中的逗号`,`时，程序执行 break 语句，其会直接终止当前的循环，跳出循环体。

> break 语句一般会结合 if 语句进行搭配使用，表示在某种条件下跳出循环体。

注意，通过前面的学习我们知道，for 循环后也可以配备一个 else 语句。这种情况下，如果使用 break 语句跳出循环体，不会执行 else 中包含的代码。举个例子：

add = "www.qinjl.com,www.qinjl.com"
    for i in add:
        if i == ',':
            # 终止循环
            break
        print(i, end="")
    else:
        print("执行 else 语句中的代码")
        
    print("\n执行循环体外的代码")
    
    输出结果：
    www.qinjl.com
    执行循环体外的代码

从输出结果可以看出，使用 break 跳出当前循环体之后，该循环后的 else 代码块也不会被执行。

但是，如果将 else 代码块中的代码直接放在循环体的后面，则该部分代码将会被执行。

另外，对于嵌套的循环结构来说，break 语句只会终止所在循环体的执行，而不会作用于所有的循环体。举个例子：

add = "www.qinjl.com,www.qinjl.com"
    for i in range(3):
        for j in add:
            if j == ',':
                break
            print(j, end="")
        print("\n跳出内循环")
    
    #输出结果：
    www.qinjl.com
    跳出内循环
    www.qinjl.com
    跳出内循环
    www.qinjl.com
    跳出内循环

分析上面程序，每当执行内层循环时，只要循环至 add 字符串中的逗号`,`就会执行 break 语句，它会立即停止执行当前所在的内存循环体，转而继续执行外层循环。

那么在嵌套循环结构中，如何同时跳出内层循环和外层循环呢？ 最简单的方法就是借用一个 `bool 类型`的变量。

add = "www.qinjl.com,www.qinjl.com"
    # 提前定义一个 bool 变量，并为其赋初值
    flag = False
    for i in range(3):
        for j in add:
            if j == ',':
                # 在 break 前，修改 flag 的值
                flag = True
                break
            print(j, end="")
        print("\n跳出内循环")
        # 在外层循环体中再次使用 break
        if flag:
            print("跳出外层循环")
            break
    
    # 输出结果：
    www.qinjl.com
    跳出内循环
    跳出外层循环

可以看到，通过借助一个 `bool 类型的变量 flag`，在跳出内循环时更改 flag 的值，同时在外层循环体中，判断 flag 的值是否发生改动，如有改动，则再次执行 break 跳出外层循环；反之，则继续执行外层循环。

# continue的用法 #

和 break 语句相比，`continue` 语句的作用则没有那么强大，它只会终止执行本次循环中剩下的代码，直接从下一次循环继续执行。

> 仍然以在操作跑步为例，原计划跑 10 圈，但当跑到 2 圈半的时候突然接到一个电话，此时停止了跑步，当挂断电话后，并没有继续跑剩下的半圈，而是直接从第 3 圈开始跑。

continue 语句的用法和 break 语句一样，只要 while 或 for 语句中的相应位置加入即可。例如：

add = "www.qinjl.com,www.qinjl.com"
    # 一个简单的for循环
    for i in add:
        if i == ',':
            # 忽略本次循环的剩下语句
            print('\n')
            continue
        print(i, end="")
    
    # 输出结果：
    www.qinjl.com
    www.qinjl.com

可以看到，当遍历 add 字符串至逗号`,`时，会进入 `if 判断语句`执行 print() 语句和 continue 语句。其中，print() 语句起到换行的作用，而 `continue 语句`会使 Python 解释器忽略执行第 8 行代码，直接从下一次循环开始执行。

[20210719171257842.png]: /images/20220829/7c95135597774a10862f40dd758eae2c.png
[62ccb98e0df86ed57656b629a4338c90.gif_pic_center]: /images/20220829/a6d34966c7b64371836c62596dfc22b8.png
[20210719173108417.png]: /images/20220829/afab9d4d1bb54717af058dd3a51880db.png
[470858e7f7210c38f99f7f873b51acfc.png]: /images/20220829/d56033dd54da4f7985c6a122f000f37a.png