黑马程序员最新Python教程——第一阶段（1）_黑马程序员python课件

Python导学

1. 本人是一名Python小白，希望和大家一起进入python的殿堂。以下笔记完全来源于黑马程序员最新Python教程，网站地址为(https://www.bilibili.com/video/BV1qW4y1a7fU?p=1&vd_source=9beb0a2f0cec6f01c2433a881b54152c)
2. 笔记配合视频效果更好
3. 外链图片上传失败已经解决，手动校正，如有错误和遗漏，可私信与评论进行指正，看到了会及时更改
4. 与各位共勉
5. 用来复习回顾使用

简洁高效与丰富的应用场景是Python的两大杀手锏（简洁高效），下图为JAVA与Python的对比。
由于简单高效，越来越多的人走向Python之路，进而 出现了丰富的第三方库，完善了整个Python的生态。
其次Python还有着非常吩咐的应用场景。

接下来介绍课程的安排，如下图：

我们的课程完全是基于Python3.10.4版本！！下面给出本课程的特点：

第一阶段——第一章

01-初识Python

为什么选择Python——优雅！优雅永不过时！

适用面广泛

人生苦短，我用Python

02-什么是编程语言

语言是进行沟通交流的表达方式，所以编程语言就是用于和计算机进行交流。计算机只认识01二进制编码，所以我们要把我们的语言通过引入翻译程序告诉计算机。

用于人类和计算机进行交流的一种语言，通过编写编程语言的代码，去指挥计算机工作。
它无法直接和计算机沟通，需要翻译工具（解释器或编译器）将代码翻译成二进制，从而实现和计算机的畅顺沟通。

关爱人工智障，人人有责

二进制如下：111001011011000010110001 111001101001110110100101 111010011011101110010001 111010011010100110101100 111001111010100010001011 111001011011101010001111 111001011001000110011000

03-Python环境安装

此部分建议跟随视频安装，这里就不放笔记了，这里我推荐下载PyCharm Community Edition ，可以去PyCharm 官网下载，pycharm安装教程，超详细，并且配置环境——Windows下PyCharm配置Anaconda环境教程。

04-Python环境安装（macOS）

macOS Python安装教程
本视频的链接跟随

05-Python环境安装（Linux）

Linux系统上安装python详细步骤
本视频的链接跟随

06-第一个Python程序-Hello World

向世界说你好，应该是全世界，所有程序员入门编程语言时，都会选择的第一-个程序。让我们也延续这一份来自程序员之间的浪漫，学习如何使用Python，向世界说你好。

if __name__ == '__main__':
#if __name__ == '__main__':的作用
# 一个python文件通常有两种使用方法
# 第一是作为脚本直接执行
# 第二是 import 到其他的 python 脚本中被调用（模块重用）执行。
# 因此 if __name__ == 'main': 的作用就是控制这两种情况执行代码的过程
# 在 if __name__ == 'main': 下的代码只有在第一种情况下（即文件作为脚本直接执行）才会被执行
# 而 import 到其他脚本中是不会被执行的。
    print('Hello World!!!')#注意中英文的符号！！！！！！！！！！！！！！！！！！！！！！！！
1
2
3
4
5
6
7
8
9

拓展：if name == ‘main’:的运行原理
每个python模块（python文件，也就是此处的 test.py 和 import_test.py）都包含内置的变量 name，当该模块被直接执行的时候，name 等于文件名（包含后缀 .py ）；如果该模块 import 到其他模块中，则该模块的 name 等于模块名称（不包含后缀.py）。

而 “main” 始终指当前执行模块的名称（包含后缀.py）。进而当模块被直接执行时，name == ‘main’ 结果为真。

07-第一个Python程序-练习讲解

if __name__ == '__main__':
#请在“命令提示符”(CMD) 程序内，通过Python,向屏幕上输出:
#零基础，学Python, 月薪过万，就来黑马程序员。
    print("零基础，学Python, 月薪过万，就来黑马程序员。")

1
2
3
4
5

08-第一个Python程序-常见问题

09-Python解释器

Python解释器，是一个计算机程序，用来翻译Python代码,并提交给计算机执行。所以，它的功能很简单，就2点:
1.翻译代码
2.提交给计算机运行

10-Pycharm开发工具安装与基础使用

详细查看03-Python环境安装

11-Pycharm扩展基础使用

通过快捷键设置字体大小



常用的快捷键：

第一阶段——第二章

01-字面量

子面量：在代码中，被写下来的的固定的值称之为字面量。

Python中常见的值类型：

字符串
字符串(string) ，又称文本，是由任意数量的字符如中文、英文、各类符号、数字等组成。所以叫做字符的串。

Python中，字符串需要用双引号(")包围起来。

if __name__ == '__main__':
    a = 666
    b = 3.14
    c = "零基础，学Python, 月薪过万，就来黑马程序员。"
    print(a)
    print(b)
    print(c)
    print(666)   #同样也是字面量
    print(3.14)  #同样也是字面量
    print("零基础，学Python, 月薪过万，就来黑马程序员。")  #同样也是字面量
1
2
3
4
5
6
7
8
9
10

02-注释

注释的作用

注释的分类

1. 单行注释：以#开头，#右边的所有文字当作说明，而不是真正要执行的程序，起辅助说明作用

if __name__ == '__main__':
    # 我是一个单行注释
1
2

3. 多行注释：以-对三个单双引号引起来(’ ’ ‘注释内容’ ’ ’ )(" " " 注释内容" " ")来解释说明一段代码的作用使用方法

if __name__ == '__main__':
    '''
    我
    是
    多
    行
    注
    释
    '''
1
2
3
4
5
6
7
8
9

注释是代码中的解释型语句，用来对代码内容进行注解。注释不是代码，不会被程序执行。

03-变量

什么是变量
变量：在程序运行时，能储存计算结果或能表示值的抽象概念。简单的说，变量就是在程序运行时，记录数据用的。

if __name__ == '__main__':
    a = 666
    print("钱包还有：",a,"元")
    print("买了一个冰激凌花费10元")
    a = a-10
    print("钱包还有：",a,"元")
    #格式：print（内容1，内容2，.....，内容N）用,隔开 一定是英文逗号！！！
1
2
3
4
5
6
7

04-数据类型

在学习字面量的时候，我们了解到：数据是有类型的。

目前在入门阶段，我们主要接触如下三类数据类型：

如何查看验证数据类型？

if __name__ == '__main__':
    a = 666
    b = type(a)
    print(type(666))
    print(type(a))
    print(b)
    print(type("a"))
    '''
    输出：
	<class 'int'>
	<class 'int'>
	<class 'int'>
	<class 'str'>
    '''
1
2
3
4
5
6
7
8
9
10
11
12
13
14

变量有类型吗？
我们通过type(变量)可以输出类型，这是查看变量的类型还是数据的类型?

查看的是：变量存储的数据的类型。因为，变量无类型，但是它存储的数据有。

05-数据类型转换

数据类型之间，在特定的场景下，是可以相互转换的，如字符串转数字、数字转字符串等。那么，我们为什么要转换它们呢?

1. 从文件中读取的数字，默认是字符串，我们需要转换成数字类型
2. 后续学习的input()语句,默认结果是字符串，若需要数字也需要转换
3. 将数字转换成字符串用以写出到外部系统
4. 等等

if __name__ == '__main__':
    a = 666
    b = "666"
    c = 66.6

    print(type(a))
    print(type(b))
    print(type(c))
    b = int(b)
    a = float(a)
    d = str(a)
    print(type(b))
    print(type(a))
    print(type(d))
    """
    <class 'int'>
	<class 'str'>
	<class 'float'>
	<class 'int'>
	<class 'float'>
	<class 'str'>
	"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

想把字符串转换成数字，必须确保字符串里都是数字

06-标识符

什么是标识符
在Python程序中，我们可以给很多东西起名字，比如:

1. 变量的名字
2. 方法的名字
3. 类的名字
4. 等等

这些名字，我们把它统一的称之为标识符，用来做内容的标识。所以，标识符：是用户在编程的时候所使用的一系列名字，用于给变量、类、方法等命名。
标识符命名规则-内容限定
●英文
●中文（不推荐）
●数字（不可以用在开头）
●下划线(_)
标识符命名中，只允许出现：这四类元素。其余任何内容都不被允许。
标识符命名规则-大小写敏感
以定义变量为例:
●Andy =1
●andy =2
字母a的大写和小写，是完全能够区分的。
标识符命名规则-不可使用关键字

07-运算符

算术（数学）运算符

if __name__ == '__main__':
    # 算术(数学)运算符
    print("1 + 1 = ",1 + 1)    #2
    print("2 - 1 = ",2 - 1)    #1
    print("3 * 3 = ",3 * 3)    #9
    print("11/ 2 = ",11 / 2)   #5.5
    print("11//2 = ",11 // 2)  #5
    print("9 % 2 = ",9 % 2)    #1
    print("2** 3 = ",2 **3)    #8
1
2
3
4
5
6
7
8
9

赋值运算符

复合赋值运算符

if __name__ == '__main__':
    # 复合赋值运算符
    a = 11
    a +=1
    print("a += 1 : ", a)    #12
    a -=1
    print("a -= 1 : ",a)    #11
    a *= 2
    print("a *= 2 : ",a)    #22
    a /= 2
    print("a /= 2 : ",a)    #11.0
    a **= 2
    print("a **= 2 : ",a)    #121.0
    a //= 2
    print("a //= 2 : ",a)    #60.0
    a %= 3.3
    print("a %= 3.3 : ",a)    #0.6000000000000032
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

08-字符串三种定义方式

1. 三引号定义法，和多行注释的写法一样，同样支持换行操作。
2. 使用变量接收它，它就是字符串
3. 不使用变量接收它，就可以作为多行注释使用。

字符串的嵌套

• 单引号定义法，可以内含双引号
• 双引号定义法，可以内含单引号
• 可以使用转移字符()来将引号解除效用，变成普通字符串

if __name__ == '__main__':
    a = "'我'"
    b = '"的"'
    c = "\"字\""
    d = '\"符\"'
    e = '\'串\''
    print(a)
    print(b)
    print(c)
    print(d)
    print(e)
    """
    '我'
	"的"
	"字"
	"符"
	'串'
	"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

09-字符串的拼接

如果我们有两个字符串(文本)字面量，可以将其拼接成一一个字符串，通过+号即可完成，如：

if __name__ == '__main__':
    print("学IT来黑马"+ "月薪过万")
    a = "!!!"
    print("学IT来黑马"+ "月薪过万"+a)
    #学IT来黑马月薪过万
    #学IT来黑马月薪过万!!!
1
2
3
4
5
6

10-字符串格式化

if __name__ == '__main__':
    a = "!!!"
    b = "~~~~~"
    print("学IT来黑马"+ "月薪过万 %s"%a)
    print("学IT来黑马" + "月薪过万 %s %s" % (a,b))
    #学IT来黑马月薪过万 !!!
	#学IT来黑马月薪过万 !!! ~~~~~
1
2
3
4
5
6
7

多个变量占位，变量要用括号括起来，并按照占位的顺序填入

11-字符串格式化的精度控制

if __name__ == '__main__':
    a = 19.99
    print("%f" %a)  #19.990000
1
2
3

我们可以用m.n来控制数据的宽度与精度

1. m，控制宽度，要求是数字（很少使用），设置的宽度小于数字自身，不生效
2. .n，控制小数点精度，要求是数字，会进行小数的四舍五入

if __name__ == '__main__':
    num1 = 11
    num2 = 11.345
    print("数字11宽度限制5，结果: %5d" % num1)
    print("数字11宽度限制1，结果: %1d" % num1)
    print("数字11.345宽度限制7，小数精度2，结果: %7.2f" % num2)
    print("数字11.345不限制宽度，小数精度2,结果: %.2f" % num2)
    '''
    数字11宽度限制5，结果:    11
    数字11宽度限制1，结果: 11
    数字11.345宽度限制7，小数精度2，结果:   11.35
    数字11.345不限制宽度，小数精度2,结果: 11.35
    '''
1
2
3
4
5
6
7
8
9
10
11
12
13

12-字符串三种定义方式2

通过语法: f"内容{变量}"的格式来快速格式化

f 的作用就是告诉电脑，我这里面会有占位符

if __name__ == '__main__':
    num1 = 11
    num2 = 11.345
    print(f"结果: {num1}，结果: {num2}" )
    '''
    数字11宽度限制1，结果: %1d
    '''
1
2
3
4
5
6
7

不理会类型，不做精度控制

13-对表达式进行格式化

表达式：一条具有明确执行结果的代码语句

if __name__ == '__main__':
    print("1 * 1的结果是: %d" % (1 * 1))
    print(f"1 * 2的结果是: {1*2}")
    print("字符串在Python中的类型名是: %s" % type("字符串"))

    '''
    1 * 1的结果是: 1
    1 * 2的结果是: 2
    字符串在Python中的类型名是: <class 'str'>
    '''
1
2
3
4
5
6
7
8
9
10

14-字符串格式化练习题讲解

if __name__ == '__main__':
    name = "传智播客"
    stock_price = 19.99
    stock_code = "003032"
    stock_price_growth_factor = 1.2
    grow_days = 7
    finally_stock_price = stock_price*stock_price_growth_factor**grow_days
    print(f"公司: {name}， 股票代码: {stock_code}， 当前股价: {stock_price}")
    print("每日增长系数: %2.1f，经过%d天的增长后，股价达到了: %.2f" % (stock_price_growth_factor, grow_days, finally_stock_price))

    '''
    公司: 传智播客， 股票代码: 003032， 当前股价: 19.99
	每日增长系数: 1.2，经过7天的增长后，股价达到了: 71.63
    '''
1
2
3
4
5
6
7
8
9
10
11
12
13
14

15-数据输入（input语句）

获取键盘输入——利用input语句完成

我们前面学习过print语句(函数)，可以完成将内容(字面量、变量等)输出到屏幕上。
在Python中，与之对应的还有一个input语句，用来获取键盘输入。

• 数据输出：print
• 数据输入：input

使用上也非常简单：

• 使用input()语句可以从键盘获取输入
• 使用一个变量接收(存储)input语句获取的键盘输入数据即可

if __name__ == '__main__':
    print("please tell me your name!")
    name = input()
    print("ok,your name is "+name)
    
    name = input("please tell me your name!")
    print("ok,your name is "+name)
1
2
3
4
5
6
7

第一阶段——第三章

01-布尔类型和比较运算符

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

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

一定要大写True与False

if __name__ == '__main__':
    bool_1 = true  #错误
    bool_2 = True

1
2
3
4

02-if语句的基本格式

ADT:
if 要判断的条件：
（Tab）条件成立时，要做得事情
Python是靠缩进来判断归属的

if __name__ == '__main__': 
    age = 30
    if age>18:#:千万不要忘记
        print("成年了")#注意缩进位置！！！让Python明确归属关系
1
2
3
4

03-案例-成年人判断讲解

if __name__ == '__main__':
    print('Welcome to this 游乐园，儿童no money 成人yes money')
    age = input('How old are you?')
    age = int(age)
    if age >=18:
        print("Oh,you are a adult，give me money")
    if age < 18:
        print("Oh,you are a child .it is dangerous,Please call your parent to bring you in there!!!")
1
2
3
4
5
6
7
8

04-if else组合判断讲解

if __name__ == '__main__':
    print('Welcome to this 游乐园，儿童no money 成人yes money')
    age = input('How old are you?')
    age = int(age)
    if age >=18:
        print("Oh,you are a adult，give me money")
    else:
        print("Oh,you are a child .it is dangerous,Please call your parent to bring you in there!!!")
1
2
3
4
5
6
7
8

05-案例-我要买票吗讲解

if __name__ == '__main__':
    # 定义键盘输入获取身高数据.
    height = int(input("请输入你的身高(cm) : "))
    # 通过if进行判断
    if height > 120:
        print("您的身高超出120CM，需要买票，10元。")
    else:
        print("您的身高低于120CM，可以免费游玩。")
    print("祝您游玩愉快")
1
2
3
4
5
6
7
8
9

06-if elif else组合使用的语法

if __name__ == '__main__':
    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("祝您游玩愉快。")
1
2
3
4
5
6
7
8
9
10
11

07-案例-猜猜心理数字讲解

if __name__ == '__main__':
    # 定义一个变量数字
    num = 5
    # 通过键盘输入获取猜想的数字，通过多次if 和elif的组合进行猜想比较
    if int(input("请猜一个数字: ")) == num:
        print("恭喜第一次就猜对了呢")
    elif int(input("猜错了， 再猜一次: "))== num:
        print("猜对了")
    elif int(input("猜错了， 再猜一次: ")) == num:
        print("恭喜，最后一次机会，你猜对了")
    else:
        print("Sorry猜错了，"+"我想的是：",num)
1
2
3
4
5
6
7
8
9
10
11
12

08-判断语句的嵌套

判断语句的嵌套

许多的逻辑的判断，是嵌套的，多层的。
对于这种需求，我们可以只有组合：if elif else，完成特定需求的要求

if __name__ == '__main__':
    if int(input("你的身高是多少: ")) > 120:
        print("身高超出限制，不可以免费")
        print("但是，如果vip级别大于3，可以免费")
        if int(input(" 你的vip级别是多少: ")) > 3:
            print("恭喜你，vip级别达标，可以免费")
        else:
            print("Sorry你需要买票10元")
    else:
        print("欢迎小朋友，免费游玩。")
1
2
3
4
5
6
7
8
9
10

案例需求：

1. 必须是大于等于18岁小于30岁的成年人
2. 同时入职时间需满足大于两年，或者级别大于3才可领取

if __name__ == '__main__':
    age = 20
    year = 3
    Level = 1
    if age >= 18:
        print("你是成年人")
        if age < 30:
            print("你的年龄达标了")
            if year > 2:
                print("恭喜你，年龄和入职时间都达标，可以领取礼物")
            elif Level > 3:
                print("恭喜你，年龄和级别大表，可以领取礼物")
            else:
                print("不好意思，尽管年龄达标，但是入职时间和级别都不达标。")
        else:
            print("不好意思，年龄太大了")
    else:
        print("不好意思，小朋友不可以领取。")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

09-判断语句的综合案例

案例需求：

1. 数字随机产生，范围1-10
2. 有3次机会猜测数字，通过3层嵌套判断实现
3. 每次猜不中，会提示大了或小了

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

import random
num = random.randint(1,10)#可以取到10
1
2

正式代码：

# 1.构建一个随机的数字变量
import random
num = random.randint(1,10)
if __name__ == '__main__':

    guess_num = int(input(" 输入你要猜测的数字: "))
    # 2.通过if判断语句进行数字的猜测
    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("三次机会用完了，没有猜中。")
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

第一阶段——第四章

01-while循环的基础应用

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

实例：
向小美示爱10次

if __name__ == '__main__':
    i = 0
    while i<10:
        print("xioamei ,I love you!")
        i += 1
        #关于i++ python 中的没有 i++ ，如果写了会报语法错误。 
        #但是python 中有 --i,++i,+-i,-+i,他们不是实现-1操作的。
        #仅仅是作为判断运算符号,类似数学中的负负得正。
1
2
3
4
5
6
7
8

1. while的条件需得到布尔类型, True表示继续循环, False表示结束循环
2. 需要设置循环终止的条件，如i+= 1配合i< 100,就能确保100次后停止，否则将无限循环
3. 空格缩进和if判断一样，都需要设置

02-案例-求1-100的和

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

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

if __name__ == '__main__':
    num =0
    i =1
    while i<=100:
        num = num+i
        i += 1
    print(num)#5050
1
2
3
4
5
6
7

03-while循环猜数字案例

案例：

1. 设置一个范围1-10的随机整数变量，通过while循环，配合input语句，判断输入的数字是否等于随机数
2. 无限次机会，直到猜中为止
3. 每一次猜不中，会提示大了或小了
4. 猜完数字后，提示猜了几次

提示：

1. 无限次机会，终止条件不适合用数字累加来判断
2. 可以考虑布尔类型本身 (True or False)
3. 需要提示几次猜中，就需要提供数字累加功能
4. 随机数可以使用：

import random
num = random.randint(1,10)#可以取到10
1
2

正式代码：

import random
num  =random.randint(1,10)
if __name__ == '__main__':
    a = int(input("请输入一个1-10的数"))
    while a !=num:
        print("不对")
        a = int(input("请再输入"))
    print("猜到了！！")
1
2
3
4
5
6
7
8

04-while循环的嵌套应用

if __name__ == '__main__':
    i = 1
    while i <= 10:#表白10天 每天10多花 
        print(f"今天是第{i}天，准备表白......")
        j = 1
        while j <= 10:
            print(f"送给小美第{j}只玫瑰花")
            j += 1
        print("小美，我喜欢你")
        i += 1
    print(f"坚持到第{i - 1}天，表白成功")

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

05-案例-九九乘法表

补充知识——输出不换行

end是print的传参功能

补充知识——制表符\t
在字符串中，有一一个特殊符号:\t,效果等同于在键盘上按下: tab键。
它可以让我们的多行字符串进行对齐。

案例：输出九九乘法表

if __name__ == '__main__':
    i = 1
    #定义内层循环的控制变量
    while i<=9:
        f = 1
        while f<=i:
        	#内层循环的print语句，不要换行，通过\t制表符进行对齐
            print(f"{f} * {i} = {i * f}\t",end='')
            f += 1
        print()# print空内容，就是输出一个换行
        i +=1
    '''
    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	
    '''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

06-for循环的基础语法

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

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

for 临时变量 in 待处理数据集：
（Tab）循环满足条件时执行的代码

if __name__ == '__main__':
    # 定义字符串name
    name = "itheima"
    # for循环处理字符串
    for x in name:
        print(x)

    '''
    i
    t
    h
    e
    i
    m
    a
    '''

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

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

07-案例-数一数多少字母a

案例：

1. 定义字符串变量name,内容为: “itheima is a brand of itcast”
2. 通过for循环，遍历此字符串，统计有多少个英文字母: “a”

if __name__ == '__main__':
    # 定义字符串n
    n = "itsdiahdoiaaa sdaaheima"
    m = 0
    # for循环处理字符串
    for x in n:
        if x=='a':
            m+=1
    print(f"一共{m}个a")
1
2
3
4
5
6
7
8
9

08-range语句

语法中的：待处理数据集，严格来说，称之为：序列类型。序列类型指，其内容可以一一个个依次取出的一种类型，包括：

1. 字符串
2. 列表
3. 元组
4. 等

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

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]

if __name__ == '__main__':

    for x in range(10):
        print(x," ",end = " ")
    print()
    for x in range(5,10):
        print(x," ",end = " ")
    print()
    for x in range(5,10,2):
        print(x," ",end = " ")
    '''
    0   1   2   3   4   5   6   7   8   9   
    5   6   7   8   9   
    5   7   9  
    '''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

09-for循环的临时变量作用域

if __name__ == '__main__':

    for x in range(10):
        print(x," ",end = " ")
    print()
    print(x)
    '''
    0   1   2   3   4   5   6   7   8   9   
    9
    '''
1
2
3
4
5
6
7
8
9
10

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

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

10-for循环的嵌套使用

if __name__ == '__main__':

    # 坚持表白10天， 每天都送10朵花
    # range
    i = 0
    for i in range(1,11):
        print(f"今天是向小美表白的第{i}天，加油坚持。")
        # 写内层的循环了
        for j in range(1, 11):
            print(f"给小美送的第{j}朵玫瑰花")
        print("小美我喜欢你")
    print(f"第{i}天，表白成功")
1
2
3
4
5
6
7
8
9
10
11
12

if __name__ == '__main__':

    i = 1
    while i <= 10:
        print(f"今天是向小美表白的第{i}天，坚持.")
        for j in range(1, 11):
            print(f"送给小美的第{j}朵玫瑰花")
        print(f"小美，我喜欢你(第{i}天的表白结束)")
        i += 1
    print(f"表白第{i - 1}天，表白成功")
1
2
3
4
5
6
7
8
9
10

11-for循环打印九九乘法表

if __name__ == '__main__':
    #定义内层循环的控制变量
    for i in range(1,10):
        f = 1
        while f in range(1,i+1):
        	#内层循环的print语句，不要换行，通过\t制表符进行对齐
            print(f"{f} * {i} = {i * f}\t",end='')
            f += 1
        print()# print空内容，就是输出一个换行
        i +=1

    '''
    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	
    '''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

12-continue和break

continue

if __name__ == '__main__':
    #演示中断语句continue
    for i in range(1,10):
        print("1 ",end="")
        continue
        print("我是菜鸡")

    '''
    1 1 1 1 1 1 1 1 1 
    '''
1
2
3
4
5
6
7
8
9
10

if __name__ == '__main__':
	#演示continue的嵌套应用
    for i in range(1,6):
        print("语句1")
        for j in range(1, 6):
            print("语句2")
            continue
            print("语句3")
        print("语句4")
1
2
3
4
5
6
7
8
9

break

if __name__ == '__main__':
    #演示break的嵌套应用
    for i in range(1,10):
        print("1 ",end="")
        break
        print("我是菜鸡")

    '''
    1 
    '''
1
2
3
4
5
6
7
8
9
10

if __name__ == '__main__':
	#演示break的嵌套应用
    for i in range(1,6):
        print("语句1")
        for j in range(1, 6):
            print("语句2")
            break
            print("语句3")
        print("语句4")
1
2
3
4
5
6
7
8
9

13-循环综合案例

案例：

import random
score =0
if __name__ == '__main__':
    # 定义账户余额变量
    money = 10000
    # for循环对员工发放工资
    for i in range(1, 21):
        score = random.randint(1, 10)
        if score < 5:
            print(f"员工{i}绩效分{score}，不满足，不发工资，下一位")
            # continue跳过发放
            continue

        # 要判断余额足不足
        if money >= 1000:
            money -= 1000
            print(f"员工{i}，满足条件发放工资1000，公司账户余额: {money}")
        else:
            print(f"余额不足，当前余额: {money}元， 不足以发工资，不发了，下个月再来")
            # break结束发放
            break
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21