On my way，Python
Python笔记
Python 简介
Python是一个免费、开源、跨平台、动态、面向对象的编程语言。
基础知识
Python程序的执行方式
交互式
在命令行输入指令，回车即可得到结果。
- 打开终端
- 进入交互式：
python3 - 编写代码：
print(“hello world”) - 离开交互式：
exit()
文件式
将指令编写到.py文件，可以重复运行程序。
- 编写文件
- 打开终端
- 进入程序所在目录：cd 目录
- 执行程序：
python3 文件名
Python程序的执行过程
计算机只能识别机器码(1010)，不能识别源代码(python)
- 由源代码转变成机器码的过程分成两类：编译和解释
- 编译：在程序运行之前，通过编译器将源代码变成机器码，例如：C语言
优点：运行速度快
缺点：开发效率低，不能跨平台 - 解释：在程序运行之时，通过解释器对程序逐行翻译，然后执行，例如Javascript
优点：开发效率高，可以跨平台
缺点：运行速度慢 - python是解释型语言，但为了提高运行速度，使用了一种编译的方法。编译之后得到pyc文件，存储了字节码（特定于Python的表现形式，不是机器码）
源代码 – 编译 --> 字节码 – 解释 --> 机器码
|————1次————|
解释器类型
- CPython（C语言开发)
- Jython (java开发)
- IronPython (.net开发)
数据基本运算
基础知识
pycharm常用快捷键
- 移动到本行开头：home键
- 移动到本行末尾：end键盘
- 注释代码：ctrl + /
- 复制行：ctrl +d
- 删除行：shift + delete
- 选择列：shift + alt +鼠标左键
- 移动行：shift + alt + 上下箭头
- 代码格式化：ctrl+alt+l
注释
给人看的，通常是对代码的描述信息
- 单行注释：以#号开头
- 多行注释：三引号开头，三引号结尾
函数
表示一个功能，函数定义者是提供功能的人，函数调用者是使用功能的人。
例如：
- print(数据) 作用：将括号中的内容显示在控制台中
- 变量 = input(“需要显示的内容”) 作用：将用户输入的内容赋值给变量
"""
练习：判断英文句子成分：I kiss you
"""
subject = input("请输入I kiss you的主语:")
predicate = input("请输入I kiss you的谓语:")
object = input("请输入I kiss you的宾语:")
print("您输入的主语是:" + subject + ",谓语是:" + predicate + ",宾语是:" + object + ".")
变量
关联一个对象的标识符
- 命名：必须是字母或下划线开头，后跟字母、数字、下划线
不能使用关键字(蓝色)，否则发生语法错误：SyntaxError: invalid syntax - 建议命名：字母小写，多个单词以下划线隔开：
class_name = “xxx” - 赋值：创建一个变量或改变一个变量关联的数据。
- 语法：
变量名 = 数据
变量名1 = 变量名2 = 数据
变量名1, 变量名2, = 数据1, 数据2
#创建变量
name01 = "悟空"
name02 = "八戒"
#修改变量
name02 = "唐僧"
#相加产生新数据
name03 = name01 + name02
#传递数据地址
name04 = name03
"""
画出下列代码内存图,说出终端显示结果
"""
name_of_hubei_province = "湖北"
name_of_hunan_province = "湖南"
name_of_hunan_province = "湖南省"
name_of_hunan_province = name_of_hubei_province
print(name_of_hunan_province) # 湖北
del 语句
- 语法:
del 变量名1, 变量名2
- 作用：
用于删除变量,同时解除与对象的关联.如果可能则释放对象。 - 自动化内存管理的引用计数：
每个对象记录被变量绑定(引用)的数量,当为0时被销毁。
“”"
删除 del
“”"
`name01 = "悟空"`
`name02 = name01 # 创建2个变量,赋同样的值`
`name02 = name01 = "悟空"`
`del name01 # 删除变量,"悟空"存在`
`del name02 # 删除变量,"悟空"不存在(引用计数为0)`
`name02 = "唐僧" # 修改变量,"悟空"不存在(引用计数为0)`
核心数据类型
在python中变量没有类型，但关联的对象有类型。
整形int
- 表示整数，包含正数、负数、0
如： -5, 100, 0 - 字面值：
十进制：每位用十种状态计数，逢十进一，写法是0~9
二进制：每位用二种状态计数，逢二进一，写法是0b开头，后跟0或者1
八进制：每位用八种状态计数，逢八进一，写法是0o开头，后跟0~7
十六进制：每位用十六种状态计数，逢十六进一，写法是0x开头，后跟0-9,A-F,a-f
浮点型float
- 表示小数，包含正数、负数，0.0
- 字面值：
小数：1.0 2.5
科学计数法：e/E (正负号) 指数
1.23e-2 (等同于0.0123)
1.23456e5(等同于123456.0)
字符串str
- 是用来记录文本信息(文字信息)
- 字面值：双引号
布尔bool
- 用来表示真和假的类型
- True 表示真(条件满足或成立)，本质是1
- False 表示假(条件不满足或不成立)，本质是0
#命题：您是总统
result = input("请输入您的职业：") # "总统"
print(result) # True
print(type(result))
数据类型转换
- 转换为整形: int(数据)
- 转换为浮点型:float(数据)
- 转换为字符串:str(数据)
- 转换为布尔:bool(数据)
结果为False：bool(0) bool(0.0) bool(None) - 混合类型自动升级：
1 + 2.14 返回的结果是 3.14
1 + 3.0 返回结果是: 4.0
"""
练习：在终端中输入商品单价、购买的数量和支付金额。
计算应该找回多少钱。
效果：
请输入商品单价：5
请输入购买数量：3
请输入支付金额：20
应找回：5.0
"""
#1. 获取数据
price = float(input("请输入商品单价："))
count = int(input("请输入购买数量："))
money = float(input("请输入支付金额："))
#2. 逻辑计算
result = money - price * count
#3. 显示结果
print("应找回：" + str(result))
运算符
算术运算符
加法 +
减法 -
乘法 *
除法 / ：结果为浮点数
整除 // ：除的结果去掉小数部分
求余 %
幂运算 **
优先级从高到低：
()
**
* / % //
+ -
算数运算符
+ - * / // % **
增强运算符:在算数运算符基础上增加了对自身赋值的功能
+= -= *= /= //= %= **=
"""
练习2：古代的秤，一斤十六两。
在终端中获取两，计算几斤零几两。
效果：
请输入总两数：100
结果为：6斤4两
"""
total_liang = int(input("请输入总两数："))
jin = total_liang // 16
liang = total_liang % 16
print("结果为：" + str(jin) + "斤" + str(liang) + "两")
"""
练习2：
匀变速直线运动的速度与位移公式：
位移 = 初速度 × 时间 + 加速度 * 时间的平方 / 2
已知(在终端中录入)：位移、时间、初速度
计算：加速度
"""
#(位移 -初速度 × 时间) * 2 / 时间 ** 2 = 加速度
s = float(input("请输入位移："))
v0 = float(input("请输入初速度："))
t = float(input("请输入时间："))
a = (s - v0 * t) * 2 / t ** 2
print(a)
增强运算符
y += x 相当于 y = y + x
y -= x 相当于 y = y - x
y *= x 相当于 y = y * x
y /= x 相当于 y = y / x
y //= x 相当于 y = y // x
y %= x 相当于 y = y % x
y **= x 相当于 y = y ** x
"""
练习：在终端中输入一个四位整数，计算每位相加和。
例如：录入1234，打印1+2+3+4结果
效果：
请输入四位整数：1234
结果是：10
"""
number = int(input("请输入四位整数："))
unit01 = number % 10 # 个位
#1234 // 10 --> 123 % 10 --> 3
unit02 = number // 10 % 10 # 十位
#1234 // 100 --> 12 % 10 --> 2
unit03 = number // 100 % 10 # 百位
unit04 = number // 1000 # 千位
result = unit01 + unit02 + unit03 + unit04
#建议
result = number % 10
result += number // 10 % 10
result += number // 100 % 10
result += number // 1000
print("结果是：" + str(result))
“”"
变量交换
“”"
bridegroom_name = "武大郎"
bride_name = "潘金莲"
#传统思想：借助第三方变量
#temp = bridegroom_name
#bridegroom_name = bride_name
#bride_name = temp
#交换律思想：a,b=b,a
bridegroom_name, bride_name = bride_name, bridegroom_name
print("交换后的新郎：" + bridegroom_name)
print("交换后的新娘：" + bride_name)
比较运算符
小于 <
小于等于 <=
大于 >
大于等于 >=
等于 ==
不等于 !=
返回布尔类型的值
比较运算的数学表示方式:0 <= x <= 100
逻辑运算符
与and
表示并且的关系，一假俱假
#示例:
True and True # True
True and False # False
False and True # False
False and False # False
或or
表示或者的关系，一真俱真
#示例:
True or True # True
True or False # True
False or True # True
False or False # False
非 not
表示取反
#例如：
not True # 返回False
not False # 返回True
print(True or True) # True
print(False or True) # True
print(True or False) # True
print(False or False) # False
短路运算
一但结果确定，后面的语句将不再执行。
身份运算符
语法:
x is y
x is not y
作用：
is 用于判断两个对象是否是同一个对象,是时返回True,否则返回False。
is not 的作用与is相反
优先级
高到低：
算数运算符
比较运算符
增强运算符
身份运算符
逻辑运算符
语句
行
- 物理行：程序员编写代码的行。
- 逻辑行：python解释器需要执行的指令。
- 建议一个逻辑行在一个物理行上。
- 如果一个物理行中使用多个逻辑行，需要使用分号；隔开。
- 如果逻辑行过长，可以使用隐式换行或显式换行。
隐式换行：所有括号的内容换行,称为隐式换行
括号包括: () [] {} 三种
显式换行：通过折行符 \ (反斜杠)换行，必须放在一行的末尾，目的是告诉解释器,下一行也是本行的语句。
#3个物理行 3个逻辑行 (建议)
a = 1
b = 2
c = a + b
#1个物理行 3个逻辑行(使用分号隔开多条命令)
a = 1;b = 2;c = a + b
#3个物理行 1个逻辑行(使用折行符在多个物理行下达一条命令)
a = 1+2+\
3+4+\
5+6
#通过括号(小中大)自动换行
a = (1+2+
3+
4+
5+
6)
选择语句
If elif else 语句
- 作用:
让程序根据条件选择性的执行语句。 - 语法:
if 条件1:
语句块1
elif 条件2:
语句块2
else:
语句块3
- 说明:
elif 子句可以有0个或多个。
else 子句可以有0个或1个，且只能放在if语句的最后。
选择语句
让语句有选择性的执行
if 条件:
满足条件执行的语句
else:
不满足条件执行的语句
调试Debug
让程序中断,逐语句审查程序执行过程与实际取值.
1. 加断点(在可能出错的行)
2. 开始调试(点击Debug按钮)
3. 按F8逐语句执行,看变量取值
"""
练习1：
如果满足 职位是高管 或者 年薪大于50000的 条件 则显示“娶你”
否则显示”继续努力 ”
"""
if (input("请输入职位：") == "高管" or
int(input("请输入身高：")) > 500000):
print("娶你")
else:
print("继续努力")
# 练习2:
# 在终端中输入性别
# 打印"您好先生" "您好女士" "未知"
sex = input("请输入性别：")
if sex == "男":
print("您好先生")
elif sex == "女":
print("您好女士")
else:
print("未知")
"""
练习3：
在终端中输入课程阶段数,显示课程名称
1 显示 Python语言核心编程
2 显示 Python高级软件技术
3 显示 Web 全栈
4 显示 网络爬虫
5 显示 数据分析、人工智能
"""
course = input("请输入课程编号：")
if course == "1":
print("Python语言核心编程")
elif course == "2":
print("Python高级软件技术")
elif course == "3":
print("Web 全栈")
elif course == "4":
print("网络爬虫")
elif course == "5":
print("数据分析、人工智能")
# 练习4：
# 在终端中录入4个同学身高,打印最高的值.
# 算法：
# 170 160 180 165
# 假设第一个就是最大值
# 使用假设的和第二个进行比较, 发现更大的就替换假设的
# 使用假设的和第三个进行比较, 发现更大的就替换假设的
# 使用假设的和第四个进行比较, 发现更大的就替换假设的
# 最后，假设的就是最大的.
# 效果：
# 请输入第1个同学身高:170
# 请输入第2个同学身高:160
# 请输入第3个同学身高:180
# 请输入第4个同学身高:165
# 最高的同学:180
height01 = int(input("请输入第1个同学身高："))
height02 = int(input("请输入第2个同学身高："))
height03 = int(input("请输入第3个同学身高："))
height04 = int(input("请输入第4个同学身高："))
max_value = height01
if max_value < height02:
max_value = height02
if max_value < height03:
max_value = height03
if max_value < height04:
max_value = height04
print("最高的同学:" + str(max_value))
# 练习5：
# 根据心理年龄与实际年龄，打印智商等级。
# 智商IQ = 心理年龄MA 除以 实际年龄CA 乘以 100
# 天才：140以上（包含）
# 超常：120-139之间（包含）
# 聪慧：110-119之间（包含）
# 正常：90-109之间（包含）
# 迟钝：80-89之间（包含）
# 低能：80以下
#写法一：
ma = int(input("请输入心理年龄："))
ca = int(input("请输入实际年龄："))
iq = ma / ca * 100
# 连续区间的判断：建议只考虑单边
if 140 <= iq:
print("天才")
elif 120 <= iq: # 程序能执行到本行,说明一定小于140
print("超常")
elif 110 <= iq:
print("聪慧")
elif 90 <= iq:
print("正常")
elif 80 <= iq:
print("迟钝")
else:
print("低能")
#写法二：
# 下列写法,适合不连续的区间
# if iq >= 140:
# print("天才")
# elif 120 <= iq < 140: # el与iq < 140都在表达小于140
# print("超常")
# elif 110 <= iq < 120:
# print("聪慧")
# elif 90 <= iq < 110:
# print("正常")
# elif 80 <= iq < 90:
# print("迟钝")
# else:
# print("低能")
# 练习6：
# 在终端中输入月份，打印相应的天数.
# 1 3 5 7 8 10 12 有 31天
# 2 有 29天
# 4 6 9 11 有 30天
# 超过月份提示月份有误
# 效果：
# 请输入月份:10
# 31天
month = int(input("请输入月份："))
if 1 <= month <= 12:
if month == 2:
print("28天")
elif month == 4 or month == 6 or month == 9 or month == 11:
print("30天")
else:
print("31天")
else:
print("月份有误")
if 语句的真值表达式
if 100:
print("真值")
#等同于
if bool(100):
print("真值")
# 练习：在终端中输入一个整数，如果是奇数为变量state赋值"奇数",否则赋值"偶数"。
# 效果：
# 请输入数字:6
# state变量存储的是：偶数
#写法一：
# if int(input("请输入整数:")) % 2:
# state = "奇数"
# else:
state = "偶数"
state = "奇数" if int(input("请输入整数:")) % 2 \
else "偶数"
print(state)
条件表达式
语法：
变量 = 结果1 if 条件 else 结果2
作用：根据条件(True/False) 来决定返回结果1还是结果2。
“”"
条件表达式
变量 = 满足条件的值 if 条件 else 不满足条件的值
“”"
# 根据一个条件,为变量赋值
# if input("请输入性别:") == "男":
# value = 1
# else:
# value = 0
value = 1 if input("请输入性别:") == "男" else 0
print(value)
# 练习：在终端中输入一个年份，如果是闰年为变量day赋值29,否则赋值28。
# 闰年条件：年份能被4整除但是不能被100整除
# 年份能被400整除
# 效果：
# 请输入年份:2020
# 2020年的2月有29天
year = int(input("请输入年份："))
if year % 4 == 0 and year % 100 != 0 or \
year % 400 == 0:
day = 29
else:
day = 28
循环语句
while语句
while 循环计数
1. 开始
2. 结束
3. 间隔
# 计数器
count = 0
while count < 5:
print("跑圈" + str(count)) # 0 1 2 3 4
count += 1
- 作用:
可以让一段代码满足条件，重复执行。 - 语法:
while 条件:
满足条件执行的语句
else:
不满足条件执行的语句
- 说明:
else子句可以省略。
在循环体内用break终止循环时,else子句不执行。
“”"
while 循环
当满足条件时执行循环体
执行后再判断条件,如果还满足则继续执行…
while True:
循环体
if 退出条件:
break # 跳出循环
“”"
while True:
number = int(input("请输入数字："))
if number > 0:
print("正数")
elif number < 0:
print("负数")
else:
print("零")
if input("请输入q键退出:") == "q":
break
#练习1：
#让下列代码重复执行，输入y继续(不输入y则退出)
sex = input("请输入性别:")
if sex == "男":
print("您好先生")
elif sex == "女":
print("您好女士")
else:
print("未知")
while True:
sex = input("请输入性别:")
if sex == "男":
print("您好先生")
elif sex == "女":
print("您好女士")
else:
print("未知")
if input("输入y继续") != "y":
break
#练习2：
#在终端中显示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
count = 2
while count < 7:
print(count)
count += 1
count = 1
while count < 8:
print(count)
count += 2
count = 8
while count > 3:
print(count)
count -= 1
count = -1
while count > -6:
print(count)
count -= 1
"""
练习3：
在终端中循环录入5个成绩,
最后打印平均成绩(总成绩除以人数)
效果：
请输入成绩：98
请输入成绩：83
请输入成绩：90
请输入成绩：99
请输入成绩：78
平均分：89.6
"""
count = 0
total_score = 0
while count < 5:
count += 1
total_score += int(input("请输入成绩："))
print("平均分：" + str(total_score / 5))
"""
练习4：
一张纸的厚度是0.01毫米
请计算，对折多少次超过珠穆朗玛峰(8844.43米)
数据： 厚度 次数
算法：厚度*=2 次数+=1
"""
# thickness = 0.01 / 1000
# thickness = 0.00001
thickness = 1e-5
count = 0
while thickness <= 8844.43:
thickness *= 2
count += 1
print("第"+str(count)+"次对折的高度是："+str(thickness))
print("总共对折" + str(count) + "次")
"""
练习5：
程序产生1个,1到100之间的随机数。
让玩家重复猜测,直到猜对为止。
每次提示：大了、小了、恭喜猜对了,总共猜了多少次。
"""
# 准备一个随机数工具
import random
# 产生一个随机数
random_number = random.randint(1, 100)
count = 0
while True:
count += 1
input_number = int(input("请输入数字："))
if input_number > random_number:
print("大了")
elif input_number < random_number:
print("小了")
else:
print("恭喜猜对了,总共猜了" + str(count) + "次。")
break
for 语句
- 作用:
用来遍历可迭代对象的数据元素。
可迭代对象是指能依次获取数据元素的对象，例如：容器类型。 - 语法:
for 变量列表 in 可迭代对象:
语句块1
else:
语句块2
- 说明:
else子句可以省略。
在循环体内用break终止循环时,else子句不执行。
"""
for 循环
for 变量 in 可迭代对象 :
"""
message = "我是孙悟空"
for item in message:
print(item)
# item = "a" # 修改变量item,不影响message
"""
练习:
在终端中输入任意整数，计算累加和.
"1234" -> "1" -> 累加 1
"""
sum_value = 0
for item in input("请输入任意整数："):
sum_value += int(item)
print(sum_value)
range 函数
- 作用:
用来创建一个生成一系列整数的可迭代对象(也叫整数序列生成器)。 - 语法:
range(开始点，结束点，间隔) - 说明:
函数返回的可迭代对象可以用for取出其中的元素
返回的数字不包含结束点
开始点默认为0
间隔默认值为1
"""
练习：
在终端中累加 0 1 2 3
在终端中累加 2 3 4 5 6
在终端中累加 1 3 5 7
在终端中累加 8 7 6 5 4
在终端中累加 -1 -2 -3 -4 -5
"""
sum_value = 0
for item in range(4):
sum_value += item
print(sum_value)
sum_value = 0
for number in range(2, 7):
sum_value += number
print(sum_value)
sum_value = 0
for element in range(1, 8, 2):
sum_value += element
print(sum_value)
sum_value = 0
for i in range(8, 3, -1):
sum_value += i
print(sum_value)
sum_value = 0
for i in range(-1, -6, -1):
sum_value += i
print(sum_value)
跳转语句
break 语句
- 跳出循环体，后面的代码不再执行。
- 可以让while语句的else部分不执行。
continue 语句
跳过本次，继续下次循环。
# 练习：累加10 -- 60之间，个位不是3/5/8的整数和。
sum_value = 0
for number in range(10, 61):
unit = number % 10
# 满足条件 累加
if unit != 3 and unit != 5 and unit != 8:
sum_value += number
print(sum_value) # 1255
sum_value = 0
for number in range(10, 61):
unit = number % 10
# 不满足条件 跳过
if unit == 3 or unit == 5 or unit == 8:
continue
sum_value += number
print(sum_value) # 1255
容器类型
通用操作
数学运算符
- +：用于拼接两个容器
- +=：用原容器与右侧容器拼接,并重新绑定变量
- *：重复生成容器元素
- *=：用原容器生成重复元素, 并重新绑定变量
- < <= > >= == !=：依次比较两个容器中元素,一但不同则返回比较结果。
#拼接两个容器元素
name03 = name01 + name02
print(name03) # 悟空八戒
#重复容器中的元素
name04 = name01 * 20
print(name04) # 悟空悟空
#依次比较两个容器中元素,一但不同则返回比较结果。
print(name01 > name02)
#成员运算符
#True
print("悟空" in "花果山水帘洞齐天大圣孙悟空")
print("水帘" in "花果山水帘洞齐天大圣孙悟空")
#False
print("大圣齐天" in "花果山水帘洞齐天大圣孙悟空")
print("水洞" in "花果山水帘洞齐天大圣孙悟空")
"""
for 循环
for 变量 in 可迭代对象 :
"""
message = "我是孙悟空"
for item in message:
print(item)
# item = "a" # 修改变量item,不影响message
"""
练习：
在终端中获取一个整数，作为边长，打印矩形
"""
number = int(input("请输入整数："))
print("*" * number)
for __ in range(number - 2):
print("*%s*" % (" " * (number - 2)))
print("*" * number)
成员运算符
- 语法：
数据 in 序列
数据 not in 序列 - 作用：
如果在指定的序列中找到值，返回bool类型。
索引index
- 作用：定位单个容器元素。
- 语法：容器[整数]
- 说明：
正向索引从0开始，第二个索引为1，最后一个为len(s)-1。
反向索引从-1开始,-1代表最后一个,-2代表倒数第二个,以此类推,第一个是-len(s)。
"""
索引
"""
message = "我是花果山水帘洞美猴王齐天大圣"
print(message[0]) # 我
print(message[4]) # 山
print(message[-4]) # 齐
# print(message[1.5]) # 编号必须是整数
# print(message[100]) # IndexError
# print(message[-100]) # IndexError
print(len(message)) # 字符串长度
# 通过正向索引定位最后一个元素
print(message[len(message) - 1])
# 通过反向索引定位第一个元素
print(message[-len(message)])
# 定位第三个、第五个、倒数第二个、倒数第四个
print(message[2])
print(message[4])
print(message[-2])
print(message[-4])
# 定位 "山" "王"
print(message[4])
print(message[-5])
切片slice
- 作用：
定位多个容器元素。 - 语法：
容器[开始索引:结束索引:步长] - 说明：
结束索引不包含该位置元素
步长是切片每次获取完当前元素后移动的偏移量
开始、结束和步长都可以省略
"""
练习：
字符串： content = "我是京师监狱狱长金海。"
打印第一个字符、打印最后一个字符、打印中间字符
打印字前三个符、打印后三个字符
命题：金海在字符串content中
命题：京师监狱不在字符串content中
通过切片打印“京师监狱狱长”
通过切片打印“长狱狱监师京”
通过切片打印“我师狱海”
倒序打印字符
"""
content = "我是京师监狱狱长金海。"
print(content[0])
print(content[-len(content)])
print(content[len(content) - 1])
print(content[-1])
print(content[5])
print(content[len(content) // 2])
print(content[:3])
print(content[-3:])
print("金海" in content)
print("京师监狱" not in content)
print(content[2:-3])
print(content[-4:1:-1])
print(content[::3])
print(content[::-1])
内建函数
- len(x) 返回序列的长度
- max(x) 返回序列的最大值元素
- min(x) 返回序列的最小值元素
- sum(x) 返回序列中所有元素的和(元素必须是数值类型)
字符串 str
由一系列字符组成的不可变序列容器，存储的是字符的编码值
"""
字符串编码
"""
#字 --> 数
number = ord("a")
print(number) # 97
#数 --> 字
chrt = chr(97)
print(chrt) # a
编码
- 字节byte：计算机最小存储单位，等于8 位bit.
- 字符：单个的数字，文字与符号。
- 字符集(码表)：存储字符与二进制序列的对应关系。
- 编码：将字符转换为对应的二进制序列的过程。
- 解码：将二进制序列转换为对应的字符的过程。
- 编码方式：
–ASCII编码：包含英文、数字等字符，每个字符1个字节。
–GBK编码：兼容ASCII编码，包含21003个中文；英文1个字节，汉字2个字节。
–Unicode字符集：国际统一编码，旧字符集每个字符2字节，新字符集4字节。
–UTF-8编码：Unicode的存储与传输方式，英文1字节，中文3字节。
相关函数
- ord(字符串):返回该字符串的Unicode码。
- chr(整数):返回该整数对应的字符串。
"""
练习1：
在终端中录入一个内容,循环打印每个文字的编码值。
"""
for itme in input("请输入一个内容："):
number = ord(itme)
print(number)
"""
练习：
循环录入编码值打印文字，直到输入空字符串停止。
"""
while True:
str_number = input("请输入编码值：")
if str_number == "":
break
print(chr(int(str_number)))
字面值
单引和双引号的区别
- 单引号内的双引号不算结束符
- 双引号内的单引号不算结束符
三引号作用
- 换行会自动转换为换行符\n
- 三引号内可以包含单引号和双引号
- 作为文档字符串
转义字符
- 改变字符的原始含义。
\’ \” \””” \n \ \t \0 空字符 - 原始字符串：取消转义。
a = r”C:\newfile\test.py”
字符串格式化
- 定义：
生成一定格式的字符串。 - 语法：
字符串%(变量)
“我的名字是%s,年龄是%s” % (name, age) - 类型码：
%s 字符串 %d整数 %f 浮点数
"""
字符串字面值
"""
#1. 各种写法
content01 = "字面值"
content02 = '字面值'
#可见即所得
content03 = '''字面值'''
content03 = """
字
面
值"""
print(content03)
#2. 引号冲突
content04 = '我是"孙悟空"。'
content05 = "我是'孙悟空'。"
content06 = """我是'孙'悟"空"。"""
#3. 转义符:改变原始含义的特殊字符
#\" \' \\ \n换行 ...
content07 = "我是\"孙悟空\"。"
content08 = "我是\n孙悟空。"
url = "c:\\a\\b\c\d.txt"
#原始字符 r"字符串"
url = r"c:\a\b\c\d.txt"
print(content08)
#4. 字符串格式化
subject = "I"
predicate = "kiss"
object = "you"
#print("主语是:" + subject + ",谓语是:" + predicate + ",宾语是:" + object + ".")
print("主语是:%s,谓语是:%s,宾语是:%s." % (subject, predicate, object))
cure_rate = 99.5
#print("治愈比例为" + str(cure_rate) + "%")
print("治愈比例为%s%%" % (cure_rate))
#%f 用于控制小数精度
money = 1.23245124
print("金额是:%.2f元" % money) # 金额是:1.23元
#%d 用于控制整数位数
second = 6
print("秒：%.2d"%(second)) #秒：06
"""
练习：根据下列文字，提取变量，使用字符串格式化打印信息
湖北确诊67802人,治愈63326人,治愈率0.99
70秒是01分零10秒
"""
region = "湖北"
confirmed = 67802
cure = 63326
cure_rate = 0.99
print("%s确诊%s人,治愈%s人,治愈率%.2f" % (region, confirmed, cure, cure_rate))
second = 70
print("%s秒是%.2d分零%.2d秒" % (second, second // 60, second % 60))
列表 list
定义
由一系列变量组成的可变序列容器。
基础操作
- 创建列表：
列表名 = []
列表名 = list(可迭代对象)
- 添加元素：
列表名.append(元素)
列表.insert(索引，元素)
3. 定位元素：
列表名[索引] = 元素
变量 = 列表名[索引] # 赋值单个给变量不会创建新列表
变量 = 列表名[切片] # 赋值给变量的是切片所创建的新列表
列表名[切片] = 容器 # 右侧必须是可迭代对象，左侧切片没有创建新列表。遍历列表：
正向：
for 变量名 in 列表名:
变量名就是元素
反向：
for 索引名 in range(len(列表名)-1,-1,-1):
列表名[索引名]就是元素
- 删除元素：
列表名.remove(元素)
del 列表名[索引或切片]
# 练习1：
# 创建地区列表、新增列表、现有列表，至少存储3行信息
list_region = ["香港", "上海", "新疆"]
list_new = [15, 6, 0]
list_now = [393, 61, 49]
# 练习2：
# 向以上三个列表追加数据第4行数据
list_region.append("四川")
list_new.append(0)
list_now.append(27)
# 在第1个位置插入第5行数据
list_region.insert(0,"台湾")
list_new.insert(0,0)
list_now.insert(0,19)
print(list_region)
print(list_new)
print(list_now)
"""
练习3：
打印香港疫情信息(xx地区新增xx人现存xx人)
将地区列表后2个元素修改为 ["XJ","SC"]
打印地区列表元素(一行一个)
倒序打印新增列表元素(一行一个)
"""
list_region = ["香港", "上海", "新疆"]
list_new = [15, 6, 0]
list_now = [393, 61, 49]
print("%s地区新增%d人现存%s人" % (list_region[0], list_new[0], list_now[0]))
print(f"{list_region[0]}地区新增{list_new[0]}人现存{list_now[0]}人")
list_region[-2:] = ["XJ", "SC"]
print(list_region)
for region in list_region:
print(region)
for i in range(len(list_new) - 1, -1, -1):
print(list_new[i])
"""
练习4：
在地区列表中删除“新疆”
在新增列表中删除第1个元素
在现有列表中删除前2个元素
"""
list_region = ["香港", "上海", "新疆"]
list_new = [15, 6, 0]
list_now = [393, 61, 49]
list_region.remove("新疆")
del list_new[0]
del list_now[:2]
print(list_region)
print(list_new)
print(list_now)
"""
练习5：
八大行星："水星" "金星" "地球" "火星" "木星" "土星" "天王星" "海王星"
-- 创建列表存储4个行星：“水星” "金星" "火星" "木星"
-- 插入"地球"、追加"土星" "天王星" "海王星"
-- 打印距离太阳最近、最远的行星(第一个和最后一个元素)
-- 打印太阳到地球之间的行星(前两个行星)
-- 删除"海王星",删除第四个行星
-- 倒序打印所有行星(一行一个)
"""
list_planet = ["水星", "金星", "火星", "木星"]
list_planet.insert(2, "地球")
# list_planet.append("土星")
# list_planet.append("天王星")
# list_planet.append("海王星")
# list_planet += ["土星", "天王星", "海王星"]
list_planet[len(list_planet):] = ["土星", "天王星", "海王星"]
print(list_planet[0])
print(list_planet[-1])
print(list_planet[:2])
list_planet.remove("海王星")
del list_planet[3]
for i in range(len(list_planet) - 1, -1, -1):
print(list_planet[i])
深拷贝和浅拷贝
浅拷贝：复制过程中,只复制一层变量,不会复制深层变量绑定的对象的复制过程。
深拷贝：复制整个依懒的变量。
#练习1：画出下列代码内存图
list01 = ["北京", "上海"]
list02 = list01
list01[0] = "广州"
list03 = list01[:]
list03[-1] = "深圳"
print(list01)#?`
#练习2：画出下列内存图
list01 = ["北京", "上海", "深圳"]
list02 = list01
list01.insert(0,"天津")
del list01[1]
print(list02)# ?
#练习3：画出下列内存图
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(list02) # ?
列表与字符串转换
- 列表转换为字符串：
result = “连接符”.join(列表)
"""
练习：
在终端中,循环录入字符串,如果录入空则停止.
停止录入后打印所有内容(一个字符串)
"""
result = []
while True:
content = input("请输入内容：")
if content == "":
break
result.append(content)
result = "_".join(result)
print(result)
- 字符串转换为列表：
列表 = “a-b-c-d”.split(“分隔符”)
"""
练习：将下列英文语句按照单词进行翻转.
转换前：To have a government that is of people by people for people
转换后：people for people by people of is that government a have To
"""
message = "To have a government that is of people by people for people"
list_temp = message.split(" ")
message = " ".join(list_temp[::-1])
print(message)
列表推导式
定义
使用简易方法，将可迭代对象转换为列表。
语法
变量 = [表达式 for 变量 in 可迭代对象]
变量 = [表达式 for 变量 in 可迭代对象 if 条件]
说明
如果if真值表达式的布尔值为False,则可迭代对象生成的数据将被丢弃。
"""
练习：
生成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]
"""
# result = []
# for item in range(10,31):
# if item % 3 ==0 or item % 5 ==0:
# result.append(item)
result = [item for item in range(10,31)if item % 3 ==0 or item % 5 ==0]
print(result)
result = [item ** 2 for item in range(5,21)]
print(result)
列表推导式嵌套
- 语法：
变量 = [表达式 for 变量1 in 可迭代对象1 for 变量2 in可迭代对象2]
- 传统写法：
result = []
for r in ["a", "b", "c"]:
for c in ["A", "B", "C"]:
result.append(r + c)
- 推导式写法：
result = [r + c for r in list01 for c in list02]
"""
列表推导式嵌套
"""
list01 = ["香蕉", "苹果", "哈密瓜"]
list02 = ["牛奶", "咖啡", "雪碧", "可乐"]
# result = []
# for r in list01:
# for c in list02:
# result.append(r + c)
result = [r + c for r in list01 for c in list02]
print(result)
元组 tuple
定义
1. 由一系列变量组成的不可变序列容器。
2. 不可变是指一但创建，不可以再添加/删除/修改元素。
基础操作
- 创建空元组：
元组名 = ()
元组名 = tuple() - 创建非空元组：
元组名 = (20,)
元组名 = (1, 2, 3)
元组名 = 100,200,300
元组名 = tuple(可迭代对象) - 获取元素：
变量 = 元组名[索引]
变量 = 元组名[切片] # 赋值给变量的是切片所创建的新列表 - 遍历元组：
正向：
for 变量名 in 列表名:
变量名就是元素
反向：
for 索引名 in range(len(列表名)-1,-1,-1):
元组名[索引名]就是元素
练习1：
name = "张无忌"
names = ["赵敏", "周芷若"]
tuple01 = ("张翠山", name, names)
name = "无忌哥哥"
tuple01[2][0] = "敏儿"
print(tuple01) # ?
"""
练习2：
根据月日,计算是这一年的第几天.
公式：前几个月总天数 + 当月天数
例如：5月10日
计算：31 29 31 30 + 10
"""
month = int(input("请输入月份：")) # 5
day = int(input("请输入日：")) # 10
day_of_month = (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
# result = 0
# for i in range(month - 1):
# result += day_of_month[i]
result = sum( day_of_month[:month - 1] )
result += day
print(result)
作用
- 元组与列表都可以存储一系列变量，由于列表会预留内存空间，所以可以增加元素。
- 元组会按需分配内存，所以如果变量数量固定，建议使用元组，因为占用空间更小。
- 应用：
变量交换的本质就是创建元组：x, y = （y, x ）
格式化字符串的本质就是创建元祖：“姓名:%s, 年龄:%d” % (“tarena”, 15)
字典 dict
定义
1. 由一系列键值对组成的可变散列容器。
2. 散列：对键进行哈希运算，确定在内存中的存储位置，每条数据存储无先后顺序。
3. 键必须惟一且不可变(字符串/数字/元组)，值没有限制。
基础操作
- 创建字典：
字典名 = {键1：值1，键2：值2}
字典名 = dict (可迭代对象) - 添加/修改元素：
语法:
字典名[键] = 数据
说明:
键不存在，创建记录。
键存在，修改值。
3. 获取元素：
变量 = 字典名[键] # 没有键则错误
4. 遍历字典：
for 键名 in 字典名:
字典名[键名]
for 键名,值名 in 字典名.items():
语句
5. 删除元素：
del 字典名[键]
"""
练习1：
创建字典存储香港信息、字典存储上海信息、字典存储新疆信息
"""
dict_HongKong = {
"region": "香港",
"new": 15,
"now": 393,
"total": 4801,
"cure": 4320,
"death": 88
}
dict_shanghai = {
"region": "上海",
"new": 6,
"now": 61,
"total": 903,
"cure": 835,
"death": 7
}
dict_xingjiang = {
"region": "新疆",
"new": 0,
"now": 49,
"total": 902,
"cure": 850,
"death": 3
}
# 练习2：
# 在终端中打印香港的现有人数
print(dict_HongKong["now"])
# 在终端中打印上海的新增和现有人数
print(dict_shanghai["new"])
print(dict_shanghai["now"])
# 新疆新增人数增加1
dict_xingjiang["new"] += 1
"""
练习3：
删除香港现有人数信息
删除新疆新增人数信息
删除上海的新增和现有信息
"""
del dict_HongKong["now"]
del dict_xingjiang["new"]
del dict_shanghai["new"], dict_shanghai["now"]
"""
练习4：
在终端中打印香港字典的所有键(一行一个)
在终端中打印上海字典的所有值(一行一个)
在终端中打印新疆字典的所有键和值(一行一个)
在上海字典中查找值是61对应的键名称
"""
for key in dict_HongKong:
print(key)
for value in dict_shanghai.values():
print(value)
for key, value in dict_xingjiang.items():
print(key)
print(value)
for key, value in dict_shanghai.items():
if value == 61:
print(key)
break
字典推导式
定义：
使用简易方法，将可迭代对象转换为字典。
语法:
{键:值 for 变量 in 可迭代对象}
{键:值 for 变量 in 可迭代对象 if 条件}
"""
练习1：
将两个列表，合并为一个字典
姓名列表["张无忌","赵敏","周芷若"]
房间列表[101,102,103]
{101: '张无忌', 102: '赵敏', 103: '周芷若'}
练习2：
颠倒练习1字典键值
{'张无忌': 101, '赵敏': 102, '周芷若': 103}
"""
list_name = ["张无忌", "赵敏", "周芷若"]
list_room = [101, 102, 103]
# result = {}
# for i in range(len(list_name)):
# key = list_room[i]
# value = list_name[i]
# result[key] = value
result = {list_name[i]: list_room[i] for i in range(len(list_name))}
print(result)
# new_result = {}
# for key, value in result.items():
# new_result[value] = key
new_result = {value: key for key, value in result.items()}
print(new_result)
集合 set
定义
由一系列不重复的不可变类型变量(元组/数/字符串)组成的可变散列容器。
相当于只有键没有值的字典(键则是集合的数据)。
基础操作
-
创建空集合：
集合名 = set()
集合名 = set(可迭代对象) -
创建具有默认值集合：
集合名 = {1, 2, 3}
集合名 = set(可迭代对象) -
添加元素：
集合名.add(元素) -
删除元素：
集合名.discard(元素)
运算 -
交集&：返回共同元素。
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 & s2 # {2, 3} -
并集：返回不重复元素
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 | s2 # {1, 2, 3, 4} -
补集-：返回只属于其中之一的元素
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s1 - s2 # {1} 属于s1但不属于s2
补集^：返回不同的的元素
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 ^ s2 # {1, 4} 等同于(s1-s2 | s2-s1)
-
子集<：判断一个集合的所有元素是否完全在另一个集合中
-
超集>：判断一个集合是否具有另一个集合的所有元素
s1 = {1, 2, 3}
s2 = {2, 3}
s2 < s1 # True
s1 > s2 # True -
相同或不同== !=：判断集合中的所有元素是否和另一个集合相同
s1 = {1, 2, 3}
s2 = {3, 2, 1}
s1 == s2 # True
s1 != s2 # False
子集或相同,超集或相同 <= >=
练习：一家公司有如下岗位：
"经理"："曹操","刘备","孙权"
"技术" ："曹操","刘备","张飞","关羽"
1. 定义数据结构,存储以上信息.
2. 是经理也是技术的都有谁?
3. 是经理不是技术的都有谁?
4. 不是经理是技术的都有谁?
5. 身兼一职的都有谁?
6. 公司总共有多少人数?
dict_persons = {
"经理": {"曹操", "刘备", "孙权"},
"技术": {"曹操", "刘备", "张飞", "关羽"}
}
# 交集
print(dict_persons["经理"] & dict_persons["技术"])
# 补集
print(dict_persons["经理"] - dict_persons["技术"])
print(dict_persons["技术"] - dict_persons["经理"])
print(dict_persons["技术"] ^ dict_persons["经理"])
# 并集
print(len(dict_persons["技术"] | dict_persons["经理"]))
集合推导式
- 定义：
使用简易方法，将可迭代对象转换为集合。 - 语法:
{表达式 for 变量 in 可迭代对象}
{表达式 for 变量 in 可迭代对象 if 条件}
容器综合训练
"""
编辑代码，打印效果如下图：
******
######
******
######
"""
#4行 6列
for r in range(4): # 0 1 2 3
for c in range(6):
if r % 2 == 0:
print("*", end="")
else:
print("#", end="")
print()
"""
练习2：二维列表
list01 = [
[1, 2, 3, 4, 5],
[6, 7, 8, 9, 10],
[11, 12, 13, 14, 15],
]
1. 将第一行从左到右逐行打印
2. 将第二行从右到左逐行打印
3. 将第三列行从上到下逐个打印
4. 将第四列行从下到上逐个打印
5. 将二维列表以表格状打印
先根据需求写死代码
再根据规律写活代码
"""
list01 = [
[1, 2, 3, 4, 5],
[6, 7, 8, 9, 10],
[11, 12, 13, 14, 15],
]
for item in list01[0]:
print(item)
# print(list01[1][4])
# print(list01[1][3])
# print(list01[1][2])
# print(list01[1][1])
# print(list01[1][0])
for c in range(len(list01[1]) - 1, -1, -1):
print(list01[1][c])
# print(list01[0][2])
# print(list01[1][2])
# print(list01[2][2])
for r in range(len(list01)):
print(list01[r][2])
# print(list01[2][3])
# print(list01[1][3])
# print(list01[0][3])
for r in range(len(list01)-1,-1,-1):
print(list01[r][3])
# 可读可写
for r in range(len(list01)):
for c in range(len(list01[r])):
print(list01[r][c],end = "\t")
print()
# 只读
for line in list01:
for item in line:
print(item,end = "\t")
print()
"""
练习3：多个人的多个爱好
dict_hobbies = {
"于谦": ["抽烟", "喝酒", "烫头"],
"郭德纲": ["说", "学", "逗", "唱"],
}
1.打印于谦的所有爱好(一行一个)
2.计算郭德纲所有爱好数量
3.打印所有人(一行一个)
4.打印所有爱好(一行一个)
"""
dict_hobbies = {
"于谦": ["抽烟", "喝酒", "烫头"],
"郭德纲": ["说", "学", "逗", "唱"],
}
print(dict_hobbies["于谦"])
print(len(dict_hobbies["郭德纲"]))
for key in dict_hobbies:
print(key)
for value in dict_hobbies.values():
for item in value:
print(item)
"""
练习5：
对数字列表进行降序排列排列（大 --> 小）
"""
list01 = [54, 56, 7, 78, 8]
for r in range(len(list01) - 1):
for c in range(r + 1, len(list01)):
if list01[r] < list01[c]:
list01[r], list01[c] = list01[c], list01[r]
print(list01)
"""
1.打印所有商品信息,
格式：商品编号xx,商品名称xx,商品单价xx.
2. 打印所有订单中的信息,
格式：商品编号xx,购买数量xx.
3. 打印所有订单中的商品信息,
格式：商品名称xx,商品单价:xx,数量xx.
4. 查找数量最多的订单(使用自定义算法,不使用内置函数)
5. 根据购买数量对订单列表降序(大->小)排列
"""
# 商品字典
dict_commodity_infos = {
1001: {"name": "屠龙刀", "price": 10000},
1002: {"name": "倚天剑", "price": 10000},
1003: {"name": "金箍棒", "price": 52100},
1004: {"name": "口罩", "price": 20},
1005: {"name": "酒精", "price": 30},
}
# 订单列表
list_orders = [
{"cid": 1001, "count": 1},
{"cid": 1002, "count": 3},
{"cid": 1005, "count": 2},
]
# 1.打印所有商品信息,
# 格式：商品编号xx,商品名称xx,商品单价xx.
for key, value in dict_commodity_infos.items():
print(f'商品编号{key},商品名称{value["name"]},商品单价{value["price"]}.')
# 2. 打印所有订单中的信息,
# 格式：商品编号xx,购买数量xx.
for item in list_orders:
print("商品编号%s,购买数量%s." % (item["cid"], item["count"]))
# 3. 打印所有订单中的商品信息,
# 格式：商品名称xx,商品单价:xx,数量xx.
for item in list_orders:
# item["cid"] --> 1001
cid = item["cid"]
# dict_commodity_infos[1001] --> 商品信息
commodity = dict_commodity_infos[cid]
# commodity = dict_commodity_infos[item["cid"]]
print(f"商品名称{commodity['name']},商品单价:{commodity['price']},数量{item['count']}.")
# 4. 查找数量最多的订单(使用自定义算法,不使用内置函数)
max_value = list_orders[0]
for i in range(1, len(list_orders)):
if max_value["count"] < list_orders[i]["count"]:
max_value = list_orders[i]
print(max_value)
# 5. 根据购买数量对订单列表降序(大->小)排列
for r in range(len(list_orders) - 1):
for c in range(r + 1, len(list_orders)):
if list_orders[r]["count"] < list_orders[c]["count"]:
list_orders[r], list_orders[c] = list_orders[c], list_orders[r]
print(list_orders)
函数 function
pycharm快捷键
Ctrl + P 参数信息（在方法中调用参数）
Ctrl + Q 快速查看文档
定义
用于封装一个特定的功能，表示一个功能或者行为。
函数是可以重复执行的语句块, 可以重复调用。
作用
提高代码的可重用性和可维护性（代码层次结构更清晰）。
定义函数
- 语法：
def 函数名(形式参数):
函数体
- 说明：
def 关键字：全称是define，意为”定义”。
函数名：对函数体中语句的描述，规则与变量名相同。
形式参数：方法定义者要求调用者提供的信息。
函数体：完成该功能的语句。 - 函数的第一行语句建议使用文档字符串描述函数的功能与参数。
调用函数 - 语法：函数名(实际参数)
- 说明：根据形参传递内容。
"""
函数 - 入门
价值：减少代码的重复
语法：
def 函数名(?):
函数体
函数名()
"""
# 代码的重复是万恶之源
"""
# 做法(变化) + 用法
print("直拳")
print("摆拳")
print("勾拳")
print("肘击")
# ...
# 做法(变化) + 用法
print("直拳")
print("摆拳")
print("勾拳")
print("肘击")
"""
# 定义函数-做法(变化)
def attack():
print("直拳")
print("摆拳")
print("勾拳")
print("肘击")
print("鞭腿")
# 用法
attack()
# ...
# 用法
attack()
练习1： 定义函数,在终端中打印一维列表.
list01 = [5, 546, 6, 56, 76, ]
for item in list01:
print(item)
list02 = [7,6,879,9,909,]
for item in list02:
print(item)
练习2：创建函数,在终端中打印矩形.
number = int(input(“请输入整数:”)) # 5
for row in range(number):
if row == 0 or row == number - 1:
print("" * number)
else:
print("%s*" % (" " * (number - 2)))
返回值
- 定义：
方法定义者告诉调用者的结果。 - 语法：
return 数据 - 说明：
return后没有语句，相当于返回 None。
函数体没有return，相当于返回None。
练习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(“网络爬虫”)
elif number == “5”:
print(“数据分析、人工智能”)
练习4：创建函数,计算梯形面积.
top_base = float(input(“请输入上底：”))
bottom_base = float(input(“请输入下底：”))
height = float(input(“请输入高：”))
result = (top_base + bottom_base) * height / 2
print(“梯形面积是：” + str(result))
练习5：创建函数,计算IQ等级
ma = int(input(“请输入你的心里年龄：”))
ca = int(input(“请输入你的实际年龄：”))
iq = ma / ca * 100
if 140 <= iq:
print(“天才”)
elif 120 <= iq:
print(“超常”)
elif 110 <= iq:
print(“聪慧”)
elif 90 <= iq:
print(“正常”)
elif 80 <= iq:
print(“迟钝”)
else:
print(“低能”)
练习6：创建函数,根据年龄计算人生阶段
age = int(input(“请输入年龄：”))
if age <= 6:
print(“童年”)
elif age <= 17: # 程序能执行到本行,说明age一定大于6
print(“少年”)
elif age <= 40:
print(“青年”)
elif age <= 65:
print(“中年”)
else:
print(“老年”)
练习7：创建函数,根据年月日计算这是这一年的第几天.
如果2月是闰年,按29天计算
平年 28
month = int(input(“请输入月:”))
day = int(input(“请输入日:”))
days_of_month = (31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
total_days = sum(days_of_month[:month - 1])
total_days += day
print(f"{month}月{day}日是第{total_days}天.")
year = int(input(“请输入年份:”))
if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
day = 29
else:
day = 28
可变／不可变类型在传参时的区别
- 不可变类型参数有:
数值型(整数，浮点数)
布尔值bool
None 空值
字符串str
元组tuple - 可变类型参数有:
列表 list
字典 dict
集合 set - 传参说明：
不可变类型的数据传参时，函数内部不会改变原数据的值。
可变类型的数据传参时，函数内部可以改变原数据。
练习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, 200]
p2[:] = [300, 400]
a = [10, 20]
b = [30, 40]
func01(a, b)
print(a) # ?
print(b) # ?
练习3：根据下列代码，创建降序排列函数。
list01 = [5, 15, 25, 35, 1, 2]
for r in range(len(list01) - 1):
for c in range(r + 1, len(list01)):
if list01[r] < list01[c]:
list01[r], list01[c] = list01[c], list01[r]
print(list01)
练习4：定义函数，将列表中大于某个值的元素设置为None
参数 结果
[34, 545, 56, 7, 78, 8] -10-> [None,None,None,7,None,8]
[34, 545, 56, 7, 78, 8] -100-> [34, None, 56, 7, 78, 8]
函数参数
实参传递方式argument
位置传参
定义：实参与形参的位置依次对应。
序列传参
定义：实参用*将序列拆解后与形参的位置依次对应。
关键字传参
定义：实参根据形参的名字进行对应。
字典关键字传参
- 定义：实参用**将字典拆解后与形参的名字进行对应。
- 作用：配合形参的缺省参数，可以使调用者随意传参。
形参定义方式parameter
缺省形参 - 语法：
def 函数名(形参名1=默认实参1, 形参名2=默认实参2, …):
函数体 - 说明：
缺省参数必须自右至左依次存在，如果一个参数有缺省参数，则其右侧的所有参数都必须有缺省参数。
缺省参数可以有0个或多个，甚至全部都有缺省参数。
练习：
定义函数,根据小时、分钟、秒,计算总秒数
调用：提供小时、分钟、秒
调用：提供分钟、秒
调用：提供小时、秒
调用：提供分钟
位置形参
语法：
def 函数名(形参名1, 形参名2, …):
函数体
命名关键字形参 - 语法：
def 函数名(args, 命名关键字形参1, 命名关键字形参2, …):
函数体
def 函数名(, 命名关键字形参1, 命名关键字形参2, …):
函数体 - 作用：
强制实参使用关键字传参
不定长形参
星号元组形参 - 语法：
def 函数名(*元组形参名):
函数体 - 作用：
可以将多个位置实参合并为一个元组 - 说明：
一般命名为’args’
形参列表中最多只能有一个
练习：定义数值累乘的函数
双星号字典形参 - 语法：
def 函数名(**字典形参名):
函数体 - 作用：
可以将多个关键字实参合并为一个字典 - 说明:
一般命名为’kwargs’
形参列表中最多只能有一个
参数自左至右的顺序
位置形参 --> 星号元组形参 --> 命名关键字形参 --> 双星号字典形参
练习：说出程序执行结果.
def func01(list_target):
print(list_target)# ?
def func02(*args):# 三合一
print(args)# ?
def func03(args,**kwargs):# 三合一
print(args)# ?
print(kwargs)# ?
def func04(p1,p2,,p4,**kwargs):
print(p1)# 10
print(p2)# 20
print(p4)# 30
print(kwargs)# {p5 : 40}
func01([1,2,3])
func02(*[1,2,3])# 一拆三
func03(1,2,3,a=4,b=5,c=6)
func04(10,20,p4 = 30,p5 = 40)
作用域LEGB
-
作用域：变量起作用的范围。
-
Local局部作用域：函数内部。
-
Enclosing 外部嵌套作用域 ：函数嵌套。
-
Global全局作用域：模块(.py文件)内部。
-
Builtin内置模块作用域：builtins.py文件。
变量名的查找规则 -
由内到外：L -> E -> G -> B
-
在访问变量时，先查找本地变量，然后是包裹此函数外部的函数内部的变量，之后是全局变量，最后是内置变量。
局部变量 -
定义在函数内部的变量(形参也是局部变量)
-
只能在函数内部使用
-
调用函数时才被创建，函数结束后自动销毁
全局变量 -
定义在函数外部,模块内部的变量。
-
在整个模块(py文件)范围内访问（但函数内不能将其直接赋值）。
global 语句 -
作用：
在函数内部修改全局变量。
在函数内部定义全局变量(全局声明)。 -
语法：
global 变量1, 变量2, … -
说明
在函数内直接为全局变量赋值，视为创建新的局部变量。
不能先声明局部的变量，再用global声明为全局变量。
nonlocal 语句 -
作用：
在内层函数修改外层嵌套函数内的变量 -
语法
nonlocal 变量名1,变量名2, … -
说明
在被嵌套的内函数中进行使用练习：根据下列代码，创建函数。
商品字典
dict_commodity_infos = {
1001: {“name”: “屠龙刀”, “price”: 10000},
1002: {“name”: “倚天剑”, “price”: 10000},
1003: {“name”: “金箍棒”, “price”: 52100},
1004: {“name”: “口罩”, “price”: 20},
1005: {“name”: “酒精”, “price”: 30},
}
订单列表
list_orders = [
{“cid”: 1001, “count”: 1},
{“cid”: 1002, “count”: 3},
{“cid”: 1005, “count”: 2},
]
1.定义函数，打印所有商品信息,
for cid, info in dict_commodity_infos.items():
# print(f"商品编号{cid},商品名称{info[‘name’]},商品单价{info[‘price’]}.")
print(“商品编号%d,商品名称%s,商品单价%d.” % (cid, info[“name”], info[“price”]))
2. 定义函数，打印单价大于10000的商品信息,
for order in list_orders:
if info[“price”]>10000:
# print(f"商品编号{cid},商品名称{info[‘name’]},商品单价{info[‘price’]}.")
print(“商品编号%d,商品名称%s,商品单价%d.” % (cid, info[“name”], info[“price”]))
3. 定义函数，查找数量最多的订单(使用自定义算法,不使用内置函数)
max_value = list_orders[0]
for i in range(1, len(list_orders)):
if max_value[“count”] < list_orders[i][“count”]:
max_value = list_orders[i]
print(max_value)
4. 定义函数，根据购买数量对订单列表降序(大->小)排列
for r in range(len(list_orders) - 1):
for c in range(r + 1, len(list_orders)):
if list_orders[r][“count”] < list_orders[c][“count”]:
list_orders[r], list_orders[c] = list_orders[c], list_orders[r]
print(list_orders)