2.10 流程控制之 while循环

1. while 循环语句

while 循环语句: 对条件进行判断, 
为真:　则执行代码块内的语句, 执行完后会再次放回到 while 语句的条件判断, 为真则继续执行子代码块.
为假:　跳过代码块内的语句, 往下运行.
* 死循环: while 的条件永远为真, 一直执行子代码块, 程序不会停止运行.

结构: 
* 1.　while 关键字
* 2.　条件+冒号, 所有的控制语句都以冒号结尾, 后面紧跟着一个代码块.
* 3.　代码块(代码块为 while 的子句)
1
2
3
4
5
6
7
8
9

2. 无限循环

无限循环油称'死循环', 它会占用很多的计算机资源.
正常的业务编程中应该尽量避免死循环. 不然会影响程序性能, 严重的话会造成程序卡死崩溃.
1
2

while True:
    print(1)
    
1
2
3

3. while 循环使用

设计程序时几乎不会是死循环, 而是重复多少次后结束循环.
1

3.1 循环打印数学

设计一个程序, 循环运行字代码块打印1到5后停止运行.
1

# 1. 定义一个变量, 值为1
x = 1

# 2. 判断 x 的值是否比 6 小, 条件为 True 执行子代码块
while x < 6:
    # 2.1 打印x的值
    print(x)
    # 2.2 自增
    x += 1

1
2
3
4
5
6
7
8
9
10

Pythontutor 是一个在线可视化代码执行过程的的网站, 借助于图形化我们可以更好地理解代码.
Pythontutor 地址: https://pythontutor.com/render.html#mode=display
* 支持Python 3.6 与 2.7 版本.
1
2
3

3.2 循环获取输入

设计一个程序, 一直获取用户输入, 要求输入字符信息, 输入任何字符都打印 '输入的指令不对!', 
直到用户输入'q'退出程序.
1
2

# 先获取用户输入的字符, 在判断输入字符串是否等于 'q'
while input("请输入执行的代码(按下q退出)>>>:") != 'q':
    print('代码执行完毕！')

print('退出程序成功!')

1
2
3
4
5
6

3.3 模拟登录

设计一个程序, 模拟网站登录, 获取账户名称与密码, 都输入正确, 打印'登录成功!', 结束程序.
用户名密码错误提示'账户名或密码错误', 之后再次获取用户的输入对输入进行判断.
三次错误后提示'你的账户名被锁定, 请联系管理员!', 结束程序.
1
2
3

* 1. 先设计主体程序, 获取账户名称与密码, 比对输入的信息.
1

# 1. 定义账户名称 与 密码(直接使用字符串格式)
username = 'kid'
password = '123'

# 2. 获取用户输入字符串
input_username = input('账户名称>>>:')
input_password = input('账户密码>>>:')

# 3. 判断输入的账户名称 与 密码是否正确
if (input_username == username) and (input_password == password):
    print('登录成功!')

1
2
3
4
5
6
7
8
9
10
11
12

* 2. 添加输入信息不正常三次锁账户.
1

# 1. 定义账户名称 与 密码(直接使用字符串格式)
username = 'kid'
password = '123'

# 4. 定义一个计数器
error_num = 0

# 5. 循环代码块
while error_num < 3:

    # 2. 获取用户输入字符串
    input_username = input('账户名称>>>:')
    input_password = input('账户密码>>>:')

    # 3. 判断输入的账户名称 与 密码是否正确
    if (input_username == username) and (input_password == password):
        print('登录成功!')
        # 8. 输入信息正确跳出循环(让error_num不小于3即可)
        error_num = 3

    # 6. 输入错误, 计时器+1
    else:
        error_num += 1

        # 7. 三次错误提示账户被锁
        if error_num == 3:
            print('你的账户名被锁定, 请联系管理员!')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

4. break 关键字

4.1 break 的使用

break 关键字在 while 循环的子代码块内使用, 当程序执行 break 时, 会立刻跳出本层循环.
1

# 定义一个变量值为 0
num = 0

# 循环
while True:
    print(num)
    num += 1
    # num 等于 3 执行 if的代码块
    if num == 3:
        # 结束本层循环
        break

print('程序结束')

1
2
3
4
5
6
7
8
9
10
11
12
13
14

4.2 模拟登录

设计一个程序, 模拟网站登录, 账户密码输入正确, 打印'登入成功!', 结束程序.
fouz提示校验失败信息, 要求再次输入, 直到输入正确才结束程序, 使用break.
1
2

* 1. 先设计主体程序, 获取账户名称与密码, 比对输入的信息.
1

# 1. 定义账户名称 与 密码(字符串类型)
username = 'kid'
password = '123'

# 2. 获取用户输入字符串
input_username = input('账户名称>>>:')
input_password = input('账户密码>>>:')

# 3. 判断输入的账户名称 与 密码是否正确
if (input_username == username) and (input_password == password):
    print('登录成功!')

1
2
3
4
5
6
7
8
9
10
11
12

* 2. 添加循环语句与跳出循环语句
1

# 1. 定义账户名称 与 密码(字符串类型)
username = 'kid'
password = '123'

# 4. 循环代码块
while True:
    # 2. 获取用户输入字符串
    input_username = input('账户名称>>>:')
    input_password = input('账户密码>>>:')

    # 3. 判断输入的账户名称 与 密码是否正确
    if (input_username == username) and (input_password == password):
        # 3.1 登录成功并结束程序.
        print('登录成功!')
        # 3.2 跳出循环
        break

    # 4. 校验失败提示
    else:
        print('账户名称或密码输入有误, 请重新输入!')
        
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

4.3 while 嵌套

设计一个程序, 模拟网站登录, 先要求输入账户名称, 对账户名称进行校验.
校验失败打印提示信息, 并要求再次输入.

检验成功, 在要求输入账户密码, 对账户密码进行校验, 校验失败打印提示信息, 并要求再次输入.
校验成功, 打印'登录成功!', 并退出程序.
1
2
3
4
5

* 1. 先设计主体程序, 获取账户名称与密码, 比对输入的信息.
1

# 1. 定义账户名称 与 密码(字符串类型)
username = 'kid'
password = '123'

# 2. 获取账户名称
input_username = input('账户名称>>>:')
# 3. 校验账户名称
if input_username == username:
    # 3.1 获取账户密码
    input_password = input('账户密码>>>:')
    # 3.2 校验账户密码
    if input_password == password:
        print('登入成功!')

1
2
3
4
5
6
7
8
9
10
11
12
13
14

* 2. 添加账户校验失败与密码校验失败提示
1

# 1. 定义账户名称 与 密码(字符串类型)
username = 'kid'
password = '123'

# 2. 获取账户名称
input_username = input('账户名称>>>:')
# 3. 校验账户名称
if input_username == username:
    # 3.1 获取账户密码
    input_password = input('账户密码>>>:')
    # 3.2 校验账户密码
    if input_password == password:
        print('登入成功!')

    # 3.3 校验密码失败
    else:
        print('密码输入有误, 请重新输入!')

# 4. 校验账户失败
else:
    print('账户输入有误, 请重新输入!')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

第一次运行, 运行工具窗口显示:
账户名称>>>:xxx
账户输入有误, 请重新输入!
--------------------------
第二次运行, 运行工具窗口显示:
账户名称>>>:kid
账户密码>>>:789
密码输入有误, 请重新输入!
1
2
3
4
5
6
7
8

* 3. 添加循环语句
1

# 1. 定义账户名称 与 密码(字符串类型)
username = 'kid'
password = '123'

# 5. 添加循环获取账户名称
while True:
    # 2. 获取账户名称
    input_username = input('账户名称>>>:')

    # 3. 校验账户名称
    if input_username == username:
        # 6. 添加循环获取账户密码
        while True:
            # 3.1 获取账户密码
            input_password = input('账户密码>>>:')
            # 3.2 校验账户密码
            if input_password == password:
                print('登入成功!')
                # 7. 退出循环获取账户密码
                break
            # 3.3 校验密码失败
            else:
                print('密码输入有误, 请重新输入!')
        # 8. 退出循环获账户名称
        break
    # 4. 校验账户失败
    else:
        print('账户输入有误, 请重新输入!')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

运行工具窗口显示:
账户名称>>>:(kid)
账户密码>>>:(123)
登入成功!
1
2
3
4

4.4 标志位的使用

程序中嵌套使用多个 while 循环语句, 在退出程序时, 使用 break 语句一层层的退出循环比较复杂.

定义一个变量, 让流程控制语句判断程序是否执行, 这个变量被称为'标志'.
标志值为 True 时程序继续运行, 标志值为 False 时让程序停止运行.
在使用 while 嵌套时, 只需检查标志的当前值是否为 True.

布尔值类型变量命名注意点:
标志位的值一般是布尔值, Python 中定义布尔值的变量名, 一般会在前面加上 'is_'.
能让开发者能够通过变量名知道变量的类型.
1
2
3
4
5
6
7
8
9

不使用break 重新上例程序, 前两步一样.
1

# 1. 定义账户名称 与 密码(字符串类型)
username = 'kid'
password = '123'

# 5. 定义一个标志位
is_flag = True

# 6. 添加循环获取账户名称(终止循环的条件是 is_flag 不为 True)
while is_flag:
    # 2. 获取账户名称
    input_username = input('账户名称>>>:')
    # 3. 校验账户名称
    if input_username == username:
        # 7. 添加循环获取账户密码(终止循环的条件是 is_flag 不为 True)
        while is_flag:
            # 3.1 获取账户密码
            input_password = input('账户密码>>>:')
            # 3.2 校验账户密码
            if input_password == password:
                print('登入成功!')
                # 8. 修改标志位
                is_flag = False

            # 3.3 校验密码失败
            else:
                print('密码输入有误, 请重新输入!')

    # 4. 校验账户失败
    else:
        print('账户输入有误, 请重新输入!')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

运行工具窗口显示:
账户名称>>>:(kid)
账户密码>>>:(123)
登入成功!
1
2
3
4

4.5 猜数字游戏

设计一个程序, 定义一个数字, 让用户输入猜的数字, 有三次机会.
猜对了打印'恭喜你猜对了!', 退出程序,
猜大了打印'你输入数字大了!', 
猜小了打印'你输入数字小了!', 
三次机会使用完后询问是否继续玩, 输入'q'退出游戏, 否则继续猜数字游戏.
1
2
3
4
5

* 1. 先设计主体程序, 定义一个变量存储需要猜测的值, 在获取输入的字符串, 与其做比较.
1

# 1. 定义一个变量存储猜测的数字
guess_numbers = 21

# 2. 获取用户输入
input_str = input('输入猜测的数字>>>:')
# 3. 将字符串纯数字转为整型
input_numbers = int(input_str)

# 4. 判断猜测的数字是否正确(猜的数字不比要猜的数字大, 也不不比要猜的数字小, 就是等于!)
if input_numbers > guess_numbers:
    print('你输入数字大了!')
elif input_numbers < guess_numbers:
    print('你输入数字小了!')
else:
    print('恭喜你猜对了!')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

第一次运行工具窗口显示:
输入猜测的数字>>>:(15)
你输入数字小了!

第二次运行工具窗口显示:
输入猜测的数字>>>:(24)
你输入数字大了!

第三次运行工具窗口显示:
输入猜测的数字>>>:(21)
恭喜你猜对了!
1
2
3
4
5
6
7
8
9
10
11

* 2. 添加循环猜测, 三次猜测限制.
1

# 1. 定义一个变量存储猜测的数字
guess_numbers = 21

# 5. 定义一个计数器
count = 0

# 6. 循环猜测
while count < 3:

    # 2. 获取用户输入
    input_str = input('输入猜测的数字>>>:')
    # 3. 将字符串纯数字转为整型
    input_numbers = int(input_str)

    # 4. 判断猜测的数字是否正确(猜的数字不比要猜的数字大, 也不不比要猜的数字小, 就是等于!)
    if input_numbers > guess_numbers:
        print('你输入数字大了!')
    elif input_numbers < guess_numbers:
        print('你输入数字小了!')
    else:
        print('恭喜你猜对了!')
        # 7. 退出循环猜测
        break

    # 8. 猜错了计数
    count += 1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

运行工具窗口显示:
输入猜测的数字>>>:(1)
你输入数字小了!
输入猜测的数字>>>:(2)
你输入数字小了!
输入猜测的数字>>>:(25)
你输入数字大了!
1
2
3
4
5
6
7

* 3. 添加 三次机会使用完了询问是否继续玩游戏.
1

# 1. 定义一个变量存储猜测的数字
guess_numbers = 21

# 5. 定义一个计数器
count = 0

# 6. 循环猜测
while count < 3:

    # 2. 获取用户输入
    input_str = input('输入猜测的数字>>>:')
    # 3. 将字符串纯数字转为整型
    input_numbers = int(input_str)

    # 4. 判断猜测的数字是否正确(猜的数字不比要猜的数字大, 也不不比要猜的数字小, 就是等于!)
    if input_numbers > guess_numbers:
        print('你输入数字大了!')
    elif input_numbers < guess_numbers:
        print('你输入数字小了!')
    else:
        print('恭喜你猜对了!')
        # 7. 退出循环猜测
        break

    # 8. 猜错了计数
    count += 1

    # 9. 三次机会使用完了, 询问是否继续玩游戏
    if count == 3:
        # 10. 清空计数器
        count = 0
        if input('三次机会使用完了, 按下q退出,否则继续! 请输入>>>:') == 'q':
            break

# 11. 程序结束提示
print('程序结束!')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

运行工具窗口显示:
输入猜测的数字>>>:(1)
你输入数字小了!
输入猜测的数字>>>:(2)
你输入数字小了!
输入猜测的数字>>>:(2)
你输入数字小了!
三次机会使用完了, 按下q退出,否则继续! 请输入>>>:(5)
输入猜测的数字>>>:(2)
你输入数字小了!
输入猜测的数字>>>:(5)
你输入数字小了!
输入猜测的数字>>>:(6)
你输入数字小了!
三次机会使用完了, 按下q退出,否则继续! 请输入>>>:(q)
程序结束!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

5. continue 关键字

continue 关键字, 在 while 循环子代码块内使用, 
当程序执行到 continue 时立刻结束本次循环, 回到循环的条件判断.
1
2

设计一个程序, 使用 while 循环打印数字 0-9 跳过 4, 需要使用 continuce关 键字.
1

# 1. 定义变量
x = 0

# 2. 循环打印
while x < 10:
    # 2.1 判断 x的值如果4, 则结束本次循环, 不往后面执行, 回到条件判断处.
    if x == 4:
        # 注意点, 如果x的值不改变就造成死循环了.
        x += 1
        continue

    # 2.2 打印x的值
    print(x)
    # 2.3 x的值自增
    x += 1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

很多情况下可以使用其它方法不执行某次循环, 而不使用continuce 关键字.
1

# 1. 定义一个变量
x = 0

# 2. 循环打印
while x < 10:
    # 2.1 x的值不为4 打印x的值
    if x != 4:
        print(x)

    # 2.2 x的值自增
    x += 1

1
2
3
4
5
6
7
8
9
10
11
12

运行工具窗口显示:
0
1
2
3
5
6
7
8
9
1
2
3
4
5
6
7
8
9
10

6. else 从句

while循环还可以增加一个 else 从句, while与 else 缩进相同.
当 while 循环正确执行完毕后结束循环之后, 会执行 else 的子代码.
如果, 被 break 语句中断的循环不执行 else 的子代码.
标准位, continue 结束循环不影响 else 的子代码.
1
2
3
4

6.1 标志位退出循环

# 1. 定义一个变量
x = 0

# 2. 定义一个标志位
is_out = True

# 3. 循环代码块
while is_out:
    # 3.1 打印x值
    print(x)
    # 3.2 x的值自增
    x += 1
    # 3.3 x的值为3 修改标志位为False
    if x == 3:
        is_out = False

# 4. while的else语句
else:
    print('循环结束了!')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

6.2 continue 结束本次循环

# 1. 定义一个变量
x = 0

# 2. 循环代码块
while x < 4:
    # 2.1 x的值为3 跳过本次循环
    if x == 3:
        # 注意点, x的值不自增会进入死循环
        x += 1
        continue
    # 2.2 打印x值
    print(x)
    # 2.3 x的值自增
    x += 1


# 3. while的else语句
else:
    print('循环结束了!')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

6.3 break结束本次循环

# 1. 定义一个变量
x = 0

# 2. 循环代码块
while x < 4:
    # 2.1 x的值为3 结束本层循环
    if x == 3:
        break
    # 2.2 打印x值
    print(x)
    # 2.3 x的值自增
    x += 1


# 3. while的else语句
else:
    print('循环结束了!')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

7. while 嵌套

设计一个程序, 模拟登入, 
先获取用户名, 然后校验用户名, 用户名不正确打印'用户名不存在', 继续让用户输入用户名, 
用户名正确, 打印'用户名正确',继续让用户输入密码, 然后校验密码, 
密码不正确打印'密码不正确', 继续让用户输入密码, 密码正确, 打印'登录成功'.
1
2
3
4

# 1. 循环获取用户名
while True:
    # 2. 校验用户名
    # 2.1获取用户名
    username = input('请输入登入用户>>>: ')

    # 2.2 用户名正确
    if username == 'kid':
        # 2.2.1 打印'用户名正确'
        print('用户名正确!')
        # 2.2.2 循环获取密码
        while True:
            # 2.2.2.1 获取密码
            password = input('请输入用户密码>>>: ')
            # 2.2.2.2 校验密码成功
            if password == '123':
                # 2.2.2.2.1 打印'登录成功'
                print('登录成功!')
                # 2.2.2.2.2 退出循环获取密码
                break

            # 2.2.2.3 校验密码不成功
            else:
                # 2.2.2.3.1 打印'密码不正确'
                print('密码不正确!')
        # 2.2.3 退出循环获取用户名
        break

    # 2.3 用户名不正确
    else:
        # 2.3.1 打印'用户名不存在!
        print('用户名不存在!')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

先写错误的逻辑在写正确的逻辑, 减少代码的层次.
能够保持正确执行逻辑的前提下, 尽量按符合人类思维和阅读习惯编写代码.
* 学习前期不要想要取优化代码, 首先要保证程序能够正确的运行.
1
2
3

# 1. 循环获取用户名
while True:
    # 2. 校验用户名
    # 2.1 获取用户名
    username = input('请输入登入用户>>>: ')

    # 2.2 用户名不正确
    if username != 'kid':
        # 2.2.1 打印'用户名不存在!
        print('用户名不存在!')
        # 2.2.2 返回循环条件判断
        continue

    # 2.3 打印'用户名正确'
    print('用户名正确!')

    # 2.4 循环获取密码
    while True:
        # 2.4.1  获取密码
        password = input('请输入用户密码>>>: ')
        # 2.4.2 校验密码不成功
        if password != '123':
            # 2.4.1 打印'密码不正确'
            print('密码不正确!')
            # 2.4.2返回循环判断处
            continue

        # 2.4.3 打印'登录成功'
        print('登录成功!')
        # 2.4.4 退出循环获取密码
        break

    # 2.5 退出循环获取用户名
    break

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

8. 练习

1. 使用while循环输出1 2 3 4 5 6     8 9 10.
2. 求1-100的所有数的和.
3. 输出 1-100 内的所有奇数.
4. 输出 1-100 内的所有偶数.
5. 求1-2+3-4+5 ... 99的所有数的和.
6. 用户登陆（三次机会重试）.
7. 猜年龄游戏
    要求：
    允许用户最多尝试3次, 3次都没猜对的话, 就直接退出, 如果猜对了, 打印恭喜信息并退出.

8. 猜年龄游戏升级版
    要求：
    允许用户最多尝试3次,
    每尝试3次后, 如果还没猜对, 就问用户是否还想继续玩, 如果回答Y或y, 
    就继续让其猜3次, 以此往复, 如果回答N或n, 就退出程序,
    如何猜对了, 就直接退出.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

---

文章的段落全是代码块包裹的, 留言0是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言1是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言2是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言3是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言4是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言5是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言6是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言7是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言8是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言9是为了避免文章提示质量低.

---