day9

笔记来源于：黑马程序员python教程，8天python从入门到精通，学python看这套就够了

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格式进行文件编码即可。