1.1人工智能
1.1.1定义
研究如何使计算机去做过去只有人才能做的智能工作
例如：ChatGPT
1.1.2应用
2. Python 简介
2.1 计算机基础结构
2.1.1 硬件
1944年，美籍匈牙利数学家冯·诺依曼提出计算机基本结构。
五大组成部分：运算器、控制器、存储器、输入设备、输出设备。
-- 运算器：按照程序中的指令，对数据进行加工处理。
-- 控制器：根据程序需求，指挥计算机的各个部件协调工作。
通常将运算器和控制器集成在中央处理器（CPU）中。
-- 存储器：保存各类程序的数据信息。
内存RAM -- 容量小，速度快，临时存储数据
硬盘HDD -- 容量大，速度慢，永久存储数据
输入设备：外界向计算机传送信息的装置。
例如：鼠标、键盘、扫描仪…
输出设备：计算机向外界传送信息的装置。
例如：显示器、音响、打印机…
2.1.2 软件
操作系统：
-- 管理和控制计算机软件与硬件资源的程序。
-- 隔离不同硬件的差异，使软件开发简单化。
-- Windows，Linux，Unix。
应用软件：为了某种特定的用途而被开发的软件。
软件：程序 + 文档。
-- 程序是一组计算机能识别和执行的指令集合。
-- 文档是为了便于了解程序所需的说明性资料。
2.2 基础知识
2.2.1 Python介绍
2.2.1.1定义
一种简洁易懂的编程语言，可以实现各种科学计算和程序开发
2.2.1.2优势
2.2.1.3从业岗位
2.2.2 Python程序执行方式
2.2.2.1交互式
在命令行输入指令，回车即可得到结果。
(1) 打开终端
(2) 进入交互式：python3
(3) 编写代码：print("hello world")
(4) 离开交互式：exit()
2.2.2.2文件式
将指令编写到.py文件，可以重复运行程序。
(1) 编写文件
(2) 打开终端
(3) 进入程序所在目录：cd 目录
(4) 执行程序： python3 文件名
2.2.2.3 Linux常用命令
(1) pwd：查看当前工作目录的路径
(2) cd：改变工作目录（进入到某个目录）
练习：
(1) 在指定目录创建python文件.
--目录：/home/user/month01
--文件名：exercise01.py
(2) 在文件中写入：print("你好，世界!")
(3) 运行python程序
2.2.3 执行过程
计算机只能识别机器码(1010)，不能识别源代码(python)。
(1) 由源代码转变成机器码的过程分成两类：编译和解释。
(2) 编译：在程序运行之前，通过编译器将源代码变成机器码，例如：C语言。
-- 优点：运行速度快
-- 缺点：开发效率低，不能跨平台。
(3) 解释：在程序运行之时，通过解释器对程序逐行翻译，然后执行，例如Javascript。
-- 优点：开发效率高，可以跨平台；
-- 缺点：运行速度慢。
(4) python是解释型语言，但为了提高运行速度，使用了一种编译的方法。编译之后得到pyc文件，存储了字节码（特定于Python的表现形式，不是机器码）。
2.3集成开发工具
2.3.1创建新项目
2.3.2配置新项目
2.3.3新建目录
2.3.4新建文件
2.3.5运行与关闭
运行快捷键：ctrl + shift + f10
关闭快捷键：ctrl + shift + f4
3. 数据基本运算
3.1 软件开发基本步骤
3.1.1 汇率转换器
"""
创建文件:exercise03
汇率转换器
"""
# 1. 获取数据 - 美元
usd = input("请输入美元:")
# 2. 逻辑处理 - 美元 * 6.99
cny = int(usd) * 6.99
# 3. 显示结果 - xx美元是xx人民币
print(usd + "美元是" + str(cny) + "人民币")3.1.2 常用快捷键
(1) 移动到本行开头：home键
(2) 移动到本行末尾：end键盘
(3) 注释代码：ctrl + /
(4) 复制行：ctrl +d
(5) 删除行：shift + delete
(6) 选择列：shift + alt +鼠标左键
(7) 移动行：ctrl + shift + 上下箭头
(8) 代码格式化：ctrl+alt+l
3.1.3 注释
给人看的，通常是对代码的描述信息。
(1) 单行注释：以#号开头。
(2) 多行注释：三引号开头，三引号结尾。
3.2 数据
3.2.1 变量
(1) 定义：在内存中操作数据的空间。
(2) 语法
(3) 复用性
一个变量可以被多次使用，重复操作一个数据，以提高代码的可读性
# 计算圆形面积
# 没有变量：
print(2 * 3.14 * 5)
print(3.14 * 5 * 5)
# 使用变量：
r = 5
print(2 * 3.14 * r)
print(3.14 * r * r)(4)可变性
一个变量可以被重复赋值，实现对程序状态的调节以适应现实环境的变化
(5) 命名：由字母、数字、下划线组成，且不能以数字开头。
不能使用关键字(蓝色)，否则发生语法错误SyntaxError。
(6) 建议命名：字母小写，多个单词以下划线隔开。
class_name = "xxx"练习：画出下列代码内存图
number_of_monkeys = 5
number_of_tigers = number_of_monkeys
number_of_monkeys = 30
print(number_of_tigers)3.2.2 人机交互
3.2.2.1定义
用户与计算机之间的互动过程，目的是让计算机更好地满足用户需求
3.2.2.2函数
函数就像一个魔法盒子，进去一只"猴子"出来一个"大圣"
至于功能的实现方式只有函数定义者清楚；而调用者糊涂
参数是传入函数的数据，返回值是函数处理后的结果
(1) input函数
作用：将终端中用户输入的数据存储在程序中
语法：变量 = input(提示信息)
应用：输入数据
usd = input("请输入美元:")
cny = input("请输入人民币:")练习：分别输入'我爱编程'的句子成分
效果：
请输入'我爱编程'的主语:我
请输入'我爱编程'的谓语:爱
请输入'我爱编程'的宾语:编程
(2) print函数
作用：将括号中的数据显示在终端中
语法：print(数据)
应用：呈现结果
usd = input("请输入美元:")
cny = input("请输入人民币:")
print(usd + "美元=" + cny + "人民币")练习：在一行输出句子成分
效果：
请输入'我爱编程'的主语:我
请输入'我爱编程'的谓语:爱
请输入'我爱编程'的宾语:编程
您输入的主语是我，谓语是爱，宾语是编程
3.2.3 核心类型
在python中变量没有类型，但关联的对象有类型。
3.2.3.1 整形int
表示整数，包含正数、负数、0。
如： -5, 100, 0
3.2.3.2 浮点型float
(1) 表示小数，包含正数、负数，0.0。
(2) 字面值：
小数：1.0 2.5
# 小数
num01 = 1.233.2.3.3 字符串str
(1) 用来记录文本信息(文字信息)。
(2) 字面值：双引号
3.2.3.4 布尔bool
(1) 表示条件是否成立
(2) 只有两个值：
True 表示真(条件满足或成立)，本质是1
False 表示假(条件不满足或不成立)，本质是0
result = input("请输入您的职业:") == "老师"
print(result) # 输入老师,结果True;输入其他,结果False3.3 运算
3.3.1 类型转换
(1) 转换为整形: int(数据)
(2) 转换为浮点型:float(数据)
(3) 转换为字符串:str(数据)
(4) 转换为布尔:bool(数据)
结果为False：bool(0) bool(0.0) bool(None)
(5) 混合类型自动升级：
1 + 2.14 返回的结果是 3.14
1 + 3.0 返回结果是: 4.0
# str -> int
data01 = int("3")
# int -> str
data02 = str(5)
# str -> float
data03 = float("1.2")
# float -> str
data04 = str(1.2)
# int -> float
data05 = float(250)
# float -> int
data06 = int(1.9)
print(data06) # 1 向下取整(截断删除)
# 注意：字符串转换为其他类型时,
# 必须是目标类型的字符串表达形式
# print(int("10.5")) # 报错
# print(float("abc"))# 报错练习：在终端中输入商品单价、购买的数量和支付金额。计算应该找回多少钱。
效果：
请输入商品单价：5
请输入购买数量：3
请输入支付金额：20
应找回：5.0
3.3.2 运算符
3.3.2.1 算术运算符
练习1：在终端中输入一个疫情确诊人数再录入一个治愈人数，打印治愈比例
格式：治愈比例为xx%
效果：
请输入确诊人数：500
请输入治愈人数：495
治愈比例为99.0%
练习2：古代的秤，一斤十六两。在终端中获取两，计算几斤零几两。
效果：
请输入总两数：100
结果为：6斤4两
3.3.2.2 增强运算符
data01 = 10
# data01 + 5
# print(data01) # 10
data01 += 5 # data01 = data01 + 5
print(data01) # 15练习：在终端中输入一个四位整数，计算每位相加和。
例如：录入1234，打印1+2+3+4结果
效果：
请输入四位整数：1234
结果是：10
3.3.2.3 比较运算符
返回布尔类型的值
比较运算的数学表示方式:0 <= x <= 100
案例：
# 存款大于500000
print(int(input("说存款"))>=500000)
# 有房产
print(input("说房产")=="有")
# 黄金年龄
print(25 <= int(input("说年龄"))<= 35)练习： 根据条件写出代码
输入的是正数：大于零
输入的是偶数：能被2整除
输入的是星期：1到7之间
3.3.2.4 逻辑运算符
(1) 与and
int(input("请输存款:")) >= 100000 and input("请输房产:") == "有"(2) 或or
int(input("请输存款:")) > 100000 and input("请输房产:") == "有"(3) 非 not
练习:根据命题写出代码
年龄大于25 并且 身高小于170
职位是高管 或者 年薪大于500000
(4) 短路运算
一但结果确定，后面的语句将不再执行。
3.3.2.5 优先级
4. 语句
4.1 行
(1) 物理行：程序员编写代码的行。
(2) 逻辑行：python解释器需要执行的指令。
(3) 建议：
一个逻辑行在一个物理行上。
如果一个物理行中使用多个逻辑行，需要使用分号；隔开。
(4) 换行：
如果逻辑行过长，可以使用隐式换行或显式换行。
隐式换行：所有括号的内容换行,称为隐式换行
括号包括: () [] {} 三种
显式换行：通过折行符 \ (反斜杠)换行，必须放在一行的末尾，目的是告诉解释器,下一行也是本行的语句。
# 4个物理行 4个逻辑行
a = 1
b = 2
c = a + b
print(c)
# 1个物理行 4个逻辑行(不建议)
a = 1;b = 2;c = a + b;print(c)
# 4个物理行 1个逻辑行
# -- 换行符
d = 1+\
2+\
3+4\
+5+6
# -- 括号
e = (1+2+
3+4
+5+
6)4.2 选择语句
4.2.1 if else 语句
(1) 作用:
让程序根据条件有选择性的执行
(2) 语法:
练习:
在终端中输入体温，如果在36到37之间，输出正常，否则异常。
4.2.2 省略else
练习：
在终端中输入课程阶段数,显示课程名称
效果：
输入： 输出：
1 Python语言核心编程
2 Python高级软件技术
3 Web 全栈
4 人工智能
4.2.3 elif
练习1:在终端中输入一个数字，判断后输出正数或者负数或者零。
练习2：
根据心理年龄与实际年龄，打印智商等级。
智商IQ = 心理年龄MA 除以 实际年龄CA 乘以 100
天才：140以上（包含）
超常：120-139之间（包含）
聪慧：110-119之间（包含）
正常：90-109之间（包含）
迟钝：80-89之间（包含）
低能：80以下
4.2.4 if嵌套
练习：
在终端中输入月份，打印相应的天数.
1 3 5 7 8 10 12 有 31天
2 有 29天
4 6 9 11 有 30天
超过月份提示月份有误
效果：
请输入月份:10
31天
4.2.5 最值算法
在终端中录入4个同学身高,打印最高的值.
算法：
170 160 180 165
假设第一个就是最大值
使用假设的和第二个进行比较, 发现更大的就替换假设的
使用假设的和第三个进行比较, 发现更大的就替换假设的
使用假设的和第四个进行比较, 发现更大的就替换假设的
最后，假设的就是最大的.
效果：
请输入第1个同学身高:170
请输入第2个同学身高:160
请输入第3个同学身高:180
请输入第4个同学身高:165
最高的同学:180
4.3 循环语句
4.3.1 while语句
4.3.1.1延长程序生命
练习：
让下列代码重复执行，输入y继续(不输入y则退出)
number = int(input("请输入数字："))
if number > 0:
print("正数")
elif number < 0:
print("负数")
else:
print("零")4.3.1.2循环计数
练习1：
在终端中显示0 1 2 3
在终端中显示2 3 4 5 6
在终端中显示1 3 5 7
在终端中显示8 7 6 5 4
在终端中显示-1 -2 -3 -4 -5
练习2：
一张纸的厚度是0.01毫米
请计算，对折多少次超过珠穆朗玛峰(8844.43米)
思路:
数据：厚度、高度、次数
算法：厚度*=2 次数+=1
练习3：
程序产生1个,1到100之间的随机数。
让玩家重复猜测,直到猜对为止。
每次提示：大了、小了、恭喜猜对了,总共猜了多少次。
效果：
请输入要猜的数字:50
大了
请输入要猜的数字:25
小了
请输入要猜的数字:35
大了
请输入要猜的数字:30
小了
请输入要猜的数字:32
恭喜猜对啦,总共猜了5次
4.3.2 for 语句
# 写法1:range(开始,结束,间隔)
# 注意:不包含结束值
for item in range(1, 3, 1):
print(item)
# 写法2:range(开始,结束)
# 注意:间隔默认为1
for item in range(1, 3):
print(item)
# 写法3:range(结束)
# 注意:开始默认为0
for item in range(3):
print(item)练习1：
在终端中累加 0 1 2 3
在终端中累加 2 3 4 5 6
在终端中累加 1 3 5 7
在终端中累加 8 7 6 5 4
在终端中累加 -1 -2 -3 -4 -5
练习2：一张纸的厚度是0.01毫米请计算，对折15次的厚度是多少毫米
练习3：程序产生一个1到100之间的随机数，让玩家最多重复猜5次
每次提示：大了、小了、恭喜猜对了,总共猜了多少次。
4.3.3 对比
while循环
擅长于根据条件重复
例如纸张对折到珠穆朗玛峰
for循环
擅长于根据次数重复
例如纸张对折15次
4.4 跳转语句
4.4.1 break 语句
跳出循环体，后面的代码不再执行。
4.4.2 continue 语句
(1) 跳过当前循环体中剩余代码，继续执行下一次循环
# 需求：累加1-100之间能被3整除的数字
# 思想：不满足条件跳过,否则累加.
sum_value = 0
for item in range(1, 101):
if item % 3 != 0:
continue
sum_value += item
print(sum_value)练习：累加10 -- 60之间，个位不是3/5/8的整数和。
5. 容器类型
5.1 列表 list
5.1.1 概述
5.1.1.1 何时用
在Python中可以使用列表，对日常生活中的大量数据进行管理
5.1.1.2 为何用
若没有列表类型，一个变量只能操作一个数据；手动为每个数据创建变量，无法动态添加数据
movie01 = "八角笼中"
movie02 = "封神第1部"
... = "消失的她"
while True:
movie = input("请输入电影名:")
...5.1.1.3 如何用
(1)定义：由一系列变量组成的可变序列容器
(2)语法：
列表名 = [元素1,元素2,元素3]
(3)案例：
list_movie = ["八角笼中","封神第1部","消失的她"](4)内存图：
练习：
创建列表存储3个地区名称
创建列表存储3个新增人数
创建列表存储3个现有人数
5.1.1.4 序列
(1)定义：有顺序且空间连续的容器类型
(2)基础操作
+：用于连接两个容器
*：重复生成容器元素
list_movie01 = ["八角笼中"]
list_movie02 = ["封神第1部","消失的她"]
list_movie03 = list_movie01 + list_movie02
# ["八角笼中","封神第1部","消失的她"]
list_movie04 = list_movie01 * 2
# ["八角笼中","八角笼中"](3)成员运算
作用：判断容器中是否存在某一元素
语法：in not in
list_movie = ["八角笼中","封神第1部","消失的她"]
print("八角笼中" in list_movie) # True
print("封神第2部" not in list_movie) # True
print("她" in list_movie) # False(4)常用函数
len函数：计算容器中元素的数量
max函数：计算容器中最大的元素
min函数：计算容器中最小的元素
sum函数：对容器中元素求和计算
list_movie = [690761,532622,446700]
print(len(list_movie)) # 3
print(max(list_movie)) # 690761
print(min(list_movie)) # 446700
print(sum(list_movie)) # 1670083练习：
计算新增列表最大值
计算现有列表最小值
对新增列表进行求和
判断现有列表是否存在859
5.1.2 基础操作
5.1.2.1 添加元素
列表名.append(元素)
列表.insert(索引，元素)
list_movie = ["八角笼中"]
list_movie.append("封神第1部")
list_movie.append("消失的她")
print(list_movie) # ["八角笼中","封神第1部","消失的她"]
list_movie = ["封神第1部","消失的她"]
list_movie.insert(0,"八角笼中")
练习1：
向地区、新增、现有三个列表中添加第四行信息
将第五行信息插入到地区、新增、现有三个列表中第一个位置
练习2：
在终端中录入5个疫情地区名称，分别存储在列表中，最后显示列表
5.1.2.2 定位元素
列表名[索引] = 元素
变量 = 列表名[索引]
变量 = 列表名[切片] # 赋值给变量的是切片所创建的新列表
列表名[切片] = 容器 # 右侧必须是可迭代对象，左侧切片没有创建新列表
list_movie = ["八角笼中","封神第1部","消失的她"]
list_movie[0] = "满江红" 
list_movie = ["八角笼中","封神第1部","消失的她"]
list_movie[:2] = ["满江红","流浪地球"] 
list_movie = ["八角笼中","封神第1部","消失的她"]
list_new = list_movie[:2]
list_movie = ["八角笼中","封神第1部","消失的她"]
list_movie[2] = ["满江红","流浪地球"] 
练习：画出下列代码内存图
list_region = ["台湾","陕西","浙江"]
data01 = list_region
data02 = list_region[-2:]
data02[0] = "shan_xi"
print(list_region)
data01[0] = "tai_wan"
print(list_region)5.1.2.3 删除元素
列表名.remove(元素)
del 列表名[索引或切片]
list_movie = ["八角笼中","封神第1部","消失的她"]
del list_movie[0]
del list_movie[:2]
print(list_movie) # []
list_movie = ["八角笼中","封神第1部","消失的她"]
list_movie.remove("消失的她")
print(list_movie) # ["八角笼中","封神第1部"]
list_movie.remove("大话西游") # 报错
练习：
list_region = ["台湾","陕西","台湾"]
data01 = list_region
data01.remove("台湾")
print(list_region)5.1.2.4 遍历
(1)从头到尾读取
for 变量名 in 列表名:
变量名是元素
list_pop = [921109,826748,189298]
for item in list_pop:
if item > 500000:
print(item )
(2)从头到尾修改：
for 索引名 in range(len(列表名)):
列表名[索引名]是元素
list_pop = [921109,826748,189298]
for i in range(len(list_pop)):
if list_pop[i] > 500000:
list_pop[i] = 500000
练习：
打印新增列表小于10的元素
现有列表所有元素累加2
综合练习
八大行星："水星" "金星" "地球" "火星" "木星" "土星" "天王星" "海王星"
-- 创建列表存储4个行星：“水星” "金星" "火星" "木星"
-- 插入"地球"、追加"土星" "天王星" "海王星"
-- 打印距离太阳最近、最远的行星(第一个和最后一个元素)
-- 打印太阳到地球之间的行星(前两个行星)
-- 删除"海王星",删除第四个行星
-- 打印所有行星(一行一个)
5.1.3 列表拷贝
5.1.3.1为什么需要拷贝
(1)避免数据意外修改
有时候需要将可变数据传递给函数，并且希望函数对这个可变数据的操作不影响原始数据。
(2)保存数据原始快照
在某些情况下，需要创建一个相同状态的数据副本，以便之后可以对比或回滚到先前的状态。
5.1.3.2什么是深拷贝
深拷贝复制所有层的数据，拷贝后的数据完全独立。
import copy
list_movie = ["八角笼中",["消失的她","碟中谍7"]]
list_new = copy.deepcopy(list_movie)
list_new[0] = "满江红"
list_new[1][1] = "流浪地球"
print(list_movie) # ["八角笼中",["消失的她","碟中谍7"]]
5.1.3.3什么是浅拷贝
浅拷贝复制第一层的数据，共享深层的数据。
list_movie = ["八角笼中",["消失的她","碟中谍7"]]
list_new = list_movie[:] # 切片触发浅拷贝
list_new[0] = "满江红" # 修改第一层
list_new[1][1] = "流浪地球" # 修改深层
print(list_movie) # ["八角笼中",["消失的她","流浪地球"]]
5.1.3.5深浅拷贝对比
深、浅拷贝是复制数据的两种方式。
深拷贝复制所有层的数据，拷贝后的数据完全独立。
优点是修改数据时互不影响，缺点是占用内存较大。
浅拷贝复制第一层的数据，共享深层的数据。
优点是占用内存较少，缺点是修改深层数据互相影响。
当需要拷贝的数据具有深层数据，建议使用深拷贝，否则使用浅拷贝。
练习：画出下列内存图
import copy
list01 = ["北京",["上海","深圳"]]
list02 = list01
list03 = list01[:]
list04 = copy.deepcopy(list01)
list04[0] = "北京04"
list04[1][1] = "深圳04"
print(list01) # ?
list03[0] = "北京03"
list03[1][1] = "深圳03"
print(list01) # ?
list02[0] = "北京02"
list02[1][1] = "深圳02"
print(list01) # ?5.1.4 列表推导式
(1)需求：将大于60的元素存入新列表
# 传统代码
list_number = [66,25,72,86,57]
list_new = []
for item in list_number:
if item > 60:
list_new.append(item)
print(list_new) # [66,72,86]
# 推导式代码
list_new = [item for item in list_number if item > 60](2)定义：通过简单的语法将可迭代对象转换为新列表
(3)作用：简化代码，避免了传统循环结构的繁琐，提高代码的可读性
(4)语法：
新列表 = [表达式 for 变量in 可迭代对象]
新列表 = [表达式 for 变量in 可迭代对象 if 条件]
# 将所有元素的个位存入新列表
list_number = [66,25,72,86,57]
list_new = [item % 10 for item in list_number](5)适用性
使用条件：根据可迭代对象、构建新列表、过程够简单
练习：
生成10--30之间能被3或者5整除的数字
结果：[10, 12, 15, 18, 20, 21, 24, 25, 27]
生成5 -- 20之间的数字平方
结果：[25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361]
5.2 元组 tuple
5.2.1 概述
5.2.1.1 何时用
在Python中可以使用元组，存储不会变化的多个数据 
5.2.1.2 如何用
(1)定义：由一系列变量组成的不可变序列容器。
(2)语法：元组名 = (元素1,元素2)
tuple_type = ("剧情","动作")5.2.1.3 与列表区别
元组用于存储无需变化的数据，所以采用"按需分配"的存储机制
列表用于存储需要变化的数据，所以采用"预留空间"的存储机制
5.2.1.4可变数据为什么可变
存储机制：预留空间 + 自动扩容
自动扩容：开辟更大空间、拷贝原始数据、替换内存地址
5.2.1.5不可变数据如何变化
每次变化都会产生新数据
tuple_type = ("剧情","动作")
tuple_type += ("惊悚","科幻")
5.2.2 基础操作
5.2.2.1创建元组
元组名 = (元素1,元素2)
元组名 = 元素1,元素2 # 没有歧义时也可以省略小括号
元组名 = (元素1,) # 只有一个元素时必须添加逗号
name = "悟空", # 小心:是元组不是字符串5.2.2.2定位元素
变量 = 元组名[索引]
变量 = 元组名[切片] # 创建新元组
tuple_type = ("剧情","动作","科幻")
print(tuple_type[0]) # "剧情"
print(tuple_type[:2]) # ("剧情","动作")5.2.2.2遍历元组
从头到尾读取满足条件的元素
for 变量名 in 列表名:
变量名就是元素
list_pop = [921109,826748,189298]
for item in list_pop:
if item > 500000:
print(item ) 5.2.2.3序列拆包
定义：将序列元素分配给多个变量的操作
作用：操作序列元素更方便，代码更简洁
语法：变量名1,变量名2 = 序列
a,b,c = ["王宝强","周润发","王学兵"]
a,b,c = ("王宝强","周润发","王学兵")练习1：画出下列代码内存图
name = "张无忌"
names = ["赵敏", "周芷若"]
tuple01 = ("张翠山", name, names)
name = "无忌哥哥"
tuple01[2][0] = "敏儿"
print(tuple01) # ?练习2：
根据月日,计算是这一年的第几天.
公式：前几个月总天数 + 当月天数
例如：5月10日
计算：31 29 31 30 + 10
5.3 字符串 str
5.3.1 定义
由一系列字符编码值组成的不可变序列容器
5.3.2 编码
5.3.2.1 字符集
字符与整数对应关系的集合
(1)ASCII：包含英文、数字等字符
(2)GBK：兼容ASCII，包含21886个中文
(3)Unicode：几乎涵盖全球所有已知字符
5.3.2.2 编码方式
将字符转换为整数的规则
(1)ASCII：每个字符占1个字节
(2)GBK：英文1个字节，中文2个字节
(3)UTF8：英文1个字节，中文3个字节
5.3.3 不可变
采取"按需分配"的存储策略，节省内存空间
修改数据时若在原有空间，可能破坏其他数据
所以每次修改都会创建新数据，替换变量中记录的数据地址
name = "封神"
name = "封神第一部"
name = "电影" + name 
5.3.4 序列
使用比较运算符时会依次比较两个容器中元素,一但不同则返回结果
print("12w" < "13w") # True
print("2k" < "13w") # False
5.3.5字面值
5.3.5.1 单引和双引号的区别
(1) 单引号内的双引号不算结束符
(2) 双引号内的单引号不算结束符
print('悟空')
print("悟空")
print('花果山"水帘洞"美猴王孙悟空')
print("""花果山'水帘洞'"美猴王"孙悟空""") 5.3.5.2 三引号作用
(1) 换行会自动转换为换行符\n
(2) 三引号内可以包含单引号和双引号
(3) 作为文档字符串
"""
_ooOoo_
o8888888o
88" . "88
(| -_- |)
O\ = /O
____/`---'\____
.' \\| |// `.
/ \\||| : |||// \
/ _||||| -:- |||||- \
| | \\\ - /// | |
| \_| ''\---/'' |_/ |
\ .-\__ `-` __/-. /
___`. .' /--.--\ `. .'___
."" '< `.___\_<|>_/___.' _> \"".
| | : `- \`.;;;;;;;/- /`: : | |
\ \ `-` ;` / / `-` / /
`. `. \_:_\_:_/ .' .'
`-:_\_:_/-'
保佑以下代码正常运行
"""5.3.5.3 转义字符
(1) 定义：改变字符的原始含义。
(2) 语法： \' \" \n \\
print("花果山\"水帘洞\"美猴王孙悟空")
print("花果山水帘洞\n美猴王孙悟空")
print("C:\\newfile\\test.py")(3) 原始字符串：取消转义。
print(r"C:\newfile\test.py")5.3.5.4 格式化
(1) 作用：将变量插入到字符串时，可以先用占位符描述格式后插入变量
(2) 占位符：%s 原样输出 %d 整数保留位数 %f 小数保留精度
(3) 语法：格式%(变量)
name = "大圣"
age = "6"
money = 1.2345
hour = 2
minute = 6
print("我叫%s,今年%s岁啦" % (name, age))
print("请支付:%.2f元" % money)
print("%.2d:%.2d" % (hour,minute))练习：根据下列文字，提取变量，使用字符串格式化打印信息
湖北确诊67802人,治愈63326人,治愈率0.93
70秒是01分零10秒
5.4 字典 dict
5.4.1 概述
5.4.1.1何时用
适合存储有对应关系的数据，例如表格的标题名与行数据
5.4.1.2为何用
若用列表存储电影信息，通过索引访问，代码可读性差
list_movie01 = ["八角笼中","剧情","王宝强"、690761)]
print("名称" + list_movie01[0])
print("类型" + list_movie01[1])
print("演员" + list_movie01[2])
print("指数" + list_movie01[3])5.4.1.3如何用
(1)定义：由一系列键值对组成的可变散列容器
(2)语法：字典名 = {键1:值,键2:值}
(3)案例：
dict_bjlz = {
"name":"八角笼中","type":"剧情",
"actor":"王宝强","index":690761,
}
print("名称" + dict_bjlz["name"])5.4.1.4散列
(1)定义：通过哈希算法将键转换为对应存储位置的容器类型
(2)特点1：无需遍历，直接计算存储位置，速度最快
list_movie = [("八角笼中","剧情"),("消失的她","犯罪")]
for item in list_movie:
if item[0] == "消失的她":
print(item[1])
dict_movie = {"八角笼中":"剧情","消失的她":"犯罪"}
print(dict_movie["消失的她"])特点2：键必须唯一且只能是不可变类型的数据
dict_movie = {"剧情":"八角笼中","剧情":"满江红"}
print(dict_movie) # {"剧情":"满江红"}
# TypeError: unhashable type: 'list'
dict_movie = {["王宝强","陈永胜"]:"八角笼中"}(3)缺点：在内存中元素没有顺序且占用空间较大
(4)内存图
练习：
创建字典存储台湾的地区、新增、现有人数
创建字典存储陕西的地区、新增、现有人数
创建字典存储浙江的地区、新增、现有人数
5.4.2 基础操作
5.4.2.1 添加元素
(1)作用：将键值对添加到字典中
(2)语法：字典名[键] = 值
(3)案例：
dict_bjlz = {
"name":"八角笼中","type":"剧情",
}
dict_bjlz["actor"] = "王宝强"
dict_bjlz["index"] = 690761(4) 内存图：
(5) 练习：根据表格数据，为台湾、陕西、浙江三个字典添加累计、治愈人数
5.4.2.2 定位元素
(1)作用：改变或读取字典中某个键对应的值
(2)语法：字典名[键] = 值
值 = 字典名[键]
(3)案例：
dict_bjlz = {
"name":"八角笼中","type":"剧情",
}
dict_bjlz["name"] = "封神第一部"
dict_bjlz["type"] = "战争"
print(dict_bjlz["name"])
type = dict_bjlz["type"](4)注意：键存在为修改,不存在为添加
(5) 练习：
在终端中打印台湾的现有人数
在终端中打印陕西的新增和现有人数
浙江新增和现有人数各增加1
广西现有和累计人数各减少2
5.4.2.3 删除元素
(1)作用：通过键删除键值对
(2)语法：del 字典名[键]
(3)案例：
dict_bjlz = {
"name":"八角笼中","type":"剧情",
}
del dict_bjlz["name"])(4)注意：列表删除时元素向前移动,字典删除时其他元素不移动
(5)内存图：
(6) 练习：
删除台湾现有信息
删除陕西新增和现有信息
删除浙江现有和累计信息
删除广西新增人数保留键(通过键修改值)
5.4.2.4 遍历元素
所有键
(1)作用：获取字典中所有键
(2)语法：
for key in 字典名:
变量key记录的是字典键
(3)案例：
dict_bjlz = {
"name":"八角笼中","type":"剧情",
}
for key in dict_bjlz:
print(key)所有值
(1)作用：获取字典中所有值
(2)语法：
for value in 字典名.values():
变量value记录的是字典值
(3)案例：
dict_bjlz = {
"name":"八角笼中","type":"剧情",
}
for value in dict_bjlz.values():
print(value)所有键和值
(1)作用：获取字典中所有值
(2)语法：
for key,value in 字典名.items():
变量key,value分别记录的是字典的键和值
(3)案例：
dict_bjlz = {
"name":"八角笼中","type":"剧情",
}
for key,value in dict_bjlz.items():
print(key)
print(value)练习：
在终端中打印台湾所有键(一行一个)
在终端中打印陕西所有值(一行一个)
在终端中打印浙江所有键和值(一行一个)
在台湾字典中查找值是2339对应的键名称
5.4.3字典推导式
(1)定义：通过简单的语法将可迭代对象转换为新字典
(2)作用：简化代码，避免了传统循环结构的繁琐，提高代码的可读性
(3)语法：
新字典 = [键:值 for 变量 in 可迭代对象]
新字典 = [键:值 for 变量 in 可迭代对象 if 条件]
(4)案例：将2个列表合并为一个字典
list_name = ["八角笼中","封神第1部","消失的她"]
list_pop = [921109,826748,189298]
dict_movie = {
list_name[i]:list_pop[i]for i in range(len(list_name))
}(5)适用条件：根据可迭代对象、构建新字典、过程够简单
6)不适用：
# 不支持while
dict_new = {}
while True:
item = input("请输入:")
dict_new[item] = item * 2
# 必须是空字典
dict_new = {5:25}
for num in range(5):
dict_new[num] = num * 2
# 不能有多余代码
dict_new = {}
for num in range(5):
dict_new[num] = num * 2
print(num)(7)练习：使用字典推导式，颠倒字典的键和值
dict_info = {
"1001":"台湾","1002":"陕西",
"1003":"浙江","1004":"广西",
}6 函数 function
6.1 pycharm快捷键
Ctrl + Q 快速查看文档
6.2 定义
(1) 用于封装一个特定的功能，表示一个功能或者行为。
(2) 函数是可以重复执行的语句块, 可以重复调用。
6.3 作用
提高代码的可重用性和可维护性（代码层次结构更清晰）。
6.4 基础语法
6.4.1 定义函数
(1) 语法：
def 函数名(形式参数):
函数体(2) 说明：
def 关键字：全称是define，意为”定义”。
函数名：对函数体中语句的描述，规则与变量名相同。
形式参数：函数定义者要求调用者提供的信息。
函数体：完成该功能的语句。
(3) 函数的第一行语句建议使用文档字符串描述函数的功能与参数。
# 形式参数：表面的不具体的数据
def attack(count):
"""
攻击
:param count:次数
"""
for __ in range(count):
print("直拳")
print("摆拳")
print("勾拳")7.4.2 调用函数
(1) 语法：函数名(实际参数)
(2) 说明：根据形参传递内容。
# 实际参数：真实的具体的数据
attack(5)
attack(2)练习： 定义函数,在终端中打印一维列表.
list01 = [5, 546, 6, 56, 76, ]
for item in list01:
print(item)
list02 = [7,6,879,9,909,]
for item in list02:
print(item)6.4.3 返回值
(1) 定义：
函数定义者告诉调用者的结果。
(2) 语法：
return 数据
(3) 说明：
return后没有语句，相当于返回 None。
函数体没有return，相当于返回None。
def func01():
print("func01执行了")
return 100
# 1. 调用者,可以接收也可以不接收返回值
func01()
res = func01()
print(res)
# 2.在Python语言中,
# 函数没有return或return后面没有数据,
# 都相当于return None
def func02():
print("func02执行了")
return
res = func02()
print(res) # None
# 3.return可以退出函数
def func03():
print("func03执行了")
return
print("func03又执行了")
func03()
# 4. return 可以退出多层循环嵌套
def func04():
while True:
while True:
while True:
# break 只能退出一层循环
print("循环体")
return
func04()练习1：创建计算治愈比例的函数
confirmed = int(input("请输入确诊人数:"))
cure = int(input("请输入治愈人数:"))
cure_rate = cure / confirmed * 100
print("治愈比例为" + str(cure_rate) + "%")练习2：定义函数,根据总两数,计算几斤零几两.:
提示：使用容器包装需要返回的多个数据
total_liang = int(input("请输入两:"))
jin = total_liang // 16
liang = total_liang % 16
print(str(jin) + "斤零" + str(liang) + "两")练习3：创建函数,根据课程阶段计算课程名称.
number = input("请输入课程阶段数：")
if number == "1":
print("Python语言核心编程")
elif number == "2":
print("Python高级软件技术")
elif number == "3":
print("Web全栈")
elif number == "4":
print("人工智能")练习4：创建函数,计算IQ等级
ma = int(input("请输入你的心里年龄："))
ca = int(input("请输入你的实际年龄："))
iq = ma / ca * 100
if iq>= 140:
print("天才")
elif iq >= 120:
print("超常")
elif iq >= 110:
print("聪慧")
elif iq >= 90:
print("正常")
elif iq >= 80:
print("迟钝")
else:
print("低能")6.5 可变／不可变类型在传参时的区别
(1) 不可变类型参数有:
数值型(整数，浮点数)
布尔值bool
None 空值
字符串str
元组tuple
(2) 可变类型参数有:
列表 list
字典 dict
(3) 传参说明：
不可变类型的数据传参时，函数内部不会改变原数据的值。
可变类型的数据传参时，函数内部可以改变原数据。
练习1：画出下列代码内存图，并写出打印结果。
def func01(p1, p2):
p1 = "孙悟空"
p2["八戒"] += 50
a = "悟空"
b = {"八戒": 100}
func01(a, b)
print(a) # ?
print(b) # ?练习2：画出下列代码内存图，并写出打印结果。
def func01(p1, p2):
p1 = 100
p2[0] = 200
a = [10]
b = [20]
func01(a, b)
print(a) # ?
print(b) # ?6.6 函数参数
6.6.1 实参传递方式argument
6.6.1.1 位置实参
定义：实参与形参的位置依次对应。
def fun01(p1, p2, p3):
print(p1)
print(p2)
print(p3)
# 位置实参:根据顺序与形参进行对应
fun01(1, 2, 3)6.6.1.2 关键字实参
定义：实参根据形参的名字进行对应。
def fun01(p1, p2, p3):
print(p1)
print(p2)
print(p3)
# 关键字实参:根据名字与形参进行对应
fun01(p1=1, p2=2, p3=3)
fun01(p2=2, p1=1, p3=3)6.6.2形参定义方式parameter
6.6.2.1 默认形参
(1) 语法：
def 函数名(形参名1=默认值1, 形参名2=默认值2, ...):
函数体
(2) 说明：
默认参数必须自右至左依次存在，如果一个参数有默认值，则其右侧的所有参数都必须有默认值。
def func01(p1 =0, p2="", p3=100):
print(p1)
print(p2)
print(p3)
func01(p2=2)
func01(p2=2,p3=3)
# 支持同时使用位置实参与关键字实参
func01(1,p3=3)
# 注意1:先位置实参,后关键字实参
# func01(p1 =1,2,3) # 错误练习：
定义函数,根据小时、分钟、秒,计算总秒数
调用：提供小时、分钟、秒
调用：提供分钟、秒
调用：提供小时、秒
调用：提供分钟
6.6.2.2 位置形参
语法：
def 函数名(形参名1, 形参名2, ...):
函数体
7 作用域
7.1 定义
变量起作用的范围。
7.2 分类
(1) Local局部作用域：函数内部。
(2) Global全局作用域：模块(.py文件)内部。
7.3 变量名的查找规则
在访问变量时，先查找局部变量，之后是全局变量。
7.4 局部变量
(1) 定义在函数内部的变量(形参也是局部变量)
(2) 只能在函数内部使用
(3) 调用函数时才被创建，函数结束后自动销毁
7.5 全局变量
(1) 定义在函数外部,模块内部的变量。
(2) 在整个模块(py文件)范围内访问（但函数内不能将其直接赋值）。
7.6 global 语句
(1) 作用：
在函数内部修改全局变量。
在函数内部定义全局变量(全局声明)。
(2) 语法：
global 变量1, 变量2, …
(3) 说明
在函数内直接为全局变量赋值，视为创建新的局部变量。
不能先声明局部的变量，再用global声明为全局变量。
# 2. 全局作用域:文件内部
# 全局变量:在全部作用域内创建的变量
# 适用范围:整个文件
data02 = 20
data03 = [30]
def func01():
# 1. 局部作用域:函数内部
# 局部变量:在局部作用域内创建的变量
# 适用范围:一个函数
data01 = 10
print(data01)
print(data02)
def func02():
# print(data01) # 不能访问其他函数局部变量
print(data02) # 读取全局变量
def func03():
# 在局部作用域中不能修改全局变量
# data02 = 200
# 必须通过global语句声明
global data02
data02 = 200
def func04():
# 没有修改全局变量
# 在修改全局变量指向的列表
# 所以不需要通过global语句声明
data03[0] = 300
func01()
func02()
func03()
func04()
print(data02) # 200
print(data03) # [300]