本文主要是介绍Python学习打卡：day09，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
day9
笔记来源于：黑马程序员python教程，8天python从入门到精通，学python看这套就够了
目录
- day9
- 64、字典课后习题
- 65、5类数据容器的总结对比
- 数据容器分类
- 数据容器特点对比
- 66、数据容器的通用操作
- 遍历
- 统计
- len、max 和 min
- 转换
- list(容器)、tuple(容器)、str(容器)、set(容器)
- 排序
- 容器通用功能总览
- 67、拓展——字符串的大小比较
- ASCII码表
- 字符串比较
- 68、函数的多返回值
- 69、函数的多种参数使用形式
- 函数参数种类
- 位置参数
- 关键字参数
- 缺省参数
- 不定长参数
- 位置传递
- 关键字传递
- 70、函数作为参数传递
- 71、lambda 匿名函数
- 72、文件编码概念
64、字典课后习题
my_dict = {"王力宏" : {"部门" : "科技部", "工资" : 3000, "级别" : 1},"周杰伦" : {"部门" : "市场部", "工资" : 5000, "级别" : 2},"林俊杰" : {"部门": "市场部", "工资": 7000, "级别": 3},"张学友" : {"部门": "科技部", "工资": 4000, "级别": 1},"刘德华" : {"部门": "市场部", "工资": 6000, "级别": 2}}print(f"全体员工当前信息如下：{my_dict}")for element in my_dict:if my_dict[element]["级别"] == 1:my_dict[element]["工资"] += 1000my_dict[element]["级别"] += 1
print(f"全体员工级别为1的员工完成升职加薪操作，操作后：{my_dict}")# 结果
全体员工当前信息如下：{'王力宏': {'部门': '科技部', '工资': 3000, '级别': 1}, '周杰伦': {'部门': '市场部', '工资': 5000, '级别': 2}, '林俊杰': {'部门': '市场部', '工资': 7000, '级别': 3}, '张学友': {'部门': '科技部', '工资': 4000, '级别': 1}, '刘德华': {'部门': '市场部', '工资': 6000, '级别': 2}}
全体员工级别为1的员工完成升职加薪操作，操作后：{'王力宏': {'部门': '科技部', '工资': 4000, '级别': 2}, '周杰伦': {'部门': '市场部', '工资': 5000, '级别': 2}, '林俊杰': {'部门': '市场部', '工资': 7000, '级别': 3}, '张学友': {'部门': '科技部', '工资': 5000, '级别': 2}, '刘德华': {'部门': '市场部', '工资': 6000, '级别': 2}}
65、5类数据容器的总结对比
数据容器分类
数据容器可以从以下视角进行简单的分类：
- 是否支持下标索引
- 支持：列表、元组、字符串——序列类型
- 不支持：集合、字典非序列类型
- 是否支持重复元素：
- 支持：列表、元组、字符串——序列类型
- 不支持：集合、字典——非序列类型
- 是否可以修改
- 支持：列表、集合、字典
- 不支持：元组、字符串
数据容器特点对比
| 列表 | 元组 | 字符串 | 集合 | 字典 | |
|---|---|---|---|---|---|
| 元素数量 | 支持多个 | 支持多个 | 支持多个 | 支持多个 | 支持多个 |
| 元素类型 | 任意 | 任意 | 仅字符 | 任意 | Key：Value Key：除字典外任意类型 Value：任意类型 |
| 下标索引 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
| 重复元素 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
| 可修改性 | 支持 | 不支持 | 不支持 | 支持 | 支持 |
| 数据有序 | 是 | 是 | 是 | 否 | 否 |
| 使用场景 | 可修改、可重复的一批数据记录场景 | 不可修改、可重复的一批数据记录场景 | 一串字符的记录场景 | 不可重复的数据记录场景 | 以Key检索Value的数据记录场景 |
66、数据容器的通用操作
遍历
在遍历上：
- 5类数据容器都支持for循环遍历；
- 列表、元组、字符串支持while循环，集合、字典不支持（无法下标索引）。
统计
len、max 和 min
my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "abcdefg"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1" : 1, "key2" : 2, "key3" : 3, "key4" : 4, "key5" : 5}# len 元素个数
print(f"列表元素个数有：{len(my_list)}")
print(f"元组元素个数有：{len(my_tuple)}")
print(f"字符串元素个数有：{len(my_str)}")
print(f"集合元素个数有：{len(my_set)}")
print(f"字典元素个数有：{len(my_dict)}")# max 最大元素max
print(f"列表最大的元素是：{max(my_list)}")
print(f"元组最大的元素是：{max(my_tuple)}")
print(f"字符串最大的元素是：{max(my_str)}")
print(f"集合最大的元素是：{max(my_set)}")
print(f"字典最大的元素是：{max(my_dict)}")# min 最小元素min
print(f"列表最小的元素是：{min(my_list)}")
print(f"元组最小的元素是：{min(my_tuple)}")
print(f"字符串最小的元素是：{min(my_str)}")
print(f"集合最小的元素是：{min(my_set)}")
print(f"字典最小的元素是：{min(my_dict)}")# 结果
列表元素个数有：5
元组元素个数有：5
字符串元素个数有：7
集合元素个数有：5
字典元素个数有：5
列表最大的元素是：5
元组最大的元素是：5
字符串最大的元素是：g
集合最大的元素是：5
字典最大的元素是：key5
列表最小的元素是：1
元组最小的元素是：1
字符串最小的元素是：a
集合最小的元素是：1
字典最小的元素是：key1
转换
list(容器)、tuple(容器)、str(容器)、set(容器)
# 类型转换:容器转列表
print(f"列表转列表的结果是：{list(my_list)}")
print(f"元组转列表的结果是：{list(my_tuple)}")
print(f"字符串转列表的结果是：{list(my_str)}")
print(f"集合转列表的结果是：{list(my_set)}")
print(f"字典转列表的结果是：{list(my_dict)}")# 类型转换:容器转元组
print(f"列表转元组的结果是：{tuple(my_list)}")
print(f"元组转元组的结果是：{tuple(my_tuple)}")
print(f"字符串转元组的结果是：{tuple(my_str)}")
print(f"集合转元组的结果是：{tuple(my_set)}")
print(f"字典转元组的结果是：{tuple(my_dict)}")# 类型转换:容器转字符串
print(f"列表转字符串的结果是str：{str(my_list)}") # 实际上是: "[1, 2, 3, 4, 5]"
print(f"元组转字符串字符串的结果是：{str(my_tuple)}") # 实际上是: "(1, 2, 3, 4, 5)"
print(f"字符串转字符串的结果是：{str(my_str)}")
print(f"集合转字符串的结果是：{str(my_set)}")
print(f"字典转字符串的结果是：{str(my_dict)}")# 类型转换:容器转集合set
print(f"列表转集合的结果是：{set(my_list)}")
print(f"元组转集合的结果是：{set(my_tuple)}")
print(f"字符串转集合的结果是：{set(my_str)}")
print(f"集合转集合的结果是：{set(my_set)}")
print(f"字典转集合的结果是：{set(my_dict)}")# 结果
列表转列表的结果是：[1, 2, 3, 4, 5]
元组转列表的结果是：[1, 2, 3, 4, 5]
字符串转列表的结果是：['a', 'b', 'c', 'd', 'e', 'f', 'g']
集合转列表的结果是：[1, 2, 3, 4, 5]
字典转列表的结果是：['key1', 'key2', 'key3', 'key4', 'key5']
列表转元组的结果是：(1, 2, 3, 4, 5)
元组转元组的结果是：(1, 2, 3, 4, 5)
字符串转元组的结果是：('a', 'b', 'c', 'd', 'e', 'f', 'g')
集合转元组的结果是：(1, 2, 3, 4, 5)
字典转元组的结果是：('key1', 'key2', 'key3', 'key4', 'key5')
列表转字符串的结果是str：[1, 2, 3, 4, 5]
元组转字符串字符串的结果是：(1, 2, 3, 4, 5)
字符串转字符串的结果是：abcdefg
集合转字符串的结果是：{1, 2, 3, 4, 5}
字典转字符串的结果是：{'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5}
列表转集合的结果是：{1, 2, 3, 4, 5}
元组转集合的结果是：{1, 2, 3, 4, 5}
字符串转集合的结果是：{'e', 'a', 'b', 'f', 'c', 'd', 'g'}
集合转集合的结果是：{1, 2, 3, 4, 5}
字典转集合的结果是：{'key4', 'key5', 'key1', 'key3', 'key2'}
排序
sorted(容器, [reverse=True])
将给定容器进行排序
tips：排序后都会得到列表（list）对象。
# 进行容器的排序
# 排序的结果都是存入列表中
my_list = [3, 1, 2, 5, 4]
my_tuple = (3, 1, 2, 5, 4)
my_str = "dbfgeac"
my_set = {3, 1, 2, 5, 4}
my_dict = {"key3" : 1, "key1" : 2, "key2" : 3, "key5" : 4, "key5" : 4}print(f"列表对象的排序结果:{sorted(my_list)}")
print(f"列表对象的排序结果:{sorted(my_tuple)}")
print(f"列表对象的排序结果:{sorted(my_str)}")
print(f"列表对象的排序结果:{sorted(my_set)}")
print(f"列表对象的排序结果:{sorted(my_dict)}")print(f"列表对象的反向排序结果:{sorted(my_list, reverse=True)}")
print(f"列表对象的反向排序结果:{sorted(my_tuple, reverse=True)}")
print(f"列表对象的反向排序结果:{sorted(my_str, reverse=True)}")
print(f"列表对象的反向排序结果:{sorted(my_set, reverse=True)}")
print(f"列表对象的反向排序结果:{sorted(my_dict, reverse=True)}")# 结果
列表对象的排序结果:[1, 2, 3, 4, 5]
列表对象的排序结果:[1, 2, 3, 4, 5]
列表对象的排序结果:['a', 'b', 'c', 'd', 'e', 'f', 'g']
列表对象的排序结果:[1, 2, 3, 4, 5]
列表对象的排序结果:['key1', 'key2', 'key3', 'key4', 'key5']
列表对象的反向排序结果:[5, 4, 3, 2, 1]
列表对象的反向排序结果:[5, 4, 3, 2, 1]
列表对象的反向排序结果:['g', 'f', 'e', 'd', 'c', 'b', 'a']
列表对象的反向排序结果:[5, 4, 3, 2, 1]
列表对象的反向排序结果:['key5', 'key4', 'key3', 'key2', 'key1']
容器通用功能总览
| 功能 | 描述 |
|---|---|
| 通用for循环 | 遍历容器（字典是遍历key） |
| max | 容器内最大元素 |
| min() | 容器内最小元素 |
| len() | 容器元素个数 |
| list() | 转换为列表 |
| tuple() | 转换为元组 |
| str() | 转换为字符串 |
| set() | 转换为集合 |
| sorted(序列, [reverse=True]) | 排序，reverse=True表示降序 得到一个排好序的列表 |
67、拓展——字符串的大小比较
ASCII码表
在程序中，字符串所用的所有字符如：
- 大小写英文单词
- 数字
- 特殊符号(
!、\、|、@、#、空格等）
都有其对应的ASCII码表值
每一个字符都能对应上一个：数字的码值
字符串进行比较就是基于数字的码值大小进行比较的。
字符串比较
字符串是按位比较，也就是一位位进行对比，只要有一位大，那么整体就大。
68、函数的多返回值
基本语法格式：
- 按照返回值的顺序，写对应顺序的多个变量接收即可；
- 变量之间用逗号隔开；
- 支持不同类型的数据 return。
示例：
"""
演示函数的多返回值示例
"""# 演示使用多个变量，接收多个返回值
def Test_return():return 1, "hello", Truex, y, z = Test_return()
print(x)
print(y)
print(z)
69、函数的多种参数使用形式
函数参数种类
使用方式上的不同, 函数有4中常见参数使用方式:
- 位置参数
- 关键字参数
- 缺省参数
- 不定长参数
位置参数
**位置参数：**调用函数时根据函数定义的参数位置来传递参数。
tips：传递的参数和定义的参数的顺序及个数必须一致
def userinfo(name, age, gender):print(f"姓名是:{name}, 年龄是:{age}, 性别:{gender}")# 位置参数 — 默认使用形式
userinfo('小明', 20, '男')# 结果
姓名是:小明, 年龄是:20, 性别:男
关键字参数
关键字参数：函数调用时通过“键=值”形式传递参数；
作用: 可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求
。
tips：函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序。
def userinfo(name, age, gender):print(f"姓名是:{name}, 年龄是:{age}, 性别:{gender}")
# 关键字参数
userinfo(name='小王', age=11, gender='女')
userinfo(age=10, gender='女', name='潇潇') # 可以不按照参数的定义顺序传参
userinfo('甜甜', gender='女', age=9)# 结果
姓名是:小王, 年龄是:11, 性别:女
姓名是:潇潇, 年龄是:10, 性别:女
姓名是:甜甜, 年龄是:9, 性别:女
缺省参数
**缺省参数：**缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）。
作用：当调用函数时没有传递参数, 就会使用默认是用缺省参数对应的值。
tips：函数调用时，如果为缺省参数传值则修改默认参数值, 否则使用这个默认值。
# 缺省参数（默认值）
def userinfo(name, age, gender='男'):print(f"姓名是:{name}, 年龄是:{age}, 性别:{gender}")
userinfo('小天', 13)
userinfo('小天', 13, gender='女')# 结果
姓名是:小天, 年龄是:13, 性别:男
姓名是:小天, 年龄是:13, 性别:女
不定长参数
**不定长参数：**不定长参数也叫可变参数。用于不确定调用的时候会传递多少个参数(不传参也可以)的场景。
作用：当调用函数时不确定参数个数时, 可以使用不定长参数。
不定长参数的类型:
- 位置传递
- 关键字传递
位置不定长传递以 * 号标记一个形式参数，以元组的形式接受参数，形式参数一般命名为 args；
关键字不定长传递以**号标记一个形式参数，以字典的形式接受参数，形式参数一般命名为 kwargs。
位置传递
tips：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)，args是元组类型，这就是位置传递。
# 不定长 — 位置不定长，*号
# 不定长定义的形式参数会作为元组存在，接收不定长数量的参数传入
def user_info(*args):print(f"args参数的类型是：{type(args)},内容是：{args}")user_info(1, 2, 3, '小明', '男孩')# 结果
args参数的类型是：<class 'tuple'>,内容是：(1, 2, 3, '小明', '男孩')
关键字传递
tips：参数是 “键=值” 形式的形式的情况下, 所有的 “键=值” 都会被 kwargs 接受, 同时会根据 “键=值” 组成字典。
# 不定长 — 关键字不定长，**号 key-value
def user_info(**args):print(f"args参数的类型是：{type(args)},内容是：{args}")
user_info(name='小王', age=11, gender='男孩')# 结果
args参数的类型是：<class 'dict'>,内容是：{'name': '小王', 'age': 11, 'gender': '男孩', 'hello': 'world'}
70、函数作为参数传递
函数compute，作为参数，传入了 test_func 函数中使用。
- test_func 需要一个函数作为参数传入，这个函数需要接收2个数字进行计算，计算逻辑由这个被传入函数决定；
- compute 函数接收 2 个数字对其进行计算，compute 函数作为参数，传递给了test_func 函数使用；
- 最终，在 test_func 函数内部，由传入的 compute 函数，完成了对数字的计算操作。
所以，这是一种，计算逻辑的传递，而非数据的传递。
就像上述代码那样，不仅仅是相加，相见、相除、等任何逻辑都可以自行定义并作为函数传入。
"""
演示函数作为参数传递
"""# 定义一个函数，接收另一个函数作为传入参数
def Test_func(compute):result = compute(1, 2) # 确定 compute是函数print(type(compute))print(f"compute 参数的类型是：{type(compute)}")print(f"计算结果：{result}")# 定义一个函数，准备作为参数传入另一个函数
def compute(x, y):return x + y# 调用，并传入参数
Test_func(compute)# 结果
<class 'function'>
compute 参数的类型是：<class 'function'>
计算结果：3
71、lambda 匿名函数
函数的定义中
- def 关键字，可以定义带有名称的函数
- lambda 关键字，可以定义匿名函数（无名称）
有名称的函数，可以基于名称重复使用。
无名称的匿名函数，只可临时使用一次。
匿名函数定义语法：
- lambda 是关键字，表示定义匿名函数；
- 传入参数表示匿名函数的形式参数，如：x, y 表示接收2个形式参数；
- 函数体，就是函数的执行逻辑，要注意：只能写一行，无法写多行代码。
如下图代码，我们可以：
-
通过 def 关键字，定义一个函数，并传入，如下图：
-
也可以通过 lambda 关键字，传入一个一次性使用的lambda匿名函数
使用 def 和使用 lambda，定义的函数功能完全一致，只是 lambda 关键字定义的函数是匿名的，无法二次使用。
"""
演示 lambda 匿名函数
"""# 定义一个函数，接受其他函数输入
def Test_func(compute):result = compute(1, 2)print(f"结果是：{result}")# 通过 lambda 匿名函数的形式，将匿名函数作为参数传入
Test_func(lambda x, y: x+y)# 对比
def add(x, y):return x+y
Test_func(add)# 结果
结果是：3
结果是：3
72、文件编码概念
编码技术即：翻译的规则，记录了如何将内容翻译成二进制，以及如何将二进制翻译回可识别内容。
计算机中有许多可用编码：
- UTF-8
- GBK
- Big5
- 等
不同的编码，将内容翻译成二进制也是不同的。
编码有许多，所以要使用正确的编码， 才能对文件进行正确的读写操作呢。
如上，如果你给喜欢的女孩发送文件，使用编码A进行编码（内容转二进制）。
女孩使用编码B打开文件进行解码（二进制反转回内容）
我们可以使用Windows系统自带的记事本，打开文件后，即可看出文件的编码是什么：
UTF-8是目前全球通用的编码格式。
除非有特殊需求，否则，一律以UTF-8格式进行文件编码即可。
这篇关于Python学习打卡：day09的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
