1.Python概述
1.1.概述
- 起源于1989年，发行于1991年，是一个免费、开源、跨平台、动态、面型对象的编程语言。
1.2.语言优势
- 简单高效：容易上手，开发效率比其它主流语言高1/3~1/5；
- 适应性广：Python语言不仅适合专业人员，也适合非专业人员学习、使用；
- 应用广泛：软件开发的各种领域都可以使用；
- 资源丰富：Django/Requests/Numpy/Pandas/Matpotlib/TensorFlow/PyTorch/Scikit-learn…
1.3.适用岗位
- Web服务端开发
- 爬虫
- 数据分析
- 机器学习
- 自动化测试
- 自动化运维
2.Python基础体系
- Python核心：Python介绍、数据基本运算、语句、容器、函数；
3.Python核心
3.1.基础介绍
硬件：
1944年，美籍匈牙利数学家冯·诺依曼提出计算机基本机构。包含五大组成部分：运算器、控制器、存储器、输入设备、输出设备，即冯·诺依曼架构。
- 运算器：按照程序中的指令，对数据进行加工处理。
- 控制器：根据程序需求，指挥计算机的各个部件协调工作。
- 通常将运算器和控制器集成在中央处理器（CPU）中。
- 存储器：保存各类程序的数据信息。
- 内存RAM：容量小，速度快，临时存储数据
- 硬盘HDD：容量大，速度慢，永久存储数据
- 输入设备：外界向计算机传送信息的装置
- 例如：鼠标、键盘、扫描仪…
- 输出设备：计算机向外界传送信息的装置
- 例如：显示器、音响、打印机…
软件：
没有软件的计算机称之为裸机，无法完成任何工作
- 操作系统：管理和控制计算机软件与硬件资源的程序
- 隔离不同硬件差异，使软件开发简单化
- Windows、Linux、Unix
- 应用软件：为了某种特定的用途而被开发的软件
- 软件：软件=程序+文档
- 程序是一组计算机能识别和执行的指令集合
- 文档是为了便于了解程序所需的说明性材料
3.2.基础知识
3.2.1.Python环境安装与配置
3.2.1.1.Python安装
下载地址：https://www.python.org/ftp/python/
选用版本：python-3.8.9-amd64.exe
检查python是否安装成功：
①win+r，输入cmd，进入命令行窗口
②在命令行窗口中输入python，出现如下信息，python安装成功
3.2.1.2.Pycharm安装
下载：https://www.jetbrains.com/pycharm/download/
1.找到你下载PyCharm的路径，双击.exe文件进行安装。
2.点击 Next 后，我们进行选择安装路径页面（尽量不要选择带中文和空格的目录）选择好路径后，点击 Next 进行下一步
3.进入 Installation Options（安装选项）页面，全部勾选上。点击 Next
4.进入 Choose Start Menu Folder 页面，直接点击 Install 进行安装
5.等待安装完成后出现下图界面，我们点击 Finish 完成。
3.2.2.Python程序的执行方式
3.2.2.1.交互式
在命令行输入指令，回车即可得到结果。
(1) 打开终端
(2) 进入交互式：python3
(3) 编写代码：print(“hello world”)
(4) 离开交互式：exit()
3.2.2.2.文件式
将指令编写到.py文件，可以重复运行程序。
(1) 编写文件
(2) 打开终端
(3) 进入程序所在目录：cd目录
(4) 执行程序： python3 文件名
3.2.2.3.Linux常用命令
(1) pwd：查看当前工作目录的路径
(2) cd：改变工作目录（进入到某个目录）
练习：
(1) 在指定目录创建python文件.
–目录：/home/tarena/month01
–文件名：exercise01.py
(2) 在文件中写入：print(“你好，世界!”)
(3) 运行python程序
3.2.2.4.执行过程
计算机只能识别机器码(1010)，不能识别源代码(python)。
(1)由源代码转变成机器码的过程分成两类：编译和解释。
(2)编译：在程序运行之前，通过编译器将源代码变成机器码，例如：C语言。
– 优点：运行速度快
– 缺点：开发效率低，不能跨平台。
(3)解释：在程序运行之时，通过解释器对程序逐行翻译，然后执行，例如Javascript。
– 优点：开发效率高，可以跨平台；
– 缺点：运行速度慢。
(4)python是解释型语言，但为了提高运行速度，使用了一种编译的方法。编译之后得到pyc文件，存储了字节码（特定于Python的表现形式，不是机器码）
源代码 – 编译 --> 字节码 – 解释 --> 机器码
|————1次———|
3.2.2.5.解释器类型
(1) CPython（C语言开发)
(2) Jython (java开发)
(3) IronPython (.net开发)
3.3.数据基本运算
"""
汇率转换器
"""
# 1. 获取数据 - 美元
usd = input("请输入美元:")
# 2. 逻辑处理 - 美元 * 6.99
cny = int(usd) * 6.99
# 3. 显示结果 - xx美元是xx人民币
print(usd + "美元是" + str(cny) + "人民币")
3.3.1.基础知识
3.3.1.1.Pycharm常用快捷键
(1) 移动到本行开头：home键
(2) 移动到本行末尾：end键盘
(3) 注释代码：ctrl + /
(4) 复制行：ctrl +d
(5) 删除行：shift + delete
(6) 选择列：shift + alt +鼠标左键
(7) 移动行：ctrl + shift + 上下箭头
(8) 代码格式化：ctrl+alt+l
(9) project窗口开启/关闭 ALT+1
3.3.1.2.注释
通常是对代码的描述信息。
(1) 单行注释：以#号开头。
(2) 多行注释：三引号开头，三引号结尾。
3.3.2.数据
3.3.2.1.变量
定义：在内存中操作数据的空间。
语法：变量名 赋值号 数据，如：num = 88。
复用性：一个变量可以被多次使用，重复操作一个数据，以提高代码的可读性。
可变性：一个变量可以被重复赋值，实现对程序状态的调节以适应现实环境的变化。
命名：由字母、数字、下划线组成，且不能以数字开头。不能使用关键字(蓝色)，否则发生语法错误SyntaxError。
建议命名：字母小写，多个单词以下划线隔开。Class_name = “xxx”
3.3.2.2.函数
封装了一个特定功能的代码块，可以重复调用
比如：终端中输入用input函数，输出用print函数
(1) input函数
作用：将终端中用户输入的数据存储在程序中
语法：变量 = input(提示信息)
应用：输入数据
name = input("请输入姓名:")
age = input("请输入年龄:")
print(name + "的年龄是:" + age + ".")
(2) print函数
作用：将括号中的数据显示在终端中
语法：print(数据)
应用：呈现结果
usd = input("请输入美元:")
cny = input("请输入人民币:")
print(usd + "美元=" + cny + "人民币")
表示一个功能，函数定义者是提供功能的人，函数调用者是使用功能的人。
(1)print(数据) 作用：将括号中的内容显示在控制台中
print("你好")
print("世界")
(2)变量 = input(“需要显示的内容”) 作用：将用户输入的内容赋值给变量
name = input("请输入姓名:")
age = input("请输入年龄:")
print(name + "的年龄是:" + age + ".")
3.3.2.3.字符串 str
(1) 用来记录文本信息(文字信息)。
(2) 字面值：双引号
3.3.2.4.整形int
表示整数，包含正数、负数、0。
如： -5, 100, 0
3.3.2.5.浮点型float
(1) 表示小数，包含正数、负数，0.0。
(2) 字面值：小数：1.0 2.5
3.3.3.运算
3.3.3.1.类型转换
(1) 语法：
变量名 = 目标类型(待转数据)
(2) 例如：
usd = input(“请输入美元:”)
cny = input(“请输入人民币:”)
print(usd + “美元=” + cny + “人民币”)
name = “大圣”
print(“您好:” + name) # 文本拼接
变量名 = 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"))# 报错
练习：在终端中输入商品单价、购买的数量和支付金额。计算应该找回多少钱。
效果：
请输入商品单价：5
请输入购买数量：3
请输入支付金额：20
应找回：5.0
price = float(input("请输入商品单价："))
num = int(input("请输入购买数量："))
amount = float(input("请输入支付金额："))
res = (amount-price*num)
print("应找回：" + str(res))
3.3.3.2.算数运算
3.3.3.2.1.算术运算符
练习1：在终端中输入一个疫情确诊人数再录入一个治愈人数，打印治愈比例
格式：治愈比例为xx%
效果：
请输入确诊人数：500
请输入治愈人数：495
治愈比例为99.0%
num1 = int(input("请输入确诊人数："))
num2 = int(input("请输入治愈人数："))
percent = num2 / num1 * 100
print("治愈比例为" + str(percent) + "%")
练习2：古代的秤，一斤十六两。在终端中获取两，计算几斤零几两。
效果：
请输入总两数：100
结果为：6斤4两
nums = int(input("请输入总两数："))
weight1 = nums//16
weight2 = nums%16
print("结果为：" + str(weight1) + "斤" + str(weight2) + "两")
3.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
num = int(input("请输入四位整数："))
num1 = num//1000
num2 = num%1000//100
num3 = num%100//10
num4 = num%10
res = num1 + num2 + num3 + num4
print("结果是：" + str(res))
3.3.3.3.布尔运算
3.3.3.3.1.布尔类型
表示条件是否成立，只有两个值：True和False
True 表示满足条件、False 表示不满足条件
3.3.3.3.2.比较运算符
返回布尔类型的值
比较运算的数学表示方式: 0 <= x <= 100
# 存款大于500000
print(int(input("说存款"))>=500000)
# 有房产
print(input("说房产")=="有")
# 黄金年龄
print(25 <= int(input("说年龄"))<= 35)
练习： 根据条件写出代码
输入的是正数：大于零
输入的是偶数：能被2整除
输入的是星期：1到7之间
print(int(input("输入的是正数"))>0)
print(int(input("输入的是偶数"))%2==0)
print(7>=int(input("输入的是星期"))>=1)
3.3.3.3.3.逻辑运算符
1)与and：表示并且的关系，类似串联
int(input(“请输存款:”)) >= 100000 and input(“请输房产:”) == “有”
2)或or：表示或者关系，类似并联
int(input(“请输存款:”)) > 100000 or input(“请输房产:”) == “有”
3)非not：表示取反
练习:根据命题写出代码
年龄大于25 并且 身高小于170
职位是高管 或者 年薪大于500000
print(int(input("请输入年龄："))>25 and int(input("请输入身高：")) < 170 )
print(input("请输入职位：") == "高管" or int(input("请输入年薪：")) > 500000)
3.3.3.4.优先级
3.4.语句
3.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)
3.4.2.选择语句
3.4.2.1.if else 语句
(1) 作用:
让程序根据条件有选择性的执行
(2) 语法:
if 条件:
满足条件内容
else:
不满足条件内容
练习:
在终端中输入体温，如果在36到37之间，输出正常，否则异常。
tem = float(input("输入体温："))
if 37 > tem > 36 :
print("体温正常")
else:
print("体温异常")
3.4.2.2.省略else
if 条件:
满足条件内容
练习：
在终端中输入课程阶段数，显示课程名称
效果：
输入： 输出：
1 Python语言核心编程
2 Python高级软件技术
3 Web全栈
4 人工智能
num = int(input("请输入课程阶段数:"))
if num == 1 :
print("Python语言核心编程")
if num == 2 :
print("Python高级软件技术")
if num == 3 :
print("Web全栈")
if num == 4 :
print("人工智能")
3.4.2.3.elif
if 条件1:
满足条件1内容
elif 条件2:
满足条件2内容
elif 条件3:
满足条件3内容
else:
均不满足
练习1:
在终端中输入一个数字，判断后输出正数或者负数或者零。
num = int(input("请输入一个数字："))
if num > 0:
print("正数")
elif num < 0:
print("负数")
else:
print("0")
练习2：
根据心理年龄与实际年龄，打印智商等级。
智商IQ = 心理年龄MA 除以 实际年龄CA 乘以 100
天才：140以上（包含）
超常：120-139之间（包含）
聪慧：110-119之间（包含）
正常：90-109之间（包含）
迟钝：80-89之间（包含）
低能：80以下
ma = int(input("请输入心理年龄："))
ca = int(input("请输入实际年龄："))
iq = int(ma / ca * 100)
if iq >= 140:
print("天才")
elif 120 <= iq <= 139:
print("超常")
elif 110 <= iq <= 119:
print("聪慧")
elif 90 <= iq <= 109:
print("正常")
elif 80 <= iq <= 89:
print("迟钝")
else:
print("低能")
3.4.2.4.if嵌套
if 条件:
if 条件1:
满足条件2内容
elif 条件2:
满足条件2内容
elif 条件3:
满足条件3内容
else:
均不满足
练习：
在终端中输入月份，打印相应的天数.
1 3 5 7 8 10 12 有 31天
2 有 29天
4 6 9 11 有 30天
超过月份提示月份有误
效果：
请输入月份:10
31天
mon = int(input("请输入月份："))
if 1 <= mon <= 12:
if mon == 2:
print("29天")
elif mon == 4 or mon == 4 or mon == 6 or mon == 9 or mon == 11:
print("30天")
else:
print("31天")
else:
print("月份有误")
3.4.3.循环语句
3.4.3.1.while语句
3.4.3.1.1.延长程序生命
练习：
让下列代码重复执行，输入y继续(不输入y则退出)
number = int(input("请输入数字："))
if number > 0:
print("正数")
elif number < 0:
print("负数")
else:
print("零")
while input("输入y继续：") == "y":
number = int(input("请输入数字："))
if number > 0:
print("正数")
elif number < 0:
print("负数")
else:
print("零")
3.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
count = 0
while count < 4:
print(count)
count += 1
print("--------------------")
count = 2
while count < 7:
print(count)
count += 1
print("--------------------")
count = 1
while count < 8:
if count % 2 != 0:
print(count)
count += 1
print("--------------------")
count = 8
while count > 3:
print(count)
count -= 1
print("--------------------")
count = -1
while count > -6:
print(count)
count -= 1
练习2：
一张纸的厚度是0.01毫米
请计算，对折多少次超过珠穆朗玛峰(8844.43米)
思路:
数据：厚度、高度、次数
算法：厚度*=2 次数+=1
num = 0
height = 0.01
while height / 1000 < 8844.43:
height *= 2
num += 1
print("对折" + str(num) + "次超过珠穆朗玛峰")
练习3：
程序产生1个,1到100之间的随机数。
让玩家重复猜测,直到猜对为止。
每次提示：大了、小了、恭喜猜对了,总共猜了多少次。
效果：
请输入要猜的数字:50
大了
请输入要猜的数字:25
小了
请输入要猜的数字:35
大了
请输入要猜的数字:30
小了
请输入要猜的数字:32
恭喜猜对啦,总共猜了5次
import random
num = random.randint(1, 100)
count = 0
while True:
temp = int(input("请输入要猜的数字："))
count += 1
if temp > num:
print("大了")
elif temp < num:
print("小了")
else:
print("恭喜猜对了，总共猜了"+ str(count) +"次")
break
3.4.3.2.for 语句
for 变量 in range(开始,结束,间隔):
语句组
# 写法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
sum1 = 0
for i in range(4):
sum1 = sum1 + i
print(i)
print("累加的和为：" + str(sum1))
print("----------------------")
sum2 = 0
for i in range(2, 7):
sum2 = sum2 + i
print(i)
print("累加的和为：" + str(sum2))
print("----------------------")
sum3 = 0
for i in range(1, 8, 2):
sum3 = sum3 + i
print(i)
print("累加的和为：" + str(sum3))
print("----------------------")
sum4 = 0
for i in range(8, 3, -1):
sum4 = sum4 + i
print(i)
print("累加的和为：" + str(sum4))
print("----------------------")
sum5 = 0
for i in range(-1, -6, -1):
sum5 = sum5 + i
print(i)
print("累加的和为：" + str(sum5))
print("----------------------")
练习2：一张纸的厚度是0.01毫米请计算，对折15次的厚度是多少毫米
weight = 0.01
for i in range(15):
weight *= 2
print("对折" + str(i+1) + "次")
print("对折15次后纸的厚度是：" + str(weight) + "毫米")
练习3：程序产生一个1到100之间的随机数，让玩家最多重复猜5次
每次提示：大了、小了、恭喜猜对了,总共猜了多少次。
import random
res = False
num = random.randint(1, 100)
print("===============猜猜看，最多猜5次===============")
for i in range(5):
tem = int(input("请输入要猜的数字："))
if tem > num:
print("大了")
elif tem < num:
print("小了")
else:
print("恭喜猜对了,总共猜了" + str(i + 1) + "次！")
res = True
if not res:
print("对不起，您的次数已用完，请重启程序再试！")
3.4.3.3.对比
- while 循环
擅长于根据条件重复
例如：纸张对折到珠穆朗玛峰 - for循环
擅长于根据次数重复
例如：纸张对折15次
3.4.4.跳转语句
3.4.4.1.break 语句
跳出循环体，后面的代码不再执行。
3.4.4.2.continue 语句
跳过当前循环体中剩余代码，继续执行下一次循环
# 需求：累加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的整数和
思路1：个位不是3/5/8则累加
思路2：个位是3/5/8就跳过，否则累加
total = 0
for i in range(10, 61):
if i % 10 == 3 or i % 10 == 5 or i % 10 == 8:
continue
total += i
print("累加10 -- 60之间，个位不是3/5/8的整数和为：" + str(total))
3.5.容器
3.5.1.列表list
在Python中可以使用列表，对日常生活中的大量数据进行管理，若没有列表类型，一个变量只能操作一个数据；手动为每个数据创建变量，无法动态添加数据。
定义：由一系列变量组成的可变序列容器。
语法：
列表名 = [元素1,元素2,元素3]
案例：list_mov = [“电影1”,“电影2”,“电影3”]
练习：
创建列表存储3个地区名称
创建列表存储3个新增人数
创建列表存储3个现有人数
list_area = ["台湾", "陕西", "浙江"]
list_add_person = [16, 182, 2]
list_cur_person = [2339, 859, 505]
3.5.1.1.序列
定义：有顺序且空间连续的容器类型。
基础操作：
+：用于连接两个容器
*：重复生成容器元素
list_movie01 = ["电影1"]
list_movie02 = ["电影2","电影3"]
list_movie03 = list_movie01 + list_movie02 # ["电影1","电影2","电影3"]
list_movie04 = list_movie01 * 2 # ["电影1","电影1"]
成员运算：
作用：判断容器中是否存在某一元素
语法：in not in
list_movie = ["电影1","电影2","电影3"]
print("电影1" in list_movie) # True
print("电影22" not in list_movie) # True
print("3" in list_movie) # False
常用函数：
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
list_area = ["台湾", "陕西", "浙江"]
list_add_person = [16, 182, 2]
list_cur_person = [2339, 859, 505]
# 计算新增列表最大值
print(max(list_add_person))
# 计算现有列表最小值
print(min(list_cur_person))
# 对新增列表进行求和
print(sum(list_add_person))
# 判断现有列表是否存在859
print(859 in list_cur_person)
3.5.1.2.基础操作
3.5.1.2.1.添加元素
列表名.append(元素)
列表.insert(索引，元素)
list_movie = ["电影1"]
list_movie.append("电影2")
list_movie.append("电影3")
print(list_movie) # ["电影1","电影2","电影3"]
list_movie = ["电影1","电影2"]
list_movie.insert(0,"电影3")
练习1：
向地区、新增、现有三个列表中添加第四行信息
将第五行信息插入到地区、新增、现有三个列表中第一个位置
list_area = ["台湾", "陕西", "浙江"]
list_add_person = [16, 182, 2]
list_cur_person = [2339, 859, 505]
# 向地区、新增、现有三个列表中添加第四行信息
list_area.append("广西")
list_add_person.append(6)
list_cur_person.append(256)
# 将第五行信息插入到地区、新增、现有三个列表中第一个位置
list_area.insert(0, "香港")
list_add_person.insert(0, 9)
list_cur_person.insert(0, 196)
print(list_area)
print(list_add_person)
print(list_cur_person)
3.5.1.2.2. 定位元素
列表名[索引] = 元素
变量 = 列表名[索引]
变量 = 列表名[切片] # 赋值给变量的是切片所创建的新列表
列表名[切片] = 容器 # 右侧必须是可迭代对象，左侧切片没有创建新列表
list_movie = ["电影1","电影2","电影3"]
list_movie[0] = "电影4"
list_movie = ["电影1","电影2","电影3"]
list_movie[:2] = ["电影4","电影5"]
list_movie = ["电影1","电影2","电影3"]
list_new = 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)
3.5.1.2.3.删除元素
列表名.remove(元素)
del 列表名[索引或切片]
list_movie = ["电影1","电影2","电影3"]
del list_movie[0]
del list_movie[:2]
print(list_movie) # []
list_movie = ["电影1","电影2","电影3"]
list_movie.remove("电影2")
print(list_movie) # ["电影1","电影3"]
list_movie.remove("电影11") # 报错
3.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
list_area = ["台湾", "陕西", "浙江"]
list_add_person = [16, 182, 2]
list_cur_person = [2339, 859, 505]
# 打印新增列表小于10的元素
for item in list_add_person:
if (item < 10):
print(item)
print("----------------------")
# 现有列表所有元素累加2
for i in range(len(list_cur_person)):
list_cur_person[i] += 2
print(list_cur_person)
综合练习
八大行星：“水星” “金星” “地球” “火星” “木星” “土星” “天王星” “海王星”
– 创建列表存储4个行星：“水星” “金星” “火星” “木星”
– 插入"地球"、追加"土星" “天王星” “海王星”
– 打印距离太阳最近、最远的行星(第一个和最后一个元素)
– 打印太阳到地球之间的行星(前两个行星)
– 删除"海王星",删除第四个行星
– 打印所有行星(一行一个)
# "水星" "金星" "地球" "火星" "木星" "土星" "天王星" "海王星"
# -- 创建列表存储4个行星：“水星” "金星" "火星" "木星"
list_start = ["水星", "金星", "火星", "木星"]
# -- 插入 "地球"、追加"土星" "天王星" "海王星"
list_start.insert(4, "地球")
list_start.append("土星")
list_start.append("天王星")
list_start.append("海王星")
# -- 打印距离太阳最近、最远的行星(第一个和最后一个元素)
print("距离太阳最近：" + list_start[0] + "，最远的行星：" + list_start[len(list_start)-1])
# -- 打印太阳到地球之间的行星(前两个行星)
print("距离太阳最近：" + list_start[0] + "，最远的行星：" + list_start[1])
# -- 删除 "海王星", 删除第四个行星
list_start.remove("海王星")
del list_start[3]
# -- 打印所有行星(一行一个)
for item in list_start:
print(item)
3.5.1.3.列表拷贝
3.5.1.3.1.为什么需要拷贝
(1)避免数据意外修改
有时候需要将可变数据传递给函数，并且希望函数对这个可变数据的操作不影响原始数据。
(2)保存数据原始快照
在某些情况下，需要创建一个相同状态的数据副本，以便之后可以对比或回滚到先前的状态。
3.5.1.3.2.什么是深拷贝
深拷贝复制所有层的数据，拷贝后的数据完全独立。
import copy
list_movie = ["电影1",["电影2","电影3"]]
list_new = copy.deepcopy(list_movie)
list_new[0] = "电影10"
list_new[1][1] = "电影11"
print(list_movie) # ['电影1', ['电影2', '电影3']]
3.5.1.3.3.什么是浅拷贝
浅拷贝复制第一层的数据，共享深层的数据。
list_movie = ["电影1",["电影2","电影3"]]
list_new = list_movie[:] # 切片触发浅拷贝
list_new[0] = "电影10"
list_new[1][1] = "电影11"
print(list_movie) # ['电影1', ['电影2', '电影11']]
3.5.1.3.4.深浅拷贝对比
深、浅拷贝是复制数据的两种方式。
深拷贝复制所有层的数据，拷贝后的数据完全独立。优点是修改数据时互不影响，缺点是占用内存较大。
浅拷贝复制第一层的数据，共享深层的数据。优点是占用内存较少，缺点是修改深层数据互相影响。
当需要拷贝的数据具有深层数据，建议使用深拷贝，否则使用浅拷贝。
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) # ['北京', ['上海', '深圳03']]
list02[0] = "北京02"
list02[1][1] = "深圳02"
# 普通拷贝，操作的是同一个对象
print(list01) # ['北京02', ['上海', '深圳02']]
3.5.1.4.列表推导式
需求：将大于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]
定义：通过简单的语法将可迭代对象转换为新列表
作用：简化代码，避免了传统循环结构的繁琐，提高代码的可读性
语法：
新列表 = [表达式 for 变量in 可迭代对象]
新列表 = [表达式 for 变量in 可迭代对象 if 条件]
案例：
# 将所有元素的个位存入新列表
list_number = [66,25,72,86,57]
list_new = [item % 10 for item in list_number]
适用性：
使用条件 => 根据可迭代对象、构建新列表、过程够简单
练习：
生成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]
# 生成10--30之间能被3或者5整除的数字
# 结果：[10, 12, 15, 18, 20, 21, 24, 25, 27]
list1 = [item for item in range(10, 30) if item % 3 == 0 or item % 5 == 0]
print(list1)
# 生成5 -- 20之间的数字平方
# 结果：[25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361]
list2 = [item**2 for item in range(5, 20)]
print(list2)
3.5.2.元组tuple
在Python中可以使用元组，存储不会变化的多个数据。
定义：由一系列变量组成的不可变序列容器。
语法：
元组名 = (元素1,元素2)
tuple_type = (“剧情”,“动作”)
与列表区别
元组用于存储无需变化的数据，所以采用"按需分配"的存储机制
列表用于存储需要变化的数据，所以采用"预留空间"的存储机制
可变数据为什么可变
存储机制：预留空间 + 自动扩容
自动扩容：开辟更大空间、拷贝原始数据、替换内存地址
不可变数据如何变化
每次变化都会产生新数据
tuple_type = (“剧情”,“动作”)
tuple_type += (“惊悚”,“科幻”)
3.5.2.1.基础操作
3.5.2.1.1.创建元组
元组名 = (元素1,元素2)
元组名 = 元素1,元素2 # 没有歧义时也可以省略小括号
元组名 = (元素1,) # 只有一个元素时必须添加逗号
name = “悟空”, # 小心:是元组不是字符串
3.5.2.1.2.定位元素
变量 = 元组名[索引]
变量 = 元组名[切片] # 创建新元组
tuple_type = (“剧情”,“动作”,“科幻”)
print(tuple_type[0]) # “剧情”
print(tuple_type[:2]) # (“剧情”,“动作”)
3.5.2.1.3.遍历元组
从头到尾读取满足条件的元素
for 变量名 in 元组名:
变量名
tuple_pop = (921109, 826748, 189298)
for item in tuple_pop:
if item > 500000:
print(item)
3.5.2.1.4.序列拆包
定义：将序列元素分配给多个变量的操作
作用：操作序列元素更方便，代码更简洁
语法：变量名1,变量名2 = 序列
a,b,c = [“王宝强”,“周润发”,“王学兵”]
a,b,c = (“王宝强”,“周润发”,“王学兵”)
练习：
根据月日,计算是这一年的第几天.
公式：前几个月总天数 + 当月天数
例如：5月10日
计算：31 29 31 30 + 10
# 1 3 5 7 8 10 12 有31天
# 2 有29天
# 4 6 9 11 有30天
tuple_mon = (31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
cur_mon = int(input("请输入月："))
cur_day = int(input("请输入日："))
sum_day = 0
for i in range(cur_mon - 1):
sum_day += int(tuple_mon[i])
sum_day += cur_day
print(str(cur_mon) + "月" + str(cur_day) + "日是这一年的第" + str(sum_day) + "天")
3.5.3.字符串str
由一系列字符编码值组成的不可变序列容器
3.5.3.1.编码
3.5.3.1.1.字符集
字符与整数对应关系的集合
(1) ASCII：包含英文、数字等字符
(2) GBK：兼容ASCII，包含21886个中文
(3) Unicode：几乎涵盖全球所有已知字符
3.5.3.1.2.编码方式
将字符转换为整数的规则
(1) ASCII：每个字符占1个字节
(2) GBK：英文1个字节，中文2个字节
(3) UTF8：英文1个字节，中文3个字节
3.5.3.1.3.不可变
采取"按需分配"的存储策略，节省内存空间
修改数据时若在原有空间，可能破坏其他数据
所以每次修改都会创建新数据，替换变量中记录的数据地址
name = “封神”
name = “封神第一部”
name = “电影” + name
3.5.3.2.序列
使用比较运算符时会依次比较两个容器中元素,一但不同则返回结果
print(“12w” < “13w”) # True
print(“2k” < “13w”) # False
3.5.3.3.字面值
3.5.3.3.1.单引和双引号的区别
(1) 单引号内的双引号不算结束符
(2) 双引号内的单引号不算结束符
print('悟空') #悟空
print("悟空") #悟空
print('花果山"水帘洞"美猴王孙悟空') #花果山"水帘洞"美猴王孙悟空
print("""花果山'水帘洞'"美猴王"孙悟空""") #花果山'水帘洞'"美猴王"孙悟空
3.5.3.3.2.三引号作用
(1) 换行会自动转换为换行符\n
(2) 三引号内可以包含单引号和双引号
(3) 作为文档字符串
3.5.3.3.3.转义字符
(1) 定义：改变字符的原始含义。
(2) 语法： ’ " \n \
print("花果山\"水帘洞\"美猴王孙悟空") # 花果山"水帘洞"美猴王孙悟空
print("花果山水帘洞\n美猴王孙悟空")
# 花果山水帘洞
# 美猴王孙悟空
print("C:\\newfile\\test.py") # C:\newfile\test.py
(3) 原始字符串：取消转义（小写字母r开头）。
print(r"C:\newfile\test.py")
3.5.3.3.4.格式化
(1) 作用：将变量插入到字符串时，可以先用占位符描述格式后插入变量
(2) 占位符：%s 原样输出， %d 整数保留位数， %f 小数保留精度
(3) 语法：格式%(变量)
name = "大圣"
age = "6"
money = 1.2345
hour = 2
minute = 6
print("我叫%s,今年%s岁啦" % (name, age)) # 我叫大圣,今年6岁啦
print("请支付:%.2f元" % money) # 请支付:1.23元
print("%.2d:%.2d" % (hour,minute)) # 02:06
练习：根据下列文字，提取变量，使用字符串格式化打印信息
湖北确诊67802人,治愈63326人,治愈率0.93
65秒是01分05秒
# 湖北确诊67802人,治愈63326人,治愈率0.93
num1 = 67802
num2 = 63326
num3 = 0.93
print("湖北确诊%d人,治愈%d人,治愈率%.2f" % (num1, num2, num3))
# 65秒是01分05秒
sec1 = 65
min = 1
sec2 = 5
print("%d秒是%.2d分%.2d秒" % (sec1, min, sec2))
3.5.4.字典dict
适合存储有对应关系的数据，例如表格的标题名与行数据。
若用列表存储电影信息，通过索引访问，代码可读性差。
list_movie01 = ["八角笼中","剧情","王宝强"、690761)]
print("名称" + list_movie01[0])
print("类型" + list_movie01[1])
print("演员" + list_movie01[2])
print("指数" + list_movie01[3])
(1)定义：由一系列键值对组成的可变散列容器
(2)语法：
字典名 = {键1:值,键2:值}
(3)案例：
dict_bjlz = {
"name":"八角笼中","type":"剧情",
"actor":"王宝强","index":690761,
}
print("名称" + dict_bjlz["name"])
3.5.4.1.散列
(1)定义：通过哈希算法将键转换为对应存储位置的容器类型
(2)特点：
①：无需遍历，直接计算存储位置，速度最快
list_movie = [("八角笼中","剧情"),("消失的她","犯罪")]
for item in list_movie:
if item[0] == "消失的她":
print(item[1])
dict_movie = {"八角笼中":"剧情","消失的她":"犯罪"}
print(dict_movie["消失的她"])
②：键必须唯一且只能是不可变类型的数据
dict_movie = {"剧情":"八角笼中","剧情":"满江红"}
print(dict_movie) # {"剧情":"满江红"}
dict_movie = {["王宝强","陈永胜"]:"八角笼中"} # TypeError: unhashable type: 'list'
③缺点：在内存中元素没有顺序且占用空间较大
练习：
创建字典存储台湾的地区、新增、现有人数
创建字典存储陕西的地区、新增、现有人数
创建字典存储浙江的地区、新增、现有人数
dict_tw = {"地区": "台湾", "新增": 16, "现有": 2339}
dict_sx = {"地区": "陕西", "新增": 182, "现有": 859}
dict_zj = {"地区": "浙江", "新增": 2, "现有": 505}
3.5.4.2.基础操作
3.5.4.2.1.添加元素
(1)作用：将键值对添加到字典中
(2)语法：字典名[键] = 值
(3)案例：
dict_bjlz = {
"name":"八角笼中","type":"剧情",
}
dict_bjlz["actor"] = "王宝强"
dict_bjlz["index"] = 690761
练习：根据表格数据，为台湾、陕西、浙江三个字典添加累计、治愈人数
dict_tw = {"地区": "台湾", "新增": 16, "现有": 2339}
dict_sx = {"地区": "陕西", "新增": 182, "现有": 859}
dict_zj = {"地区": "浙江", "新增": 2, "现有": 505}
dict_tw["累计"] = 16931
dict_tw["治愈人数"] = 13742
dict_sx["累计"] = 1573
dict_sx["治愈人数"] = 711
dict_zj["累计"] = 2008
dict_zj["治愈人数"] = 1502
3.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"]
注意：键存在为修改,不存在为添加
练习：
在终端中打印台湾的现有人数
在终端中打印陕西的新增和现有人数
浙江新增和现有人数各增加1
dict_tw = {"地区": "台湾", "新增": 16, "现有": 2339}
dict_sx = {"地区": "陕西", "新增": 182, "现有": 859}
dict_zj = {"地区": "浙江", "新增": 2, "现有": 505}
print(dict_tw["现有"])
print(dict_sx["新增"])
print(dict_sx["现有"])
dict_zj["新增"] += 1
dict_zj["现有"] += 1
3.5.4.2.3.删除元素
(1)作用：通过键删除键值对
(2)语法：del 字典名[键]
(3)案例：
dict_bjlz = {
"name":"八角笼中","type":"剧情",
}
del dict_bjlz["name"])
注意：列表删除时元素向前移动,字典删除时其他元素不移动
练习：
删除台湾现有信息
删除陕西新增和现有信息
删除浙江现有人数保留键(通过键修改值)
dict_tw = {"地区": "台湾", "新增": 16, "现有": 2339}
dict_sx = {"地区": "陕西", "新增": 182, "现有": 859}
dict_zj = {"地区": "浙江", "新增": 2, "现有": 505}
del dict_tw["现有"]
del dict_sx["新增"]
del dict_sx["现有"]
dict_zj["现有"] = ""
3.5.4.3.遍历元素
所有键
(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)语法：
```python
for key,value in 字典名.items():
变量key,value分别记录的是字典的键和值
(3)案例：
dict_bjlz = {
"name":"八角笼中","type":"剧情",
}
for key,value in dict_bjlz.items():
print(key)
print(value)
练习：
在终端中打印台湾所有键(一行一个)
在终端中打印陕西所有值(一行一个)
在终端中打印浙江所有键和值(一行一个)
在台湾字典中查找值是2339对应的键名称
dict_tw = {"地区": "台湾", "新增": 16, "现有": 2339}
dict_sx = {"地区": "陕西", "新增": 182, "现有": 859}
dict_zj = {"地区": "浙江", "新增": 2, "现有": 505}
# 在终端中打印台湾所有键(一行一个)
for key in dict_tw:
print(key)
# 在终端中打印陕西所有值(一行一个)
for val in dict_sx.values():
print(val)
# 在终端中打印浙江所有键和值(一行一个)
for key, val in dict_zj.items():
print(str(key) + ":" + str(val))
# 在台湾字典中查找值是2339对应的键名称
for key, val in dict_tw.items():
if val == 2339:
print("值是2339对应的键名称：" + key)
3.5.4.4.字典推导式
(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)
练习：使用字典推导式，颠倒字典的键和值
dict_info = {
"1001":"台湾","1002":"陕西",
"1003":"浙江","1004":"广西",
}
dict_info = {
"1001": "台湾", "1002": "陕西",
"1003": "浙江", "1004": "广西",
}
new_dict_info = {val: key for key, val in dict_info.items()}
3.5.5.容器嵌套
3.5.5.1.字典内嵌元组
数据
代码
dict_bjlz = {
"name":"八角笼中","type":("剧情","动作"),
"actor":"王宝强","index":690761,
}
print("名称" + str(dict_bjlz["type"])) # 名称('剧情', '动作')
3.5.5.2.列表内嵌字典
数据
代码
list_movie = [
{"name": "八角笼中", "index": 690761},
{"name": "封神第一部", "index": 532622}
]
print(list_movie[0]) # {"name":"八角笼中","index":690761}
print(list_movie[1]["name"]) # "封神第一部"
基础操作
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
3.6.函数 function
需求：修改多个游戏场景中角色攻击的代码，需要重复修改多次
函数作用：将功能的做法与用法分离，需求变化时只需要修改一次做法
创建语法:
def 函数名():
语句组
def关键字：全称是define，意为"定义"
函数名：对函数体中语句的描述，规则与变量名相同，建议使用动词
函数体：完成该功能的语句
调用语法：
函数名()
若没有小括号，函数不执行
通常先定义函数，再调用函数
为提高代码复用性：如果在程序中有一段代码需要在多个地方使用，可以将其定义在一个函数中，以便在需要时重复调用。
为提高代码可读性：将复杂的代码逻辑拆分成较小的函数，可以提高代码的可读性。函数有明确的名称和参数，可以使代码更加清晰易懂。
为提高代码安全性：将敏感操作或复杂计算定义在函数内部，避免在其他部分直接访问或修改实现细节，可以使代码更加安全。
3.6.1.语法
3.6.1.1.定义函数
语法：
def 函数名(形式参数):
函数体
函数的第一行语句建议使用文档字符串描述函数的功能与参数。
# 形式参数：表面的不具体的数据
def attack(count):
"""
攻击
:param count:次数
"""
for __ in range(count):
print("直拳")
print("摆拳")
print("勾拳")
3.6.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)
def printList(lists):
for item in lists:
print(item)
list01 = [5, 546, 6, 56, 76]
printList(list01)
list02 = [7, 6, 879, 9, 909]
printList(list02)
3.6.1.3.返回值
定义：
函数定义者告诉调用者的结果。
语法：
return 数据
说明：
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) + "%")
def heal(confirmed, cure):
return cure / confirmed * 100
confirmed = int(input("请输入确诊人数:"))
cure = int(input("请输入治愈人数:"))
print("治愈比例为" + str(heal(confirmed, cure)) + "%")
练习2：定义函数,根据总两数,计算几斤零几两.:
提示：使用容器包装需要返回的多个数据
total_liang = int(input("请输入两:"))
jin = total_liang // 16
liang = total_liang % 16
print(str(jin) + "斤零" + str(liang) + "两")
def compWeight(weg):
jin = weg // 16
liang = weg % 16
print(str(jin) + "斤零" + str(liang) + "两")
weight = int(input("请输入两:"))
compWeight(weight)
练习3：创建函数,根据课程阶段计算课程名称.
number = input("请输入课程阶段数：")
if number == "1":
print("Python语言核心编程")
elif number == "2":
print("Python高级软件技术")
elif number == "3":
print("Web全栈")
elif number == "4":
print("人工智能")
def getClassName(num):
if num == "1":
print("Python语言核心编程")
elif num == "2":
print("Python高级软件技术")
elif num == "3":
print("Web全栈")
number = input("请输入课程阶段数：")
getClassName(number)
练习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("低能")
def compIQ(ma, ca):
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("低能")
ma = int(input("请输入你的心里年龄："))
ca = int(input("请输入你的实际年龄："))
compIQ(ma, ca)
3.6.2.可变／不可变类型在传参时的区别
(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) # {'八戒': 150}
练习2：并写出打印结果。
def func01(p1, p2):
p1 = 100
p2[0] = 200
a = [10]
b = [20]
func01(a, b)
print(a) # [10]
print(b) # [200]
3.6.3.函数参数
3.6.3.1.实参传递方式argument
3.6.3.1.1.位置实参
定义：实参与形参的位置依次对应。
def fun01(p1, p2, p3):
print(p1)
print(p2)
print(p3)
# 位置实参:根据顺序与形参进行对应
fun01(1, 2, 3)
3.6.3.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)
3.6.3.1.3.序列实参
定义：实参用*将序列拆解后与形参的位置依次对应。
3.6.3.1.4.字典实参
定义：实参用**将字典拆解后与形参的名字进行对应。
3.6.3.2.形参定义方式parameter
3.6.3.2.1.位置形参
语法：
def 函数名(形参名1, 形参名2, ...):
函数体
3.6.3.2.2.默认形参
语法：
def 函数名(形参名1=默认值1, 形参名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)
# 注意:先位置实参,后关键字实参
# func01(p1 =1,2,3) # 错误
练习：
定义函数,根据小时、分钟、秒,计算总秒数
调用：提供小时、分钟、秒
调用：提供分钟、秒
调用：提供小时、秒
调用：提供分钟
# 定义函数,根据小时、分钟、秒,计算总秒数
def compSec(hour=0, min=0, sec=0):
return hour * 3600 + min * 60 + sec
# 调用：提供小时、分钟、秒
print(str(compSec(1, 10, 10)))
# 调用：提供分钟、秒
print(str(compSec(min=10, sec=10)))
# 调用：提供小时、秒
print(str(compSec(hour=1, sec=10)))
# 调用：提供分钟
print(str(compSec(min=10)))
3.6.3.2.3.星号元组形参
语法：
def 函数名(*元组形参名):
函数体
作用：
收集多余的位置传参。
说明：
一般命名为’args’
形参列表中最多只能有一个
3.6.3.2.4.双星号字典形参
语法：
def 函数名(**元组形参名):
函数体
作用：
收集多余的关键字传参
说明:
一般命名为’kwargs’
形参列表中最多只能有一个
3.6.3.2.5.命名关键字形参
语法：
def 函数名(命名关键字形参1, 命名关键字形参2, …):
函数体
3.6.3.3.参数顺序
形式参数：位置形参 --> 星号元组形参 --> 命名关键字形参 --> 双星号字典形参
实际参数：位置实参 --> 关键字实参
3.7.作用域
定义：变量起作用的范围。
分类：
(1) Local局部作用域：函数内部。
(2) Global全局作用域：模块(.py文件)内部。
变量名的查找规则：在访问变量时，先查找局部变量，之后是全局变量。
局部变量：
(1) 定义在函数内部的变量(形参也是局部变量)
(2) 只能在函数内部使用
(3) 调用函数时才被创建，函数结束后自动销毁
全局变量：
(1) 定义在函数外部,模块内部的变量。
(2) 在整个模块(py文件)范围内访问（但函数内不能将其直接赋值）。
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]
489
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
