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.23
3.2.3.3 字符串str
(1) 用来记录文本信息(文字信息)。
(2) 字面值:双引号
3.2.3.4 布尔bool
(1) 表示条件是否成立
(2) 只有两个值:
True 表示真(条件满足或成立),本质是1
False 表示假(条件不满足或不成立),本质是0
result = input("请输入您的职业:") == "老师"
print(result) # 输入老师,结果True;输入其他,结果False
3.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]