『无为则无心』Python基础 — 14、Python流程控制语句（while循环语句）

1、什么是循环结构
2、while循环
- （1）while循环的语法
- （2）while循环的应用
3、while语句的死循环
4、break和continue
5、while循环嵌套
6、while循环嵌套应用

为了方便我们控制程序的运行流程，编程语言一般都会有基本的流程控制结构，包括：顺序结构、选择结构、循环结构。

本篇文章主要说明Pyhton循环结构的while循环语句。

1、什么是循环结构

（1）概念

循环结构是指在实际问题中有许多具有规律性的重复操作，因此在程序中就需要重复执行某些语句。为解决此类常见的问题而设置的一种程序结构。它由循环体中的条件，判断继续执行某个功能还是退出循环。

（2）循环语句的作用

思考：假如我有个女朋友，有一天我们闹矛盾生气了，女朋友说：道歉，说100遍“媳妇儿，我错了”。这个时候程序员会怎么做？

答：100遍print('媳妇儿，我错了')

思考：复制粘贴100次吗？

答：重复执行100次一样的代码，程序中循环即可。

循环的作用：让代码更高效的重复执行。

（3）循环语句的分类

在Python中，循环分为while和for两种，最终实现效果相同。

2、`while`循环

（1）`while`循环的语法

while 条件表达式:

    # 循环体（代码块）

    条件成立重复执行的代码1

    条件成立重复执行的代码2

    ......

执行流程：

while语句在执行时，会先对while后的条件表达式进行求值判断，

如果判断结果为True，则执行循环体（代码块），

循环体执行完毕，继续对条件表达式进行求值判断，以此类推，

直到判断结果为False，则循环终止。

快速体验：

需求：复现重复执行100次print('媳妇儿，我错了')（输出更简洁一些，我们这里设置5次）。

分析：初始值是0次，终点是5次，重复做的事情输出“媳妇儿，我错了”。

# 循环的计数器（表示循环的次数）

i = 0 # 计数器默认习惯从0开始

while i < 5:

    print('媳妇儿，我错了')

    # 计数器+1

    i += 1

print('任务结束')

（2）`while`循环的应用

1）应用一：计算1-100累加和

分析：1-100的累加和，即1 + 2 + 3 + 4 +….，即前两个数字的相加结果 + 下一个数字( 前一个数字 + 1)。

"""

1. 准备做计数器

2. 准备变量，保存将来运算的结果

3. 循环做加法运算

4. 打印结果

"""

i = 1 # 计数器

result = 0 # 累加结果

# 累加运算

while i <= 100:

    # 加法运算 前两个数的结果 + 第三个数

    # 每计算一次执行加法，则更新一次result变量的值

    result += i

    # 计数器+1

    i += 1 

# 打印最终结果：输出5050

print(result)

注意：为了验证程序的准确性，可以先改小数值，验证结果正确后，再改成1-100做累加。

2）应用二：计算1-100偶数累加和

分析：1-100的偶数和，即 2 + 4 + 6 + 8....，得到偶数的方法如下：

偶数即是和2取余结果为0的数字，可以加入条件语句判断是否为偶数，为偶数则累加
初始值为0 / 2 , 计数器每次累加2

方法一：条件判断和2取余数则累加

# 方法一：条件判断和2取余数为0则累加计算

"""

 1. 准备计数器变量

 2. 准备保存结果的变量result

 3. 循环加法运算

 	  如果是偶数才加法运算，和2取余数为0

 4. 输出结果

"""

i = 1

result = 0

while i <= 100:

    if i % 2 == 0:

        result += i

    i += 1

# 输出2550

print(result)

方法二：计数器控制偶数累加

# 方法二：计数器控制增量为2

i = 0

result = 0

while i <= 100:

    result += i

    i += 2

# 输出2550

print(result)

"""

 两种实现方式都可以正确实现，

 但是更推荐使用第一种方式，

 因为第一种是程序去判断一个数是否是偶数，

 而第二种方式，是根据我们的经验，

 使用的简便方法。

 所以推荐使用计算机计算的方式。

 但是在实际开发中，在正确实现功能的前提下，

 我们可能更注重代码的简洁性和可读性，

 还有就是代码的空间复杂度和时间复杂度。

"""

3）应用三：获得1000内的水仙花数

分析：水仙花数是指一个 3 位数，它的每个位上的数字的 3次幂之和等于它本身（例如：1^3 + 5^3+ 3^3 = 153）。

# 获取1000以内的三位数

# 因为水仙花数是一个三位数，所以从100开始

i = 100

while i < 1000:

    # 获取三位数的百位数，十位数，个位数

    # 假设，i的百位数是a，十位数b，个位数c

    # 求i的百位数，对100整除

    a = i // 100

    # 求i的十位数，有很多算法，可以自己拓展。

    # 方式一

    # 先整除10.获得的结果在模以10，就得到10位上的数字了。

    # b = i // 10 % 10

    # 方式二

    # (i - a * 100)得到十位和个位数，在模以10

    b = (i - a * 100) // 10

    # 求i的个位数字

    c = i % 10

    # print(i , a , b , c)

    # 判断i是否是水仙花数

    if a**3 + b**3 + c**3 == i :

        print(f'水仙花数{i}')

    i += 1

3、`while`语句的死循环

（1）概念

在编程中，一个靠自身控制无法终止的程序称为“死循环”。在while循环语句中，条件表达式恒为True的循环语句，称为就是while死循环语句，它会一直运行，慎用！

# 死循环示例：

while True :

    print('hello')

（2）总结

循环结构的三个要素（表达式）

# 1、初始化表达式，

#   通过初始化表达式初始化一个变量，

#   也就是计数器。

i = 0

# 2、条件表达式，

#   条件表达式用来设置循环执行的条件

while i < 10 :

    print(i)

    # 3、更新表达式，让计数器自增或自减，

    # 条件变量一定要更新，保证循环能够正常结束。

    i += 1

4、`break`和`continue`

break和continue是循环中满足一定条件退出循环的两种不同方式。

举例：一共吃5个苹果，吃完第一个，吃第二个…，这里"吃苹果"的动作是不是重复执行？

情况一：如果吃的过程中，吃完第三个吃饱了，则不需要再吃第4个和第五个苹果，即是吃苹果的动作停止，这里就是break控制循环流程，即用来立即退出循环语句（包括else中的语句也不执行）。

情况二：如果吃的过程中，吃到第三个吃出一个大虫子...，是不是这个苹果就不吃了，开始吃第四个苹果，这里就是continue控制循环流程，即退出当前的循环，继而执行下一次循环代码。

（1）情况一：break

"""

 执行结果：

 吃了第1个苹果

 吃了第2个苹果

 吃了第3个苹果

 吃饱了不吃了

"""

i = 1 # 应该0开始，写1是为了方便输出

while i <= 5:

    if i == 4: # 吃饱的条件

        print(f'吃饱了不吃了')

        # 满足条件，退出整个while循环

        break

    print(f'吃了第{i}个苹果')

    i += 1

（2）情况二：continue

"""

 执行结果：

 吃了第1个苹果

 吃了第2个苹果

 大虫子，第3个不吃了

 吃了第4个苹果

 吃了第5个苹果

"""

i = 1

while i <= 5:

    if i == 3:

        print(f'大虫子，第{i}个不吃了')

        # 在执行continue之前一定要修改计数器，

        # 否则会陷入死循环

        i += 1

        continue

    print(f'吃了第{i}个苹果')

    i += 1

注意：如果在嵌套循环中，也就是循环中还嵌套着循环的时候，break和continue都是只对离他最近的循环起作用。

5、`while`循环嵌套

（1）应用场景

故事梗概：有天女朋友又生气了，惩罚：说3遍“媳妇儿，我错了”，这个程序是不是循环即可？但如果女朋友说：还要刷今天晚饭的碗，这个程序怎么书写？

while 条件表达式:

    print('媳妇儿， 我错了')

print('刷晚饭的碗')

但如果女朋友还是生气，把这套惩罚要连续3天都执行，有如何书写程序？

while 条件表达式:

    while 条件表达式:

        print('媳妇儿， 我错了')

    print('刷晚饭的碗')

（2）语法

while 条件表达式1:

    条件1成立执行的代码

    ......

    while 条件表达式2:

        条件2成立执行的代码

        ......

总结：所谓while循环嵌套，就是一个while里面嵌套一个while的写法，每个while和之前的基础语法是相同的。

（3）快速体验：复现场景

"""

步骤1. 循环打印3次媳妇儿，我错了。

步骤2. 今天晚饭后刷碗

步骤3. 上面是一套惩罚，这一套惩罚要重复执行3天

        一套惩罚要重复执行，

        放到一个while循环里面。

"""

j = 0 # 天数计数器

while j < 3:

    i = 0 # 道歉计数器

    while i < 3:

        print('媳妇儿，我错了')

        i += 1

    print('刷晚饭的碗')

    print(f'一套惩罚结束---第{j + 1}天---------')

    j += 1

 """

 执行结果：

 媳妇儿，我错了

 媳妇儿，我错了

 媳妇儿，我错了

 刷晚饭的碗

 一套惩罚结束---第1天---------

 媳妇儿，我错了

 媳妇儿，我错了

 媳妇儿，我错了

 刷晚饭的碗

 一套惩罚结束---第2天---------

 媳妇儿，我错了

 媳妇儿，我错了

 媳妇儿，我错了

 刷晚饭的碗

 一套惩罚结束---第3天---------

 """

（4）`while`循环嵌套执行流程

当内部循环执行完成之后，再执行下一次外部循环的条件判断。

6、`while`循环嵌套应用

（1）应用一：打印星号(正方形)

需求：

*****

*****

*****

*****

*****

分析：一行输出5个星号，重复打印5行。

代码如下：

"""

步骤1. 打印1个星星

步骤2. 打印一行5个星星： 循环5次步骤1

步骤3. 打印5行星星： 循环5次步骤2

"""

# 重复打印5行星星

j = 0

while j <= 4:

    # 一行星星的打印

    i = 0

    while i <= 4:

        # 一行内的星星不能换行，取消print默认结束符\n

        print('*', end='')

        i += 1

    # 每行结束要换行，这里借助一个空的print()函数，

    # 利用print()默认结束符换行.

    print()

    j += 1

总结一下：

外层循环控制图形的高度。

内层循环控制图形的宽度。

循环嵌套时，外层循环没执行一次，内存循环就要执行一圈。

（2）应用二：打印星号(三角形)

需求：

*

**

***

****

*****

分析：

一行输出星星的个数和行号是相等的，

也就是每行要重复打印行号数字个星号。
将打印行星号的命令重复执行5次实现打印5行。

代码如下：

# 重复打印5行星星

# j表示行号

j = 0

while j <= 4:

    # 一行星星的打印

    i = 0

    # i表示每行里面星星的个数，这个数字要和行号相等

    # 所以i要和j联动

    while i <= j:

        print('*', end='')

        i += 1

    print()

    j += 1

（3）打印九九乘法表

从上边打印三角形的思路引入，来实现代码。

执行结果：

代码如下：

"""

步骤1. 打印一个乘法表达式：x * x = x*x

步骤2. 一行打印多个表达式，

        一行表达式的个数和行号数相等，

        循环行号次，

        一个行内不换行。

步骤3. 打印多行表达式，步骤2循环9次。

**** 一行表达式的个数和行号数相等

"""

# 重复打印9行表达式

j = 1

while j <= 9:

    # 打印一行里面的表达式 a * b = a*b

    i = 1

    while i <= j:

        # 乘法表达式 x * x = x*x

        print(f'{i}*{j}={j*i}', end='\t')

        i += 1

    print() # 换行

    j += 1

（4）求100以内所有的质数

# 创建一个循环，求1-100以内所有的数

i = 2

while i <= 100:

    # 创建一个变量，记录i的状态，默认认为i是质数

    flag = True

    # 判断i是否是质数

    # 获取所有可能成为i的因数的数

    j = 2

#   while j < i:

    # 如36,6之前的因数和6之后的因数是对称的

    # 所以不用循环整个i，循环根号就可以了

    while j <= i ** 0.5:

        # 判断i能否被j整除

        if i % j == 0:

            # i能被j整除，证明i不是质数，修改flag为False

            flag = False

            # 一旦进入判断，则证明i一定不是质数，

            # 此时内层循环没有继续执行的必要,

            # 使用break来退出内层的循环.

            break

        j += 1

    # 验证结果并输出

    if flag :

        print(i)

    i += 1