CAIJINBO

python基础02-选择和循环语句

2020-07-26python

选择和循环语句

一、比较和逻辑运算符

1. 比较(即关系，条件)运算符

运算符 描述 示例
== 检查两个操作数的值是否相等，如果是则条件变为真。 如a=3,b=3，则（a == b) 为 True
!= 检查两个操作数的值是否相等，如果值不相等，则条件变为真。 如a=1,b=3，则(a != b) 为 True
> 检查左操作数的值是否大于右操作数的值，如果是，则条件成立。 如a=7,b=3，则(a > b) 为 True
< 检查左操作数的值是否小于右操作数的值，如果是，则条件成立。 如a=7,b=3，则(a < b) 为 False
>= 检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立。 如a=3,b=3，则(a >= b) 为 True
<= 检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立。 如a=3,b=3，则(a <= b) 为 True

示例代码：

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. 逻辑运算符

运算符 逻辑表达式 描述 实例
and x and y 布尔”与”：如果 x 为 False，x and y 返回 False，否则它返回 y 的值。 True and False， 返回 False。
or x or y 布尔”或”：如果 x 是 True，它返回 True，否则它返回 y 的值。 False or True， 返回 True。
not not x 布尔”非”：如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 not True 返回 False, not False 返回 True

示例代码：

"""
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) )

二、if 语句的基本格式

1. if 选择语句基本格式

  • if 语句是用来进行选择判断的，其使用格式如下：
if 要判断的条件:
    条件满足时，要做的事情
    ……
  • 注意：
    • 判断的条件结果为 True 时，才会执行 if 里面的代码块
    • 代码的缩进为一个 tab 键，或者 4 个空格
    • 只要缩进一个 tab 键里面的代码，都属于 if 语句里面的代码块

2. 案例演练：选择年龄

需求

  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执行完毕

三、if-else 语句格式

1. else 处理条件不满足的情况

  • 思考：在使用 if 的时候，它只能做到满足条件时要做的事情。那万一需要在不满足条件的时候，做某些事，该怎么办呢？
  • 答：使用 if-else

2. if-else的语法格式

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. if 实现三目运算操作

  • 三目运算符：简洁版if-else语句

  • a if a > b else b
    • 如果 a > b的条件成立，三目运算的结果是a，否则就是b
# 需求：通过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)

四、if-elif-else 语句格式

1. if-elif-else 语句格式

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

语法格式如下:

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

说明:

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

2. 案例演练：女友的节日

需求

  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('每天都是节日啊……')

五、if 嵌套

1. if 嵌套应用场景

  • 坐火车或者地铁的实际情况是：
    • 先进行安检如果安检通过才会判断是否有车票，
    • 或者是先检查是否有车票之后才会进行安检
  • 即实际的情况某个判断是再另外一个判断成立的基础上进行的，这样的情况该怎样解决呢？
    • if 嵌套

2. if 嵌套的格式

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

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

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

# 条件 1 不满足的处理
else:
    条件1 不满足时，执行的代码
    ……
  • if 嵌套：if 里面包含 if
  • 满足外层if的条件，才执行判断内层的if

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('大哥，您要先买票啊')

应用：猜拳游戏

学习目标:

  • 强化 多个条件 的 逻辑运算
  • 体会 import 导⼊模块（“⼯具包”）的使⽤

1. 案例需求

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

2. 基础代码实现

"""
规则：石头 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('不行，我要和你决战到天亮！')

3. 随机数的产生

  • 在 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. 猜拳游戏完整代码

"""
规则：石头 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('不行，我要和你决战到天亮！')

六、while循环

1. while循环

1.1 while循环的格式

变量设置初始值

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

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

1.2 案例演练：循环跑步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.3 死循环

  • 条件永远为真的(True)循环即为死循环，也叫无限循环
while True:
    print('我会永远循环执行下去')

2. while循环的应用

2.1 计算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)

2.2 计算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)

3. debug调试

3.1 操作流程

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

七、while循环嵌套

1. while嵌套的格式

  • while 嵌套就是：while 里面还有 while
while 条件 1:
    条件满足时，做的事情1
    ...(省略)...

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

        处理条件 2

    处理条件 1
  • 步骤流程：先写外层的while，再写内层的while

2. 案例演练

需求：跑步 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

3. while嵌套应用

3.1 打印正方形

3.1.1 通过循环打印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

3.1.2 通过循环嵌套打印正方形

要求：打印如下图形

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

示例代码：

"""
外层 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

3.2 打印三角形

要求：打印如下图形：

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

示例代码：

"""
外层 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

八、break 、 continue和循环的else

1. break 和 continue的作用

break 和 continue 是专门在循环中使用的关键字

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

1.1 break

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

需求：跑步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圈
累了，结束战斗
循环的外面

1.2 continue

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

需求：跑步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圈
循环的外面

2. 循环的else

2.1 循环的else

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

示例代码：

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的分支

2.2 if…else 和 循环 else 的区别

  • if…else：
    • 不满足if条件的前提下，执行else操作
    • 两者只会执行一个分支
  • 循环 else：
    • 循环里面没有遇到break语句，while执行完后，则会执行else的分支
    • 也就是说，没有遇到break，不仅会执行while的语句，也会执行else的语句
本文作者：caijinbo
本文链接：https://caijinbo.work/2020/07/26/2020-07-27-python基础02-选择和循环语句/
版权声明：本博客所有文章除特殊声明外，均采用 CC BY-NC 4.0 许可协议。转载请注明出处 caijinbo的博客！
pyhon