条件和循环语句

1. 条件语句

1.1 简介

• 如果某些条件满足，才能做某件事情；条件不满足时，则不能做，这就是所谓的选择判断
• 不仅生活中有，在软件开发中"选择"功能也经常会用到

1.2 应用场景

火车站安检

上网吧

密码判断

2. 关系和逻辑运算符

2.1 关系运算符

1. 简介

• 2个数比较，满足结果为True, 不满足为False

age = 15
print(age >= 18) # 结果为False

2. 应用

num1 = 15
num2 = 20

# == 等于：表示左右两个操作数是否相等
print(num1 == num2)  # 打印结果为：False

# != 不等于
print(num1 != num2)  # 打印结果为：True

# < 小于
print(num1 < num2)  # 打印结果为：True

# >= 大于等于: num1 大于 或者 等于 num2 ，条件都成立
print(num1 >= num2)  # 打印结果为：False

# <= 小于等于： num1 小于 或者 等于 num2 ，条件都成立
print(num1 <= num2)  # 打印结果为：True

2.1 逻辑运算符

1. 简介

• and：并且， 左右2边都为True，结果才为True
• or：或者， 只有有1个为True，结果为True
• not：非，取反，原来是True就变成False
  

2. 应用

"""
and: 并且， 左右2边都为True，结果才为True
or:  或者， 只有有1个为True，结果为True
not: 非，取反，原来是True就变成False
"""

# 左右2边都为True，结果才为True
print(True and True)

# 5>3 为True,  4 < 3为False， 整体为False
print(5 > 3 and 4 < 3)

print(True or False)
# 1 == 1 为True, 结果就为True
print(1 == 1 or 1 > 3)

print(not True)
# 1 == 1为True, 加上not，变成False
print( not (1 == 1) )

3. 分类

3.1 if 语句

1. 简介

• if 语句是用来进行选择判断的

2. 格式

if 要判断的条件:
    条件满足时，要做的事情
    ……

• 注意：
  *判断的条件结果为 True 时，才会执行 if 里面的代码块
  • 代码的缩进为一个tab键，或者 4 个空格
  • 只要缩进一个tab键里面的代码，都属于 if 语句里面的代码块

3. 应用

需求:选择年龄

1. 定义一个变量 age，保存年龄
2. if 判断条件(判断是否满 18 岁)
3. 满足条件，打印一句话：允许进网吧嗨皮

print('if的前面')

 # 1. 定义一个变量age，保存年龄
age = 19

 # 2. if 判断条件(判断是否满 18 岁)
if age >= 18:
    # 3. 满足条件，打印一句话：允许进网吧嗨皮
    print('允许进网吧嗨皮')

 # 不属于if的，可以无条件执行
print('if执行完毕')

运行结果:

if的前面
允许进网吧嗨皮
if执行完毕

3.2 if-else 语句

1. 简介

在不满足条件的时候，使用 if-else

2. 格式

if 要判断的条件:
    条件满足时，要做的事情
    ……
else:
    条件不满足时，要做的事情
    ……

3. 应用

需求：判断年龄改进

1. 输入用户年龄，input返回值是字符串，类型转换为int
2. if 判断是否满 18 岁： 2.1 如果满 18 岁，打印一句话：允许进网吧嗨皮
3. 否则，未满 18 岁： 3.1 打印一句话：提示回家写作业
   实现

# 1. 输入用户年龄，input返回值是字符串，类型转换为int
age = int(input('输入用户年龄: '))

# 2. if 判断是否满 18 岁:
if age >= 18:
    # 2.1 如果满 18 岁，打印一句话：允许进网吧嗨皮
    print('允许进网吧嗨皮')
# 3. 否则，未满 18 岁
else:
    # 3.1 打印一句话：提示回家写作业
    print('回家写作业')

运行结果：

输入用户年龄: 12
回家写作业

4. 三目运算符

1. 简介

• 三目运算符：简洁版if-else语句
• 如果 a > b的条件成立，三目运算的结果是a，否则就是b

a if a > b else b

2. 应用

# 需求：通过if-else求2个数的最大值
# 1. 定义2个变量，赋值
a = 10
b = 20

# 2. if 用大于比较2个变量大小：
if a > b:
    #  2.1 如果满足条件，把大的那个数保存
    _max = a
# 3. 否则，不满足条件：
else:
    #  3.1 把小的那个数保存
    _max = b
# 4. if 语句的外面，打印最大值
print(_max)

# 重新给a, b赋值
a = 10
b = 20

# 通过 三目运算符实现 同样效果
# 如果 a > b的条件成立，三目运算的结果是a，否则就是b
_max2 = a if a > b else b
print(_max2)

3.3 if-elif-else 语句

1. 简介

• 一对 if 和 else 可以让代码执行出两种不同的结果
• 但开发中，可能希望并列的执行出多种结果，这时就可以使用 elif

2. 语法格式

if 条件1：
    满足条件1，执行的事情1
elif 条件2：
    满足条件2，执行的事情2
elif 条件3：
    满足条件3，执行的事情3
else:
    不满足上述条件，执行其它事情

说明:

• 条件从上往下判断
• 只要满足一个条件，执行满足条件的代码块，其它条件不再判断执行

3. 应用

需求：女友的节日

1. 定义 holiday_name 字符串变量记录节日名称
2. 如果是 情人节 应该 买玫瑰／看电影
3. 如果是 平安夜 应该 买苹果／吃大餐
4. 如果是 生日 应该 买蛋糕
5. 其他的日子每天都是节日啊……
   实现：

"""
1. 定义 holiday_name 字符串变量记录节日名称
2. if 判断是否为情人节：
    2.1 如果是 情人节，打印： 买玫瑰／看电影
3. elif 判断是否为平安夜:
    3.1 如果是 平安夜，打印： 买苹果／吃大餐
4. elif 判断是否为生日 :
    4.1 如果是 生日，打印： 买蛋糕
5. else 其它情况：
    5.1 打印：每天都是节日啊……
"""

# 1. 定义 holiday_name 字符串变量记录节日名称
holiday_name = '情人节'

# 2. if 判断是否为情人节：
#   是两个=，==，判断是否相等
if holiday_name == '情人节':
    # 2.1 如果是 情人节，打印： 买玫瑰／看电影
    print('买玫瑰／看电影')
# 3. elif 判断是否为平安夜:
elif holiday_name == '平安夜':
    # 3.1 如果是 平安夜，打印： 买苹果／吃大餐
    print('买苹果／吃大餐')
# 4. elif 判断是否为生日 :
elif holiday_name == '生日':
    # 4.1 如果是 生日，打印： 买蛋糕
    print('买蛋糕')
# 5. else 其它情况：
else:
    # 5.1 打印：每天都是节日啊……
    print('每天都是节日啊……')

3.4 嵌套

1. 简介

• if 嵌套：if 里面包含 if
• 满足外层if的条件，才执行判断内层的if

1. 应用场景

• 坐火车或者地铁的实际情况是：
  • 先进行安检如果安检通过才会判断是否有车票
  • 或者是先检查是否有车票之后才会进行安检
• 即实际的情况某个判断是再另外一个判断成立的基础上进行的

2. 格式

if 条件 1:
    条件 1 满足执行的代码
    ……

    if 条件 1 基础上的条件 2:
        条件 2 满足时，执行的代码
        ……    

    # 条件 2 不满足的处理
    else:
        条件 2 不满足时，执行的代码

# 条件 1 不满足的处理
else:
    条件1 不满足时，执行的代码
    ……

3. 应用

需求：车票刀具安检

1. 定义布尔型变量 has_ticket 表示是否有车票
2. 定义整型变量 knife_length 表示刀的长度，单位：厘米
3. 首先检查是否有车票，如果有，提示：有车票，即将进行下一步的刀具安检
4. 安检时，需要检查刀的长度，判断是否超过 20 厘米
	* 如果超过 20 厘米，提示：刀的长度超过20厘米，不允许上车
	* 如果不超过 20 厘米，安检通过
5. 如果没有车票，提示：大哥，您要先买票啊

思路：

"""
步骤流程：先写外层的if，再写内层的if

外层 if 步骤流程：
1. 定义布尔型变量 has_ticket，赋值为True表示有票
2. if 判断是否有票：
    2.1 如果有票，打印：有车票，即将进行下一步的刀具安检
    2.2 内层if的处理(先空着，不处理)
3. 否则，没有票
    3.1 打印：大哥，您要先买票啊

内层 if 步骤流程：
a. 定义整型变量 knife_length 表示刀的长度，单位：厘米
b. if 判断刀具长度是否超过20：
    b.1 如果超过 20 厘米，打印：刀的长度超过20厘米，不允许上车
c. 否则，不超过20厘米：
    c.1 打印：安检通过，请上车
"""

实现：

# 外层 if
# 1. 定义布尔型变量 has_ticket，赋值为True表示有票
has_ticket = True

# 2. if 判断是否有票：
if has_ticket:
    # 2.1 如果有票，打印：有车票，即将进行下一步的刀具安检
    print('有车票，即将进行下一步的刀具安检')

    # 2.2 内层 if 的处理
    # a. 定义整型变量 knife_length 表示刀的长度，单位：厘米
    knife_length = 22
    # b. if 判断刀具长度是否超过20：
    if knife_length > 20:
        # b.1 如果超过 20 厘米，打印：刀的长度超过20厘米，不允许上车
        print('刀的长度超过20厘米，不允许上车')
    # c. 否则，不超过20厘米：
    else:
        # c.1 打印：安检通过，请上车
        print('安检通过，请上车')

# 3. 否则，没有票
else:
    # 3.1 打印：大哥，您要先买票啊
    print('大哥，您要先买票啊')

4. 应用

猜拳游戏

4.1 需求

1. 从控制台输出要出的拳 —— 拳头（1）／剪刀（2）／布（3）
2. 电脑 随机 出拳 —— 先假定电脑只会出拳头，完成整体代码功能
3. 比较胜负
   

4.2 思路

1. 用户输入数字：请输入（石头 1， 剪刀 2， 布 3）
2. 电脑 随机 出拳，即随机产生一个[1,3]范围的数
3. 条件判断

if (user == 1 and computer == 2) or (user == 2 and computer == 3) or (user == 3 and computer == 1):
    print('用户赢')
elif user == computer:
    print('平局')
else:
    print('电脑赢')

4.2 实现1

"""
规则：石头 1， 剪刀 2， 布 3
角色：用户user，电脑computer
用户赢的情况：
    user == 1 and computer == 2
    user == 2 and computer == 3
    user == 3 and computer == 1

步骤流程：
1. 用户输入数字：请输入（石头 1， 剪刀 2， 布 3）
2. 电脑固定一个数字，假定只会出石头
3. if 用户赢电脑的判断：
    3.1 如果用户赢，打印：电脑弱爆了
4. elif 平局：
    4.1 打印：心有灵犀，再来一盘！
5. 否则，电脑赢
    5.1 打印：不行，我要和你决战到天亮！
"""

# 1. 用户输入数字
user = int(input('请输入（石头 1， 剪刀 2， 布 3）：'))

# 2. 电脑固定一个数字，假定只会出石头
computer = 3

# 3. if 用户赢电脑的判断：
if (user == 1 and computer == 2) or (user == 2 and computer == 3) or (user == 3 and computer == 1):
    # 3.1 如果用户赢，打印：电脑弱爆了
    print('电脑弱爆了')
# 4. elif 平局：
elif user == computer:
    print('心有灵犀，再来一盘！')
# 5. 否则，电脑赢
else:
    # 5.1 打印：不行，我要和你决战到天亮！
    print('不行，我要和你决战到天亮！')

4.4 随机数的产生

• 在Python中，要使用随机数，首先需要导入随机数的模块—— “工具包”

import random

• 导入模块后，可以直接在模块名称后面敲一个 . 然后按Tab键，会提示该模块中包含的所有函数
• random.randint(a, b)，返回[a, b]之间的整数，包含a和b

"""
功能：产生某个范围的随机数

步骤流程：
# 1. 导入模块，工具包
# 2. 调用工具里面的函数，返回一个随机值
"""
# 1. 导入模块，工具包
import random

# 2. 调用工具里面的函数，返回一个随机值
num = random.randint(1, 3)  # [1, 3]在1, 2, 3随机产出一个数
print(num)

4.5 实现2

"""
规则：石头 1， 剪刀 2， 布 3
角色：用户user，电脑computer
用户赢的情况：
    user == 1 and computer == 2
    user == 2 and computer == 3
    user == 3 and computer == 1

步骤流程：
0. 导入模块
1. 用户输入数字：请输入（石头 1， 剪刀 2， 布 3）
2. 电脑 随机 出拳，即随机产生一个[1,3]范围的数
3. if 用户赢电脑的判断：
    3.1 如果用户赢，打印：电脑弱爆了
4. elif 平局：
    4.1 打印：心有灵犀，再来一盘！
5. 否则，电脑赢
    5.1 打印：不行，我要和你决战到天亮！
"""

# 0. 导入模块
import random

# 1. 用户输入数字
user = int(input('请输入（石头 1， 剪刀 2， 布 3）：'))

# 2. 电脑 随机 出拳，即随机产生一个[1,3]范围的数
computer = random.randint(1, 3)

# 3. if 用户赢电脑的判断：
if (user == 1 and computer == 2) or (user == 2 and computer == 3) or (user == 3 and computer == 1):
    # 3.1 如果用户赢，打印：电脑弱爆了
    print('电脑弱爆了')
# 4. elif 平局：
elif user == computer:
    print('心有灵犀，再来一盘！')
# 5. 否则，电脑赢
else:
    # 5.1 打印：不行，我要和你决战到天亮！
    print('不行，我要和你决战到天亮！')

2. 循环语句

2.1 简介

1. 应用场景

• 生活中

• 软件开发

2. 作用

• 让 指定的代码重复地执行

2.2 分类

1. while

1.1 格式

变量设置初始值

while 条件(判断 变量是否满足条件):
    条件满足时，做的事情1
    ...(省略)...

    修改变量

• 注意：while语句中的缩进部分是一个独立的代码块

1.2 使用

"""
1. 定义一个条件变量，一般赋值为0
2. while 判断条件：
   2.1 满足条件的代码块
   2.2 条件变量的改变【非常重要】
"""

i = 0
while i < 10:
   print('跑步第%d圈' % (i+1))
   i += 1

1.3 死循环

• 条件永远为真True循环即为死循环，也叫无限循环

while True:
    print('我会永远循环执行下去')

1.4 debug调试

1. 操作流程

1. 设置断点
2. 调试运行
3. 单步执行代码
4. 观察变量变化
   • 重复步骤3、4，观察变量和程序执行流程
   • 重复步骤3、4，观察变量和程序执行流程
   • 重复步骤3、4，观察变量和程序执行流程

2. 流程图片

• 设置断点、取消断点

• 调试运行

• 调试终端页面

单步执行代码

观察变量变化

停止调试

1.5 应用1

需求：循环跑步10圈

"""
1. 定义一个条件变量，一般赋值为0
2. while 判断条件：
    2.1 满足条件的代码块
    2.2 条件变量的改变【非常重要】
"""

# 1. 定义一个条件变量，一般赋值为0
i = 0

# 2. while 判断条件：
while i < 10:
    # 2.1 满足条件的代码块
    print('跑步第%d圈' % (i+1))

    # 2.2 条件变量的改变【非常重要】
    i += 1

运行结果：

跑步第1圈
跑步第2圈
跑步第3圈
跑步第4圈
跑步第5圈
跑步第6圈
跑步第7圈
跑步第8圈
跑步第9圈
跑步第10圈

1.6 应用2

需求：计算1~100的累加和（包含1和100）
思路：

"""
核心代码分析：
_sum = 0

i = 1
# 等价于 _sum += i
_sum = sum+i  # _sum = 0+1

i = 2
_sum = _sum+i # _sum = 上一步_sum的内容 + 2 ==》 _sum = 0+1+2

i = 3
_sum = _sum+i # _sum = 上一步_sum的内容 + 3 ==》 _sum = 0+1+2+3


步骤流程：
1. 定义条件变量 i, 赋值为1
2. 定义一个辅助变量，用于保存累计的结果
3. while 条件(i <= 100)：
    3.1 完成累加
    3.2 条件变量改变
4. 在循环的外面，打印最终的累加结果
"""

实现：

# 1. 定义条件变量 i, 赋值为1
i = 1
# 2. 定义一个辅助变量，用于保存累计的结果
_sum = 0

# 3. while 条件(i <= 100)：
while i <= 100:
    # 3.1 完成累加
    _sum = _sum + i

    # 3.2 条件变量改变
    i += 1

# 4. 在循环的外面，打印最终的累加结果
print('_sum = %d' % _sum)

1.7 应用3

需求：计算1~100之间偶数的累加和

"""
判断一个变量是否为偶数：对2求余，余数为0即为偶数
i = 4
if i % 2 == 0：
    print('偶数')

步骤流程：
1. 定义条件变量
2. 设置辅助变量
3. while 条件：
    3.1 if 判断i是否为偶数
        3.1.1 累加
    3.2 条件变量的改变
4. 循环外面，打印累加结果
"""

思路：

# 1. 定义条件变量
i = 1
# 2. 设置辅助变量
_sum = 0

# 3. while 条件：
while i <= 100:
    # 3.1 if 判断i是否为偶数
    if i % 2 == 0:
        # 3.1.1 累加
        _sum += i

    # 3.2 条件变量的改变
    i += 1

# 4. 循环外面，打印累加结果
print("sum = %d" % _sum)

2. while嵌套

1. 简介

• while嵌套就是：while里面还有while

2. 格式

while 条件 1:
    条件满足时，做的事情1
    ...(省略)...

    while 条件 2:
        条件满足时，做的事情1
        ...(省略)...

        处理条件 2

    处理条件 1

3. 步骤流程

• 先写外层的while，再写内层的while

4. 应用1

需求：跑步 5 圈，每跑步1圈，做10个俯卧撑
思路：

"""
外层 while 步骤流程：
1. 设置外层循环的条件变量 i， 赋值为0
2. 外层while 条件(i < 5)：
    3. 打印跑了第几圈
    4. 做10个俯卧撑内循环处理(先空着，不处理)
    5. 外层循环的条件变量改变

内层 while 步骤流程：
4.1 定义内层循环条件变量 j = 0
4.2 内层循环 while j < 10:
    4.3 打印第几个俯卧撑
    4.4 内层循环的条件变量改变
"""

实现：

# 1. 设置外层循环的条件变量 i， 赋值为0
i = 0

# 2. 外层while 条件(i < 5)：
while i < 5:
    # 3. 打印跑了第几圈
    print('跑步第 %d 圈' % (i + 1))

    # 4. 做10个俯卧撑
    # 4.1 定义内层循环条件变量j = 0
    j = 0

    # 4.2 内层循环 while j < 10:
    while j < 10:
        # 4.3 打印第几个俯卧撑
        print('第%d俯卧撑' % (j + 1))
        # 4.4 内层循环的条件变量改变
        j += 1

    # 5. 外层循环的条件变量改变
    i += 1

4. 应用2

需求：通过循环打印1行星星

* * * * *

思路：

"""
步骤流程：
1 定义循环条件变量 j = 0
2 循环 while j < 5:
    3 打印一个星星，end=''作用指定不换行打印
    4 循环的条件变量改变
"""

实现：

# 1 定义循环条件变量 j = 0
j = 0
# 2 循环 while j < 5:
while j < 5:
    # 3 打印一个星星，end=''作用指定不换行打印
    print('* ', end='')

    # 4 循环的条件变量改变
    j += 1

要求：通过循环嵌套打印正方形

* * * * * 
* * * * * 
* * * * * 
* * * * * 
* * * * *

思路：

"""
外层 while 步骤流程：
1. 定义外层循环的条件变量 i = 0
2. 外层while 条件(i < 5)：
    3. 内循环处理(先空着，不处理)
    4. 单独打印空行
    5. 外层循环的条件变量改变

内层 while 步骤流程：
3.1 定义内层循环条件变量 j = 0
3.2 内层循环 while j < 5:
    3.3 打印一个星星，end=''作用指定不换行打印
    3.4 内层循环的条件变量改变
"""

实现：

# 1. 定义外层循环的条件变量 i = 0
i = 0

# 2. 外层while 条件(i < 5)：
while i < 5:
    # 3. 内循环处理：打印一行星星
    # 3.1 定义内层循环条件变量 j = 0
    j = 0
    # 3.2 内层循环 while j < 5:
    while j < 5:
        # 3.3 打印一个星星，end=''作用指定不换行打印
        print('* ', end='')

        # 3.4 内层循环的条件变量改变
        j += 1

    # 4. 单独打印空行
    print()
    # 5. 外层循环的条件变量改变
    i += 1

5. 应用三

要求：打印三角形

* 
* * 
* * * 
* * * *  
* * * * *

思路：

"""
外层 while 步骤流程：
1. 定义外层循环的条件变量 i = 0
2. 外层while 条件(i < 5)：
    3. 内循环处理(先空着，不处理)
    4. 单独打印空行
    5. 外层循环的条件变量改变

内层 while 步骤流程：第1次打印1个星，第2次打印2个星，如此内推
3.1 定义内层循环条件变量 j = 0
3.2 内层循环 while j < i+1:
    3.3 打印一个星星，end=''作用指定不换号打印
    3.4 内层循环的条件变量改变
"""

实现：

# 1. 定义外层循环的条件变量 i = 0
i = 0

# 2. 外层 while 条件(i < 5)：
while i < 5:
    # 3. 内循环处理：第1次打印1个星，第2次打印2个星，如此内推
    # 3.1 设置条件变量j = 0
    j = 0
    # 3.2 内层循环 while j < i+1:
    while j < i + 1:
        # 3.3 打印一个星星，end=''作用指定不换行打印
        print('* ', end='')

        # 3.4 内层循环的条件变量改变
        j += 1

    # 4. 单独打印空行
    print()
    # 5. 外层循环的条件变量改变
    i += 1

3. break、continue和循环的else

3.1 break

1. 简介

• 在循环过程中，如果某一个条件满足后，不希望循环继续执行，可以使用break跳出循环

2. 作用

• 跳出循环，不再执行循环体中后续重复的代码

2. 应用

需求：跑步10圈，跑5圈后，不再跑了
思路：

"""
步骤流程：
1. 定义一个条件变量，一般赋值为0
2. while 判断条件：
    3. 满足条件的循环代码块
    4. if 满足条件：
        4.1 打印提示信息：累了，结束战斗
        4.2 break跳出循环
    5. 条件变量的改变【非常重要】
"""

实现：

# 1. 定义一个条件变量，一般赋值为0
i = 0

# 2. while 判断条件：
while i < 10:
    # 3. 满足条件的循环代码块
    print('跑步第%d圈' % (i+1))

    # 4. if 满足条件：
    if i == 4:
        # 4.1 打印提示信息
        print('累了，结束战斗')
        # 4.2 break跳出循环
        break

    # 5. 条件变量的改变【非常重要】
    i += 1

print('循环的外面')

运行结果

跑步第1圈
跑步第2圈
跑步第3圈
跑步第4圈
跑步第5圈
累了，结束战斗
循环的外面

3.2 continue

1. 简介

• 在循环过程中，如果某一个条件满足后，不希望执行本次循环代码（跳过本次循环），但可进入下一次循环判断，可以使用 continue

2. 作用

• 跳过循环，不再执行本次循环体中后续重复的代码，但进入下一次循环判断

2. 应用

需求：跑步10圈，到第5圈休息一下，第6圈继续
思路：

"""
步骤流程：
1. 定义一个条件变量，一般赋值为0
2. while 判断条件：
    3. if 满足条件：
        3.1 打印：累了，休息1圈
        3.2 条件变量的改变【非常重要】，如果没有，导致死循环
        3.3 continue跳过本次循环

    4. 打印跑步第几圈
    5. 条件变量的改变【非常重要】
"""

实现：

# 1. 定义一个条件变量，一般赋值为0
i = 0

# 2. while 判断条件：
while i < 10:
    # 3. if 满足条件：
    if i == 4:
        # 3.1 打印：累了，休息1圈
        print('累了，休息1圈')
        # 3.2 条件变量的改变【非常重要】，如果没有，导致死循环
        i += 1
        # 3.3 continue跳过本次循环
        continue

    # 4. 打印跑步第几圈
    print('跑步第%d圈' % (i+1))

    # 5. 条件变量的改变【非常重要】
    i += 1

print('循环的外面')

• 需要注意：使用continue时，条件处理部分的代码，需要特别注意，不小心会出现死循环

运行结果：

跑步第1圈
跑步第2圈
跑步第3圈
跑步第4圈
累了，休息1圈
跑步第6圈
跑步第7圈
跑步第8圈
跑步第9圈
跑步第10圈
循环的外面

3.3 区别

相同点：

• break 和 continue 是专门在循环中使用的关键字
• break/continue只能用在循环中，除此以外不能单独使用
• break/continue在嵌套循环中，只对最近的一层循环起作用(就近原则)
• 不同点：
• break 跳出循环，不再执行循环体中后续重复的代码
• continue 跳过循环，不再执行本次循环体中后续重复的代码，但进入下一次循环判断

3.4 循环的else

1. 简介

• 循环也可以支持else使用

2. 执行流程

• 循环里面没有遇到break语句，while执行完后，则会执行else的分支

3. 应用

i = 0
while i < 5:
    print('跑步第%d圈' % (i+1))
    # 测试有break，和没有break的else执行情况
    # if i == 3:
    #     break

    i += 1
else:
    print('循环里面没有遇到break语句，while执行完后，则会执行else的分支')

运行结果：

跑步第1圈
跑步第2圈
跑步第3圈
跑步第4圈
跑步第5圈
循环里面没有遇到break语句，while执行完后，则会执行else的分支

4. if…else 和 循环 else 的区别

• if…else：
  • 不满足if条件的前提下，执行else操作
  • 两者只会执行一个分支
• 循环 else：
  • 循环里面没有遇到break语句，while执行完后，则会执行else的分支
  • 也就是说，没有遇到break，不仅会执行while的语句，也会执行else的语句