1. 导学

1.1 学习理念

1.1.1 弱语法，重本质

是一种弱化语言规则，注重程序原理的学习过程。
语法是表象，只有了解深层机理，才能灵活运用。
学习编程要深入内存，剖析原理，才能看透语法。
就像太极“用意不用力，先在心后在身”的道理。

1.1.2 是技术，更艺术

编程是一门技术，但更是一种艺术。
写出高质量的代码（功能性、维护性，灵活性），享受编程所带来的乐趣。

1.2 学习方法

1.2.1 当天知识必须理解

What 是什么，即理解知识点的定义。
Why 为什么，即理解知识点的作用。
Where 在哪里，即理解知识点的适用性。
How 如何使用，即理解知识点的语法。

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：改变工作目录（进入到某个目录）

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) 建议命名：字母小写，多个单词以下划线隔开。

3.2.2 人机交互

3.2.2.1定义

用户与计算机之间的互动过程，目的是让计算机更好地满足用户需求

3.2.2.2函数

封装了一个特定 功能 的代码块，可以重复调用比如终端中输入用input函数，输出用print函数对于功能的内部实现，暂时不用了解，先会调用即可
(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 字符串str

(1) 用来记录文本信息(文字信息)。
(2) 字面值：双引号

name = "世界"
print("你好:" + name) # 文本拼接

3.2.3.2 整形int

表示整数，包含正数、负数、0。
如： -5, 100, 0

3.2.3.3 浮点型float

(1) 表示小数，包含正数、负数，0.0。
(2) 字面值：
小数：1.0 2.5

3.3 运算

3.3.1 类型转换

(1) 语法：
变量名 = 目标类型(待转数据)
(2) 例如：

变量名 = int(数据)
变量名 = float(数据)
变量名 = str(数据)
(3) 适用性：
输入数据、输出结果
(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"))# 报错

3.3.2 算数运算

3.3.2.1 算术运算符

3.3.3.2 增强运算符

data01 = 10
# data01 + 5
# print(data01) # 10
data01 += 5 # data01 = data01 + 5
print(data01) # 15

3.3.3 布尔运算

3.3.3.1 布尔类型

表示条件是否成立，只有两个值：True和False
True 表示满足条件、False 表示不满足条件

3.3.3.2 比较运算符

用于表达单个条件
返回布尔类型的值
比较运算的数学表示方式:0 <= x <= 100
案例：

# 存款大于500000
print(int(input("说存款"))>=500000)
# 有房产
print(input("说房产")=="有")
# 黄金年龄
print(25 <= int(input("说年龄"))<= 35)

3.3.3.3 逻辑运算符

用于表达多个条件
(1) 与and

int(input("请输存款:")) >= 100000 and input("请输房产:") == "有"

(2) 或or

int(input("请输存款:")) > 100000 and input("请输房产:") == "有"

(3) 非 not

(4) 短路运算
一但结果确定，后面的语句将不再执行。

3.3.4优先级

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) 语法:

4.2.2 省略else

4.2.3 elif

4.2.4 if嵌套

4.3 循环语句

4.3.1 while语句

4.3.1.1延长程序生命

4.3.1.2循环计数

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)

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)

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)内存图：

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

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,"八角笼中")

list_movie = ["八角笼中","封神第1部","消失的她"]
list_movie[:2] = ["满江红","流浪地球"]

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] = ["满江红","流浪地球"]

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("大话西游") # 报错

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

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.4深浅拷贝对比

深、浅拷贝是复制数据的两种方式。
深拷贝复制所有层的数据，拷贝后的数据完全独立。
优点是修改数据时互不影响，缺点是占用内存较大。
浅拷贝复制第一层的数据，共享深层的数据。
优点是占用内存较少，缺点是修改深层数据互相影响。
当需要拷贝的数据具有深层数据，建议使用深拷贝，否则使用浅拷贝。
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)适用性
使用条件：根据可迭代对象、构建新列表、过程够简单

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.3遍历元组

从头到尾读取满足条件的元素
for 变量名 in 列表名:
变量名就是元素

list_pop = [921109,826748,189298]
for item in list_pop:
	if item > 500000:
		print(item )

5.2.2.4序列拆包

定义：将序列元素分配给多个变量的操作
作用：操作序列元素更方便，代码更简洁
语法：变量名1,变量名2 = 序列

a,b,c = ["王宝强","周润发","王学兵"]
a,b,c = ("王宝强","周润发","王学兵")

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 不可变

采取"按需分配"的存储策略，节省内存空间
修改数据时若在原有空间，可能破坏其他数据
所以每次修改都会创建新数据，替换变量中记录的数据地址
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))

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.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.4.2.3 删除元素

(1)作用：通过键删除键值对
(2)语法：del 字典名[键]
(3)案例：

dict_bjlz = {
"name":"八角笼中","type":"剧情",
}
del dict_bjlz["name"])

(4)注意：列表删除时元素向前移动,字典删除时其他元素不移动
(5)内存图：

5.4.2.4 遍历元素

所有键
(1)作用：获取字典中所有键
(2)语法：
for key in 字典名:
dict_bjlz = {
“name”:“八角笼中”,“type”:“剧情”,
}
del dict_bjlz[“name”])
变量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)

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)

5.5 容器嵌套

5.5.1字典内嵌元组

(1)数据
(2)代码

dict_bjlz = {
	"name":"八角笼中","type":("剧情","动作"),
	"actor":"王宝强","index":690761,
}
print("名称" + dict_bjlz["type"])

(3)内存图

5.5.2 列表内嵌字典

(1)数据
(2)代码

list_movie = [
{"name":"八角笼中","index":690761},
{"name": "封神第一部","index": 532622}
]
print(list_movie[0]) # {"name":"八角笼中","index":690761}
print(list_movie[1]["name"]) # "封神第一部"

(3)内存图
(4)基础操作

list_movie = [
	{"name":"八角笼中","index":690761},
	{"name": "封神第一部","index": 532622}
]
# 1. 添加
dict_movie = {"name":"消失的她","index":446700}
list_movie.append(dict_movie)
# 2. 定位
# 2.1 读取
for item in list_movie:
	print("电影名:%s,热搜指数:%s"%(item["name"],item["index"]))
# 2.2 修改
for item in list_movie:
	list_movie[i]["index"] += 10
# 3. 删除
for i in range(len(list_movie)):
	if list_movie[i]["name"] == "八角笼中":
	del list_movie[i]
	break

6. 函数 function

6.1 为何自定义函数

(1)需求：修改多个游戏场景中角色攻击的代码，需要重复修改多次

(2)函数作用：将功能的做法与用法分离，需求变化时只需要修改一次做法

6.2 如何自定义函数

(1) 创建语法

(2) 调用语法

6.3 何时自定义函数

为提高代码复用性：如果在程序中有一段代码需要在多个地方使用，可以将其定义在一个函数中，以便在需要时重复调用。
为提高代码可读性：将复杂的代码逻辑拆分成较小的函数，可以提高代码的可读性。函数有明确的名称和参数，可以使代码更加清晰易懂。
为提高代码安全性：将敏感操作或复杂计算定义在函数内部，避免在其他部分直接访问或修改实现细节，可以使代码更加安全。

6.4 语法

6.4.1 定义函数

(1) 语法：

def 函数名(形式参数):
	函数体

(2) 函数的第一行语句建议使用文档字符串描述函数的功能与参数。

# 形式参数：表面的不具体的数据
def attack(count):
	"""
		攻击
	:param count:次数
	"""
for __ in range(count):
	print("直拳")
	print("摆拳")
	print("勾拳")

6.4.2 调用函数

(1) 语法：函数名(实际参数)
(2) 说明：根据形参传递内容。

# 实际参数：真实的具体的数据
attack(5)
attack(2)

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

6.5 可变／不可变类型在传参时的区别

(1) 不可变类型参数有:
数值型(整数，浮点数)
布尔值bool
None 空值
字符串str
元组tuple
(2) 可变类型参数有:
列表 list
字典 dict
(3) 传参说明：
不可变类型的数据传参时，函数内部不会改变原数据的值。
可变类型的数据传参时，函数内部可以改变原数据。

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.1.3 序列实参

定义：实参用*将序列拆解后与形参的位置依次对应。

6.6.1.4 字典实参

定义：实参用**将字典拆解后与形参的名字进行对应。

6.6.2形参定义方式parameter

6.6.2.1 位置形参

语法：
def 函数名(形参名1, 形参名2, …):
函数体

6.6.2.2 默认形参

(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.3 星号元组形参

(1) 语法：

def 函数名(*元组形参名):
		函数体

(2) 作用：
收集多余的位置传参。
(3) 说明：
一般命名为’args’
形参列表中最多只能有一个

6.6.2.4 双星号字典形参

(1) 语法：

def 函数名(**元组形参名):
	  函数体

(2) 作用：
收集多余的关键字传参
(3) 说明:
一般命名为’kwargs’
形参列表中最多只能有一个

6.6.2.5 命名关键字形参

(1) 语法：

def 函数名(**元组形参名):
	函数体

(2) 作用：
收集多余的位置传参。
(3) 说明：
一般命名为’args’
形参列表中最多只能有一个

6.6.3 参数顺序

形式参数：位置形参 --> 星号元组形参 --> 命名关键字形参 --> 双星号字典形参
实际参数：位置实参 --> 关键字实参

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]