Python学习笔记02

第三章、Python判断语句

前言

进行逻辑判断，是生活中常见的行为。同样，在程序中，进行逻辑判断也是最为基础的功能。

如果 → 判断 → 是 → ...

                      → 否 → ...

布尔类型和比较运算符

布尔类型

进行判断，只有2个结果：

• 是
• 否

如果 → 判断 → 是 → ...

                     → 否 → ...

程序中，如何描述：是或否呢？

使用：布尔类型

Python中常用的有6种值（数据）的类型

类型                           描述                          说明

数字（Number)     支持 整数（int）            整数（int） 如：10、-10

                               浮点数（float）             浮点数（float），如：13.14、-13.14

                              复数（complex)             复数（complex），如：4+3j，以结尾表示复数

                                 布尔（bool)                 布尔（bool）表达现实生活中的逻辑，即真和假；True表示真，False表示假。True本质上是一个数字记作1，False记作0。

字符串（String)   描述文本的一种数据类型  字符串(string)由任意数量的字符组成

列表（List）         有序的可变序列               Python中使用最频繁的数据类型，可有序记录一堆数据

元组（Tuple)         有序的不可变序列           可有序记录一堆不可变的Python数据集合

集合（Set)             无序不重复集合              可无序记录一堆不重复的Python数据集合

字典（Dictionary）无序Key-Value集合         可无序记录一堆Key-Value型的Python数据集合

布尔类型的定义

布尔类型的字面量：

• True 表示真(是、肯定)
• False 表示假(否、否定)

定义变量存储布尔类型数据： 变量名称 = 布尔类型字面量

布尔类型不仅可以自行定义，同时也可以通过计算得来。也就是使用比较运算符进行比较运算得到布尔类型的结果。

比较运算符

布尔类型的数据，不仅可以通过定义得到，也可以通过比较运算符进行内容比较得到。

如下代码：

result = 10 > 5

print(f"10 > 5的结果是：{result}，类型是：{type(result)}")

输出结果：10 >5 的结果是：True 类型是：

result = "itcast" == "itheima"

print(f"字符串itcast是否和itheima相等，结果是：{result}，类型是：{type(result)}")

输出结果：字符串itcast是否和itheima相等，结果是： False， 类型是：

运算符                描述                                                                             示例

==    判断内容是否相等，满足为True，不满足为False                        如a=3，b=3，则(a==b)为True

!=    判断内容是否不相等，满足为True，不满足为False                      如a=1，b=3，则(a!=b)为True

>     判断运算符左侧内容是否大于右侧满足为True，不满足为False   如a=7，b=3，则(a>b)为True

<     判断运算符左侧内容是否小于右侧满足为True，不满足为False    如a=3，b=7，则(a<b)为True

>=    判断运算符左侧内容是否大于等于右侧满足为True，不满足为False  如a=3，b=3，则(a>=b)为True

<=   判断运算符右侧内容是否小于等于右侧满足为True，不满足为False   如a=3，b=3，则(a<=b)为True

总结

1.在Python中，可以表示真假的数据类型是：

布尔类型，字面量True表示真，字面量False表示假

2.除了可以定义布尔类型外，还可以通过___计算得到布尔类型？

通过计算得到布尔类型的结果

• ==判断是否相等，!=判断是否不相等
• >判断是否大于，
• >=判断是否大于等于，

if语句的基本格式

if判断语句

生活中的判断：

如果 → 动作

程序中的判断：

if 要判断的条件：

    条件成立时，要做的事情

# 定义变量

age = 30

# 进行判断

if age >= 18:

    print("我已经成年了")

age = 18

print(f"今年我已经{age}岁了")

if age >= 18:

    print("我已经成年了") 当if判断条件结果为True时，代码会被执行；为False时，代码不会执行。

    print("即将步入大学生活")

print("时间过的真快")

当age为18时，执行结果：

今年我已经18岁了

我已经成年了

即将步入大学生活

时间过的真快

当age为10时，执行结果：

今年我已经10岁了

时间过的真快

if语句的注意点

if age >= 18: → 这个冒号不要忘记

    print("我已经成年了")

    print("即将步入大学生活")

归属于if判断的代码语句块，需在前方填充4个空格缩进

Python通过缩进判断代码块的归属关系。

总结

1.if语句的基本格式

if 要判断的条件：

    条件成立时，要做的事情

2.if语句的注意事项：

• 判断条件的结果一定要是布尔类型
• 不要忘记判断条件后的：冒号
• 归属于if语句的代码块，需在前方填充4个空格缩进

练习

练习案例：成年人判断

结合前面学习的input输入语句，完成如下案例：

1.通过input语句，获取键盘输入，为变量age赋值。（注意转换成数字类型）

2.通过if判断是否是成年人，满足条件则输出提示信息，如下：

• 欢迎来到黑马儿童游乐场，儿童免费，成人收费。
• 请输入你的年龄：30
• 您已成年，游玩需要补票10元。
• 祝您游玩愉快。

提示：您已成年，需要补票的信息输出，来自if判断

参考代码：

print("欢迎来到黑马儿童游乐园，儿童免费，成人收费")

age =int(input("请输入你的年龄："))

if age >= 18:

    print("您已成年，游玩需要补票10元。")

print("祝您游戏愉快。")

if else 语句

if满足条件会执行相应的代码语句，如果不满足呢？有没有不满足的情况下，可供执行的代码呢？

if else语句可以实现

if else 语句

生活中的判断：

如果 → 动作

否则 → 动作

程序中的判断：

if条件:

    满足条件时要做的事情1

    满足条件时要做的事情2

    满足条件时要做的事情3 ...（省略）...

else:

    不满足条件时要做的事情1

    不满足条件时要做的事情2

    不满足条件时要做的事情3

...（省略）...

例：

print(”欢迎来到黑马儿童游乐场，儿童免费，成人收费。")

age =int(input("请输入你的年龄："))

if age >= 18:

    print("您已成年，游玩需要补票10元。") 条件成立时执行

else:

    print("您未成年，可以免费游玩。")     条件不成立时执行

print("祝您游玩愉快。")

if else语句注意点

else:

else，不需要判断条件

print("您未成年，可以免费游玩。")

同样需要4个空格，作为代码的缩进哦

1.else后，不需要判断条件

2.和if的代码块一样，else的代码块同样需要4个空格作为缩进

总结

1.if else 语句，其中

• if和其代码块，条件满足时执行
• else搭配if的判断条件，当不满足的时候执行

2.if else语句的注意事项：

• else不需要判断条件，当if的条件不满足时，else执行
• else的代码块，同样要4个空格作为缩进

练习

练习案例： 我要买票吗

通过input语句获取键盘输入的身高

判断身高是否超过120cm，并通过print给出提示信息。

欢迎来到黑马动物园。

请输入你的身高(cm)：130

您的身高超出120cm，游玩需要够票10元。

祝您游玩愉快。

欢迎来到黑马动物园。

请输入你的身高(cm)：111

您的身高未超出120cm，可以免费游玩。

祝您游玩愉快。

参考代码：

height = int(input("请输入你的身高(cm)："))

if height > 120:

    print("您的身高超出120CM，需要买票，10元。")

else: print("您的身高未超出120CM，可以免费游玩。")

    print("祝您游玩愉快")

if elif else语句

某些场景下，判断条件不止一个，可能有多个。这种需求能用Python实现吗？

if elif else语句可以实现

if elif else语句

生活中的判断：

如果1 → 动作

如果2 → 动作

如果N → 动作

否则 → 动作

程序中的判断：

if 条件1:

    条件1满足应做的事情

    条件1满足应做的事情

    ......

elif 条件2:

    条件2满足应做的事情

    条件2满足应做的事情

    ......

elif 条件N:

    条件N满足应做的事情

    条件N满足应做的事情

    ......

else:

    所有条件都不满足应做的事情

    所有条件都不满足应做的事情

    ......

例：

print("欢迎来到黑马动物园。")

height = int(input("请输入你的身高(cm)："))

vip_level = int(input("请输入你的vip级别(1~5)："))

if height < 120:

     print("您的身高小于120CM，可以免费游玩。")

elif vip_level > 3:

    print("您的vip级别大于3，可以免费游玩。")

else:

    print("不好意思，所有条件都不满足，需要购票10元。")

print("祝您游玩愉快。")

if elif else语句注意点

判断是互斥且有顺序的。

• 满足条件1将不会理会条件2和条件3
• 满足条件2，将不会理会条件3
• 条件1、条件2、条件3均不满足，进入else
• else也可以省略不写，效果等同于独立的if判断

elif语句可以写多个。

空格缩进同样不可省略

print("欢迎来到黑马动物园。")

if int(input("请输入你的身高(cm)：")) < 120:

    print("您的身高小于120CM，可以免费游玩。")

elif int(input("请输入你的vip级别(1~5)：")) > 3:

    print("您的vip级别大于3，可以免费游玩。")

elif int(input("请输入今天的日期(1~30): ")) == 1:

    print("今天是1号免费日，可以免费游玩。")

else:

    print("不好意思，所有条件都不满足，需要购票10元。")

print("祝您游玩愉快。")

可以将input输入语句直接写入判断条件中，节省代码量。

总结

1. if elif else语句的作用是？

可以完成多个条件的判断

2.使用if elif else的注意点有：

• elif可以写多个
• 判断是互斥且有序的，上一个满足后面的就不会判断了
• 可以在条件判断中，直接写input语句，节省代码量

练习

练习案例：猜猜心里数字

1. 定义一个变量，数字类型，内容随意。
2. 基于input语句输入猜想的数字，通过if和多次elif的组合，判断猜想数字是否和心里数字一致。

请输入第一次猜想的数字：1

不对，再猜一次：2

不对，再猜最后一次：3

Sorry，全部猜错啦，我想的是：10

参考代码：

num = 5

if int(input("请输入第一次猜想的数字：")) == num:

    print("恭喜，第一次就猜对了")

elif int(input("不对，再猜一次：")) == num:

    print("恭喜，猜对了")

elif int(input("不对，再猜最后一次：")) == num:

    print("恭喜，最后一次机会你猜对了")

else:

    print(f"Sorry，全部猜错了，我想的是：{num}")

判断语句的嵌套

有很多场景，不仅仅是多个并列条件，还会有满足前置条件才会二次判断的多层判断需求。

对这种需求嵌套判断语句可以实现

许多逻辑的判断，是嵌套的，多层次的。

对于这种需求，我们可以：自由组合 if elif else，完成特定需求的要求

基础语法格式如下：

if 条件1：

    满足条件1 做的事情1

    满足条件1 做的事情2

if 条件2：

    满足条件2 做的事情1

    满足条件2 做的事情2

如上图，第二个if，属于第一个if内，只有第一个if满足条件，才会执行第二个if

嵌套的关键点，在于：空格缩进

通过空格缩进，来决定语句之间的：层次关系

简单嵌套：

print("欢迎来到黑马动物园。")

if int(input("请输入你的身高：")) > 120:              1

    print("你的身高大于120cm，不可以免费。")

    print("不过如果你的VIP等级高于3，可以免费游玩。")

    if int(input("请告诉我你的VIP级别：")) > 3:     2

        print("恭喜你，你的VIP级别大于3，可以免费游玩。")

    else:

        print("Sorry，你需要补票，10元。")

else:

    print("欢迎你小朋友，可以免费游玩。")

如上图所示：

• 判断有2层
• 当外层if满足条件（图中编号1）时，才会执行内层if判断(图中编号2)
• 当外层if(编号1)不满足，直接执行外层esle

举例

自由组合嵌套，需求如下：

公司要发礼物，条件是：

1.必须是大于等于18岁小于30岁的成年人

2.同时入职时间需满足大于两年，或者级别大于3才可领取

age =

year =

level =

if age >= 18:

    print("成年人符合，继续判断")

    if age < 30:

        print("年龄达标继续判断")

        if year > 2:

            print("小于30岁的成年人且入职超过2年，满足条件，可以领取")

        else:

            print("Sorry，年龄符合，但入职时间不足")

    elif level > 3:

        print("级别大于3的成年人可直接领取礼物")

    else:

        print("您的年龄过大或级别小于等于3，不可领取")

else:

    print("Sorry，未成年不可领取礼物")

如上图所示：

• if elif else可以自由组合
• 满足缩进的要求即可

总结

1.嵌套判断语句可以用于多条件、多层次的逻辑判断总结

2.嵌套判断语句可以根据需求，自由组合if elif else来构建多层次判断

3.嵌套判断语句，一定要注意空格缩进，Python通过空格缩进来决定层次关系

实战案例

案例需求：

定义一个数字(1~10，随机产生)，通过3次判断来猜出来数字

案例要求：

1. 数字随机产生，范围1-10

2. 有3次机会猜测数字，通过3层嵌套判断实现

3. 每次猜不中，会提示大了或小了

提示，通过如下代码，可以定义一个变量num，变量内存储随机数字。

import random

num = random.randint(1，10)

import random

num = random.randint(1,10)

guess_num = int(input("输入你要猜测的数字："))

if guess_num == num:

    print("恭喜，第一次就猜中了")

else:

    if guess_num > num:

        print("你猜测的数字大了")

    else:

        print("你猜测的数字小了")

    guess_num = int(input("再次输入你要猜测的数字："))

    if guess_num == num:

        print("恭喜，第二次时猜中了")

    else:

        if guess_num > num:

            print("你猜测的数字大了")

        else:

            print("你猜测的数字小了")

        guess_num = int(input("第三次输入你要猜测的数字："))

        if guess_num == num:

            print("第三次猜中了")

        else:

            print("三次机会用完了，没有猜中。")

第四章、Python循环语句

前言

循环普遍存在于日常生活中，同样，在程序中，循环功能也是至关重要的基础功能。

为什么学习循环语句

循环在程序中同判断一样，也是广泛存在的，是非常多功能实现的基础：

循环广告牌 批量修图 视频轮播 音乐轮播 图片轮播 大喇叭喊话 动态壁纸 视频监控......

循环同样是程序最基础，最核心的逻辑功能

while循环的基础语法

while循环语句

生活中的循环：

每天都去向小美表白，直到成功为止

程序中的循环：

while 条件：

   条件满足时，做的事情1

   条件满足时，做的事情2

   条件满足时，做的事情3

   ...(省略)...

只要条件满足，会无限循环执行

程序中的while循环

小美心软，只要表白100次，就会成功

print("小美，我喜欢你”)

print("小美，我喜欢你”)

print("小美，我喜欢你”)

...(还有97次)...

使用循环语句简单搞定：

i = 0

while i < 100:

    print("小美，我喜欢你")

    i += 1            # 当您写下 i += 1 时，这意味着将变量 i 的值增加 1。这是 Python 中的一种简写形式，等同于 i = i + 1。这种语法称为增量赋值操作符，用于增加变量的值。

while循环注意点

1. while的条件需得到布尔类型，True表示继续循环，False表示结束循环
2. 需要设置循环终止的条件，如i+=1配合i
3. 空格缩进和if判断一样，都需要设置

总结

1. while循环的语法格式

while 条件：

条件满足时，做的事情1

条件满足时，做的事情2

条件满足时，做的事情3

...(省略)...

2. while循环的注意事项

• 条件需提供布尔类型结果、True继续，False停止
• 空格缩进不能忘
• 请规划好循环终止条件，否则将无限循环

练习

练习案例：求1-100的和

需求：通过while循环，计算从1累加到100的和

提示：

1. 终止条件不要忘记，设置为确保while循环100次
2. 确保累加的数字，从1开始，到100结束

sum = 0

i = 1

while i <= 100:

    sum += i

    i += 1

print(f"1-100累加的和是：{sum}")

while循环的基础案例

猜数字案例

设置一个范围1-100的随机整数变量通过while循环，配合input语句，判断输入的数字是否等于随机数

• 无限次机会，直到猜中为止
• 每一次猜不中，会提示大了或小了
• 猜完数字后，提示猜了几次

提示：

无限次机会，终止条件不适合用数字累加来判断，可以考虑布尔类型本身(True or False)

需要提示几次猜中，就需要提供数字累加功能

随机数可以使用：

import random

num = random.randint(1，100)

参考代码：

# 获取范围在1-100的随机数字

import random

num = random.randint(1, 100)

# 定义一个变量，记录总共猜测了多少次

count = 0

# 通过一个布尔类型的变量，做循环是否继续的标记

flag = True

while flag:

    guess_num = int(input("请输入你猜测的数字："))

    count += 1

     if guess_num == num:

        print("猜中了")

        # 设置为False就是终止循环的条件

        flag = False

    else:

        if guess_num > num:

            print("你猜的大了")

        else:

            print("你猜的小了")

print(f"你总共猜测了 {count} 次")

while循环的嵌套应用

while循环的嵌套

生活中的嵌套循环 ：

每天都去向小美表白，直到成功为止

每次表白的流程是：送10朵玫瑰然后表白

程序中的循环：

while条件1：

    条件1满足时，做的事情1

    条件1满足时，做的事情2

    条件1满足时，做的事情3

    ...(省略)...

    while 条件2:

        条件2满足时，做的事情1

        条件2满足时，做的事情2

        条件2满足时，做的事情3

        ...(省略)...

循环内套循环

例：表白100天，每一天都会送10朵玫瑰花

i = 1

while i <= 100:

    print(f"今天是第{i}天，准备表白.")

    j = 1

    while j <= 10:

        print(f"送给小美第{j}只玫瑰花")

        j += 1

    print("小美，我喜欢你")

    i += 1

print(f"坚持到第{i-1}天，表白成功")

while循环的嵌套-注意点

• 同判断语句的嵌套一样，循环语句的嵌套，要注意空格缩进。
• 基于空格缩进来决定层次关系
• 注意条件的设置，避免出现无限循环(除非真的需要无限循环)

总结

1.嵌套循环的语法格式：

while 条件1：

    条件1满足时，做的事情1

    条件1满足时，做的事情2

    条件1满足时，做的事情3

    ...(省略)...

    while 条件2：

        条件2满足时，做的事情1

        条件2满足时，做的事情2

        条件2满足时，做的事情3

        ...(省略)...

2.嵌套循环需要注意的地方：

• 注意条件的控制，避免无限循环
• 多层嵌套，主要空格缩进来确定层次关系

3.嵌套循环的使用难点：

循环条件的控制，层次越多越复杂，需要细心+耐心

while循环的嵌套案例

补充知识-print输出不换行

默认print语句输出内容会自动换行

print("Hello")

print("World")

输出结果：

Hello

World

在即将完成的案例中，我们需要使用print语句，输出不换行的功能，非常简单，实现方式如下：

print("Hello"，end=' ')

print("World"，end=' ')

输出结果：

HelloWorld

在print语句中，加上end=”即可输出不换行了

注意：end=' '是使用的方法传参功能，我们在后面会详细讲解。

补充知识-制表符\t

在字符串中，有一个特殊符号：\t，效果等同于在键盘上按下：tab键。它可以让我们的多行字符串进行对齐。

print("Hello World"

print("itheima best") 使用空格无法对齐

print("Hello\tWorld")

print("itheima\tbest") 使用\t后，可以对齐

输出结果：

Hello World

itheima best

Hello World

itheima best

案例

练习案例-打印九九乘法表

通过while循环，输出如下九九乘法表内容

1*1=1

1*2=2 2*2=4

1*3=3 2*3=6 3*3=9

1*4=4 2*4=8 3*4=12 4*4=16

1*5=5 2*5=10 3*5=15 4*5=20 5*5=25

1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36

1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49

1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64

1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

参考代码：

# 定义外层循环的控制变量

i = 1

while i <= 9:

    # 定义内层循环的控制变量

    j = 1

    while j <= i:

        # 内层循环的 print 语句, 不要换行，通过 \t 制表符进行对齐

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

        j += 1

    i += 1

    print() # print空内容，就是输出一个换行

for循环的基础语法

基础语法

for循环

除了while循环语句外，Python同样提供了for循环语句。两者能完成的功能基本差不多，但仍有一些区别：

• while循环的循环条件是自定义的，自行控制循环条件
• for循环是一种“ 轮询 ”机制，是对一批内容进行“ 逐个处理 ”

for循环就是将“ 待办事项 ”逐个完成的循环机制

for循环语句

生活中的for循环:

• 洗碗，一个个洗干净
• 剥蒜，一个个剥干净
• 送快递，一个个送达
• 吃瓜子，一个个吃下
• ......，一个个完成

程序中的for循环:

for 临时变量 in 待处理数据集：

    循环满足条件时执行的代码

从待处理数据集中：逐个取出数据赋值给临时变量

遍历字符串

# 定义字符串name

name = "itheima"

# for循环处理字符串

for x in name:

    print(x)

可以看出，for循环是将字符串的内容：依次取出。所以，for循环也被称之为：遍历循环

运行结果如下：

i

t

h

e

i

m

a

for循环注意点

同while循环不同，for循环是无法定义循环条件的。

只能从被处理的数据集中，依次取出内容进行处理。

所以，理论上讲，Python的for循环无法构建无限循环(被处理的数据集不可能无限大)

总结

1.for循环的语法格式是：

for 临时变量 in 待处理数据集（序列）：

    循环满足条件时执行的代码

2.for循环的注意点

• 无法定义循环条件，只能被动取出数据处理
• 要注意，循环内的语句，需要有空格缩进

练习

练习案例：数一数有几个a

定义字符串变量name，内容为："itheima is a brand of itcast"

通过for循环，遍历此字符串，统计有多少个英文字母：“a”

输出结果为：itheima is a brand of itcast中共含有：4个字母a

提示：

1. 计数可以在循环外定义一个整数类型变量用来做累加计数
2. 判断是否为字母"a"，可以通过if语句结合比较运算符来完成

参考代码：

# 统计如下字符串中，有多少个字母 a

name = "itheima is a brand ofitcast"

# 定义一个变量，用来统计有多少个 a

count = 0 # for 循环统计

# for 临时变量 in 被统计的数据

for x in name:

    if x == "a":

        count += 1

print(f"{name}中有 {count} 个 'a'")

range语句

range语句

for 临时变量 in 待处理数据集：

    循环满足条件时执行的代码

语法中的：待处理数据集，严格来说，称之为：序列类型

序列类型指，其内容可以一个个依次取出的一种类型，包括：

• 字符串
• 列表
• 元组
• 等

目前我们只学习了字符串类型，其余类型在后续章节会详细学习它们

for循环语句，本质上是遍历：序列类型。

尽管除字符串外，其它的序列类型目前没学习到，但是不妨碍我们通过学习range语句，获得一个简单的数字序列。

语法1：

range(num)

获取一个从0开始，到num结束的数字序列(不含num本身)

如range(5)取得的数据是：[0, 1, 2, 3, 4]

语法2：

range(num1,num2)

获得一个从num1开始，到num2结束的数字序列(不含num2本身)

如，range(5，10)取得的数据是：[5, 6, 7, 8, 9]

语法3：

range(num1,num2，step)

获得一个从num1开始，到num2结束的数字序列(不含num2本身)数字之间的步长，以step为准(step默认为1)

如，range(5，10，2)取得的数据是：[5，7，9]

总结

1.range语句的功能是：

获得一个数字序列

2.range语句的语法格式：

语法1：range(num)

总结 语法2：range(num1，num2)

语法3：range(num1，num2，step)

3.range语句的注意事项：

• 语法1从0开始，到num结束(不含num本身)
• 语法2从num1开始，到num2结束(不含num2本身)
• 语法3从num1开始，到num2结束(不含num2本身)，步长以step值为准

range的用途很多，多数用在for循环场景

练习

练习案例：有几个偶数

定义一个数字变量num，内容随意

并使用range()语句，获取1到num的序列，使用for循环遍历它。在遍历的过程中，统计有多少偶数出现

输出结果：1到100(不含100本身)范围内，有49个偶数。

提示：

1. 序列可以使用：range(1,num)得到
2. 偶数通过if来判断，判断数字余2是否为0即可

num = 100

count_even = 0

for i in range(1, num):

    if i % 2 == 0:

         count_even += 1

print(f"1到{num}（不包含{num}本身）有{count_even}个偶数")

变量作用域

思考:

for i in range(5):

    print(i)

print(i)

如图代码，思考一下：

第四行的print语句，能否访问到变量i？

规范上：不允许

实际上：可以

for循环的变量作用域

for 临时变量 in 待处理数据集：

    循环满足条件时执行的代码

回看for循环的语法，我们会发现，将从数据集(序列)中取出的数据赋值给：临时变量

为什么是临时的呢？

临时变量，在编程规范上，作用范围(作用域)，只限定在for循环内部

如果在for循环外部访问临时变量：

• 实际上是可以访问到的
• 在编程规范上，是不允许、不建议这么做的

总结

1.for循环中的临时变量，其作用域限定为：

循环内

2.这种限定：

• 是编程规范的限定，而非强制限定
• 不遵守也能正常运行，但是不建议这样做
• 如需访问临时变量，可以预先在循环外定义它

for循环的嵌套应用

for循环的嵌套

同while一样，for循环也支持嵌套使用

生活中的嵌套循环：

每天都去向小美表白直到成功为止

每次表白的流程是：送10朵玫瑰然后表白

程序中的嵌套for循环：

for 临时变量 in 待处理数据集(序列)：

    循环满足条件应做的事情1

    循环满足条件应做的事情2

    循环满足条件应做的事情

     ...

    for 临时变量 in 待处理数据集(序列)：

        循环满足条件应做的事情1

        循环满足条件应做的事情 2

         循环满足条件应做的事情N

        ...

同样以向小美表白的案例为例

• 坚持表白100天
• 每天送花10束

i = 1

for i in range(1, 101):

    print(f"今天是向小美表白的第{i}天，坚持。")

    for j in range(1, 11):

        print(f"送给小美的第{j}朵玫瑰花")

    print(f"小美，我喜欢你，第{i}天的表白结束。")

print(f"第{i}天，表白成功。")

表白100天每一天都会送10朵玫瑰花

for循环的嵌套注意点

和while循环一样，需要注意缩进因为通过缩进，确定层次关系

我们目前学习了2个循环，while循环和for循环。

这两类循环语句是可以相互嵌套的，如下，小美表白的案例可以改为：

i = 1

for i in range(1, 101):

    print(f"今天是向小美表白的第{i}天，坚持。")

    j = 1

    while j <= 10:

        print(f"送给小美的第{j}朵玫瑰花")

        j += 1

    print(f"小美，我喜欢你，第{i}天的表白结束。")

print(f"表白第{i}天，表白成功。")

i = 1

while i <= 100:

    print(f"今天是向小美表白的第{i}天，坚持。")

    for j in range(1, 11):

        print(f"送给小美的第{j}朵玫瑰花")

    print(f"小美，我喜欢你，第{i}天的表白结束。")

    i += 1

print(f"表白第{i - 1}天，表白成功。")

总结

1.for循环的嵌套语法：

for循环或 while循环：

循环满足条件应做的事情1

循环满足条件应做的事情2

循环满足条件应做的事情N

···

for循环或while循环：

    循环满足条件应做的事情1

    循环满足条件应做的事情2

    循环满足条件应做的事情N

2.注意事项：

• 需要注意缩进，嵌套for循环同样通过缩进确定层次关系
• for循环和while循环可以相互嵌套使用

案例

练习案例-for循环打印九九乘法表

通过for循环，输出如下九九乘法表内容

1*1=1

1*2=2 2*2=4

1*3=3 2*3=6 3*3=9

1*4=4 2*4=8 3*4=12 4*4=16

1*5=5 2*5=10 3*5=15 4*5=20 5*5=25

1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36

1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49

1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64

1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

参考代码：

# 通过外层循环控制行数

for i in range(1, 10):

    # 通过内层循环控制每一行的数据

    for j in range(1, i+1):

        # 在内层循环中输出每一行的内容

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

    # 外层循环可以通过 print 输出一个回车符

    print()

循环中断：break和continue

思考：无论是while循环或是for循环，都是重复性的执行特定操作。在这个重复的过程中，会出现一些其它情况让我们不得不：

• 暂时跳过某次循环，直接进行下一次
• 提前退出循环，不在继续

对于这种场景，Python提供continue和break关键字

用以对循环进行临时跳过和直接结束

continue

continue关键字用于：中断本次循环，直接进入下一次循环

continue可以用于： for循环和while循环，效果一致

例：

for i in range(1,100):

    语句1

    continue

    语句2

上述代码，在循环内，遇到continue就结束当次循环，进行下一次。所以，语句2是不会执行的。

应用场景：在循环中，因某些原因，临时结束本次循环。

continue在嵌套循环中的应用

continue关键字只可以控制：它所在的循环临时中断

for i in range(1,3):

    print("语句1")

    for j in range(1,3):

        print("语句 2")

        continue

        print("语句3")

    print("语句4")

输出结果：

语句1

语句 2

语句 2

语句4

语句1

语句 2

语句 2

语句4

break

break关键字用于：直接结束循环

break可以用于： for循环和while循环，效果一致

例：

fori in range(1,100):

    语句 1

    break

    语句 2

语句3

上述代码：在循环内，遇到break就结束循环了。所以，执行了语句1后，直接执行语句3了

break在嵌套循环中的应用

break关键字同样只可以控制：它所在的循环结束

for i in range(1， 3):

    print("语句1")

    for j in range(1， 3)：

        print("语句2")

        break

        print("语句3")

    print("语句4")

输出结果：

语句1

语句2

语句4

语句1

语句2

语句4

总结

1.continue的作用是：

中断所在循环的当次执行，直接进入下一次

2.break的作用是：

直接结束所在的循环

3.注意事项：

• continue和break，在for和while循环中作用一致
• 在嵌套循环中，只能作用在所在的循环上，无法对上层循环起作用

综合案例

案例

练习案例：发工资

某公司，账户余额有1W元，给20名员工发工资。

• 员工编号从1到20，从编号1开始，依次领取工资，每人可领取1000元
• 领工资时，财务判断员工的绩效分(1-10)(随机生成)，如果低于5，不发工资，换下一位
• 如果工资发完了，结束发工资。

示例输出：

员工12，绩效分3，低于5，不发工资，下一位。

员工13，绩效分1，低于5，不发工资，下一位。

员工14，绩效分4，低于5，不发工资，下一位。

向员工15发放工资1000元，账户余额还剩余2000元

向员工16发放工资1000元，账户余额还剩余1000元

员工17，绩效分2，低于5，不发工资，下一位。

向员工18发放工资1000元，账户余额还剩余0元

工资发完了，下个月领取吧。

提示：

使用循环对员工依次发放工资

continue用于跳过员工，break直接结束发工资

随机数可以用：

import random

num =random.randint(1. 10)

参考代码：

money = 10000

# for循环对员工发放工资

for i in range(1, 21):

    import random

    score = random.randint(1, 10)

    if score < 5:

        # 不满足条件，不发工资，进入下一位员工

        print(f"员工{i}，绩效分{score}，不满足条件，不发工资，进入下一位")

        continue

    # 要判断余额是否足够

    if money >= 1000:

        money -= 1000

        print(f"员工{i}，满足条件发放工资1000，公司账户余额：{money}元")

    else:

        print(f"余额不足，当前余额：{money}元，不足以发工资，不发了，下个月再来")

        # 结束发放

        break