python基础专栏
python基础（第五期）
文章目录
- python基础（第五期）
- 数据容器
- 一、列表
- 1、列表的定义
- 2、列表的下标索引
- 3、列表的(添加)方法
- 3.1 列表的查询方法
- 3.2 修改特定下标索引的值
- 3.3 列表指定位置插入元素
- 3.3 列表指定元素的追加（尾部添加）
- 3.4 列表尾部追加指定的容器
- 4、列表的(删除)方法
- 4.1 删除列表元素
- 4.2 删除列表的第一个匹配项
- 4.3 清空整个列表
- 5、 统计列表元素
- 5.1 统计列表指定元素个数
- 5.2 统计列表元素的总数量
- 6、列表小结：
- 二、列表遍历
- 三、元组的定义和使用
- 1、元组的定义
- 2、元组的相关操作
- 3、元组的注意事项
- 四、元组的遍历
- 五、字符串
- 5.1 index方法
- 5.2 replace字符串替换
- 5.3 split 字符串分隔（切片）
- 5.4 strip （字符串规整操作） 去首尾空格
- 5.5 count方法统计字符串出现的个数
- 5.6 len方法统计长度
- 六、序列（容器）的切片操作
- 七、集合的定义和使用
- 7.1 基本语法定义
- 7.2 添加指定元素（add）
- 7.3 移除指定元素（remove）
- 7.4 随机取元素（pop）
- 7.5 清空集合 （clear）
- 八、集合的差集
- 8.1 取集合的差集（difference）
- 8.2 消除集合的差集 (difference_update)
- 8.3 合并集合（union）
- 8.4 统计集合元素方法 （len）
- 8.5 集合的遍历(for )
- 8.6 集合总结
- 九、字典定义
- 9.1 字典的定义
- 9.2 获取字典
- 9.3 字典的嵌套
- 9.4 字典的注意事项
- 十、字典的操作
- 10.1 新增元素
- 10.2 更新元素
- 10.3 删除字典元素（pop）
- 10.4 清空字典（clear）
- 2、获取全部的 key
- 3、 遍历字典
- 统计字典中元素的个数
- 字典小结
- 字典练习
数据容器
在Python中，常见的数据容器有以下几种：
- 列表（List）：列表是最常用的数据容器之一，可以存储任意类型的数据，并且允许重复的元素。列表使用方括号 [] 来表示，各个元素之间用逗号分隔。
- 元组（Tuple）：元组也是一种常见的数据容器，与列表相似，可以存储任意类型的数据。但不同的是，元组使用圆括号 () 来表示，且元素不能修改。
- 字典（Dictionary）：字典是一种键值对（Key-Value）的数据容器，可以根据键（Key）来快速检索对应的值（Value）。字典使用花括号 {} 来表示，每个键值对之间用冒号 : 分隔，键和值之间用逗号分隔。
- 集合（Set）：集合是一种无序且不重复的数据容器，可以进行交集、并集、差集等基本操作。集合使用花括号 {} 来表示，各个元素之间用逗号分隔。
这些数据容器在处理数据时具有不同的特点和用途，可以根据实际需求选择使用
一、列表
1、列表的定义
- 以 [] 作为标识
- 列表内每一个元素之间用，逗号隔开
基本语法
列表名 = [元素1， 元素2， 元素3， ....]
列表名 = [[列表元素1], [列表元素2], [列表元素3], [列表元素4]]
注意点：
- 列表中元素存储的类型可以是不同的。
- 里面的元素也可以是变量。
- 元素可以是嵌套列表哦！里面的子列表就是父列表的一个元素。
"""
容器： 列表（list）
"""
# 定义一个列表list
my_list = ["liujintao", "python", "hello world"]
print(my_list)
print(type(my_list))
my_list = ["helloPython", 999, True, 'A']
print(my_list)
print(type(my_list))
# 定义一个嵌套列表
my_list = [[1, 2, 3], [4, 5, 6]]
print(my_list)
print(type(my_list))
2、列表的下标索引
想要从列表中找到特定位置的数据，就得用 “下标索引”。
书写格式：my_list[0] 或者my_list[-1] → 嵌套写法：先取子列表，在取子列表里面的索引号哦
- 正向默认索引从 0 开始，反向默认从 -1 开始。
- 还需注意列表索引不能超出范围哦！
# 通过下标索引取出对应位置的数据
my_list = ["liu", "jin", "tao"]
print(my_list[0]) # 输出结果liu
print(my_list[-1]) # 输出结果tao
# print(my_list[3]) # 报错，下标超出范围
# 取出嵌套列表的元素
my_list = [[1, 2, 3], [4, 5, 6]]
print(my_list[1][-1]) # 输出结果： 6
方法表
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传
3、列表的(添加)方法
之前我么学过函数就知道，函数就是封装的一个代码单元，完成特定的功能
-
在python中，如果将函数定义为 class（类）的成员，那么函数就会称为： 方法。
-
函数和方法就是一样的（就是调用方法有些差异）
3.1 列表的查询方法
- 查找某元素的下标： 查找某元素在列表中的下标，找到则返回索引号，否则报错
语法格式：
列表.index(元素)
# 定义一个列表
my_list = ["liu", "jin", "tao"]
# 1、查找列表中某元素下标索引号
index = my_list.index("jin")
print(f"jin的下标索引号是{index}") # jin的下标索引号是1
# 2、查找元素不存在，报错
index = my_list("hello")
# print(f"hello的下标索引号是{index}") # 报错：因为不在列表中
3.2 修改特定下标索引的值
语法格式：
my_list[索引号] = 新值
# 1、修改特定下标索引的值
my_list[0] = "Yu"
print(my_list) # ['Yu', 'jin', 'tao']
3.3 列表指定位置插入元素
语法格式：
my_list.insert(下标， 插入的元素)
# 1、 在列表指定下标插入元素
my_list.insert(1, "Xin")
print(my_list) # ['Yu', 'Xin', 'jin', 'tao']
3.3 列表指定元素的追加（尾部添加）
语法格式：
my_list.append(追加的元素)
# 1、列表指定元素的追加（尾部添加）
my_list.append("like")
print(my_list) # ['Yu', 'Xin', 'jin', 'tao', 'like']
3.4 列表尾部追加指定的容器
my_list.extend(追加的容器)
# 1、尾部追加一批元素(容器)
my_list2 = ["Y", "a", "o"]
my_list.extend(my_list2)
print(my_list) # ['Yu', 'Xin', 'jin', 'tao', 'like', 'Y', 'a', 'o']
4、列表的(删除)方法
4.1 删除列表元素
语法格式：
方法一： del 列表名[下标]
方法二：列表名.pop(下标)
my_list = ["liu", "jin", "tao"]
# 1、方法一：删除指定下标元素
del my_list[0]
print(my_list) # ['jin', 'tao']
# 2、方法二：列表.pop(下标)
my_list.pop(0)
print(my_list) # ["tao"]
4.2 删除列表的第一个匹配项
语法格式：
列表名.remove(元素)
# 3、删除列表的第一个匹配项
my_list = [1, 3, 1, 3, 5, 6, 7, 8, 1, 10]
print(len(my_list)) # 10
# 删除元素 3
mylist = my_list.remove(3)
print(my_list) # [1, 1, 3, 5, 6, 7, 8, 1, 10]
print(len(my_list)) # 9
4.3 清空整个列表
语法格式：
列表名.clear()
# 4、 清空列表
my_list.clear()
print(my_list) # []
5、 统计列表元素
5.1 统计列表指定元素个数
my_list2 = ["Y", "a", "o"]
语法格式：
列表.count(元素)
# 1、统计列表指定元素个数
count = my_list2.count("Y")
print(count) # Y 的数量为 1
5.2 统计列表元素的总数量
语法格式：
len(列表名)
num = len(my_list2)
print(num) # 3
6、列表小结：
- 列表可以存放多个元素（也是有限的，只不过正常情况下，我们是用不完的）
- 混装：列表中的元素可以不同类型
- 下标：列表中的元素存放是有序的
- 重复：列表中允许数据重复
- 可操作：允许我们对列表中的数据进行操作
二、列表遍历
语法：请看下面示例注意看函数说明文档
"""
list:遍历迭代
"""
# 用 while循环实现
def list_while_func():
"""
这个函数的作用是使用while遍历列表
:return: None
:index: 是列表的索引号
:len(my_list): 是while循环的终止条件
:my_list[index]: 根据列表的索引号访问列表达到遍历的效果
"""
my_list = ["liu", "jin", "tao"]
index = 0
while index < len(my_list):
print(my_list[index])
index += 1
list_while_func()
"""
返回结果：
liu
jin
tao
"""
# 用for循环实现
def list_for_func():
"""
使用for循环遍历列表
:return: None
:range: 同样的是循环的条件
:len(my_list): 是列表的长度，只要 条件变量 i 还在 长度数值范围内，循环执行
"""
my_list = ["liu", "jin", "tao"]
for i in range(len(my_list)):
print(my_list[i])
list_for_func()
"""
返回结果：
liu
jin
tao
"""
使用场景
while ：适用于任何想要的循环
for： 遍历数据容器的场景或简单的固定次数的循环场景
三、元组的定义和使用
想想看，列表里面的元素是不是可以被修改？
- 那么元组定义后，它里面的元素就不能被修改哦！
列表是可读写的，而元组只能读不能写。
也就是说，我们希望数据不被修改，此时使用元组是最好不过了。
1、元组的定义
和列表一样，就是将[] 换成 （）即可
# 元组字面量
(元素1， 元素2， 元素3，.......)
# 元组变量
变量名称 = （元素， 元素， 元素， .....）
# 空的元组
变量名称 = （）
变量名称 = tuple（）
"""
演示 tuple 元组的定义使用
"""
# 定义元组
t1 = (1, "hello", True)
t2 = ()
t3 = tuple()
print(f"t1的类型是：{type(t1)},内容是:{t1}") # t1的类型是：<class 'tuple'>,内容是:(1, 'hello', True)
print(f"t2的类型是：{type(t2)},内容是:{t2}") # t2的类型是：<class 'tuple'>,内容是:()
print(f"t3的类型是：{type(t3)},内容是:{t3}") # t3的类型是：<class 'tuple'>,内容是:()
# 定义单个元素
t4 = (1,)
print(f"t4的类型是：{type(t4)},内容是:{t4}") # t4的类型是：<class 'tuple'>,内容是:(1,)
# 嵌套元组
t5 = ((1, 2, 3), (4, 5, 6))
print(f"t5的类型是：{type(t5)},内容是:{t5}") # t5的类型是：<class 'tuple'>,内容是:((1, 2, 3), (4, 5, 6))
# t5里面取出第 6 个元素
print(t5[1][2]) # 输出结果： 6
2、元组的相关操作
| 编号 | 方法 | 作用 |
|---|---|---|
| 1 | index（） | 查找某个数据，有返回下标，没有则报错 |
| 2 | count（） | 统计某个数据在当前元组出现的次数 |
| 3 | len（元组） | 统计元组内的元素个数 |
# 1、index方法
t6 = ("liu", "jin", "tao")
index = t6.index("jin")
print(f"在元组t6中，查找 jin 的下标为：{index}") # 在元组t6中，查找 jin 的下标为：1
# 2、count方法
t7 = ("liu", "jin", "jin", "jin", "tao")
count = t7.count("jin")
print(f"在元组t7中，元素个数为：{count}") # 在元组t7中，元素个数为：3
# 3、len方法
t8 = ("liu", "jin", "jin", "jin", "tao")
print(f"元组t8的长度为：{len(t8)}") # 元组t8的长度为：5
3、元组的注意事项
1、 元组是不可以被修改的
2、我们再元组中嵌套了 列表（list）， 这样我们是可以修改里面列表的元素哦。
唯一可修改的地方（内部列表）：
t11 = (1, 2, 3, ["liu", "jin", "tao"])
print(f"t11元组的内容是：{t11}") # t1元组的内容是：(1, 2, 3, ['liu', 'jin', 'tao'])
t11[3][0] = "LIU"
print(f"修改后的值为：{t11}") # 修改后的值为：(1, 2, 3, ['LIU', 'jin', 'tao'])
四、元组的遍历
- 和列表一样，既然可以操作小标，那么遍历也是一样的。
# 1、元组的遍历：while
t9 = ("liu", "jin", "jin", "jin", "tao")
i = 0
while i < len(t9):
print(t9[i])
i += 1
# 2、元组的遍历：for
t10 = ("liu", "jin", "jin", "jin", "tao")
for i in range(len(t10)):
print(t10[i])
五、字符串
字符串也是容器，一个字符串可以存放多个字符。
- 字符串是只读的，并不支持修改哦
- 长度任意：取决于内存大小
- 支持下标索引
- 允许重复字符
- 支持for循环
5.1 index方法
# index方法
my_srt = "hello world"
print(my_srt.index("l")) # 2
print(my_srt.index("o")) # 4
print(my_srt.index("w")) # 6
print(my_srt.index("d")) # 10
# print(my_srt.index("z")) # 报错
5.2 replace字符串替换
语法：字符串.replace(字符串1，字符串2)
功能：将字符串内的全部： 字符串1，替换为字符串2
注意：不是修改字符串本身，而是返回新的字符串，注意接收返回的新值哦！
new_my_str = my_str.replace("world", "python")
print(new_my_str) # hello python
5.3 split 字符串分隔（切片）
语法：字符串.split(分隔符字符串)
功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入到列表对象中
注意：字符串本身不变，而是得到一个新的列表对象
my_str = "liu jin tao"
my_str_list = my_str.split(" ")
print(my_str_list) # ['liu', 'jin', 'tao']
5.4 strip （字符串规整操作） 去首尾空格
语法1：字符串.strip()
语法2：字符串.strip(字符串)
new_my_str = my_str.strip()
print(new_my_str) # liujintao like code 99
# 用法2
new_my_str = my_str.strip("99")
print(new_my_str) # liujintao like code
5.5 count方法统计字符串出现的个数
count = my_str.count("l")
print(count) # 2
5.6 len方法统计长度
lens = len(my_str)
print(lens) # 34
六、序列（容器）的切片操作
上面学习的 ：列表、元组、字符串都是序列哦。
语法格式：
序列[起始下标 ：结束下标 ：步长]
表示从序列中，从指定位置开始，一次取出元素，到指定位置结束，得到一个新的序列。
省略的话默认从头或到尾。
注意点：切片操作不会影响到序列本身，因为操作后会得到一个新的序列。
"""
序列切片
"""
# 对List进行切片，从 1开始，4结束， 步长为1
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(my_list[1:4]) # [2, 3, 4]
print(my_list[1:4:1]) # [2, 3, 4]
# 对tuple进行切片，从头开始，到最后，步长为1
my_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print(my_tuple[0:]) # (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print(my_tuple[:]) # (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print(my_tuple[::]) # (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
# 对str进行切片，从头开始，到最后结束，步长为2
my_str = "0123456789"
print(my_str[0::2]) # 02468
print(my_str[::2]) # 02468
# 倒序: 对列表进行切片, 从 3 开始， 1 结束， 步长 -1
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(my_list[3:1:-1]) # [4, 3]
# 倒序: 对tuple进行切片, 从头开始， 尾结束， 步长 -2
my_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print(my_tuple[::-2]) # (10, 8, 6, 4, 2)
七、集合的定义和使用
我们学习了，列表、元组、字符三个数据容器其实基本上能够满足大多数场景，为何还需要学习集合类型？
列表可修改，支持重复元素且有序
元组、字符串不可修改、支持重复元素且有序
由此发现：都是有序的啊！有什么方法可以乱序啊！
此时，就得使用集合了。
注意：
- 首先，因为集合是无序的，所以集合不支持：下标索引访问。
- 但是集合和列表一样，是允许修改的，所以我们来看看集合的修改方法。
7.1 基本语法定义
列表、元组、字符串等定义的语法基本相同：
# 定义集合字面量
{元素， 元素， .....}
# 定义集合变量
变量名称 = {元素， 元素， .....}
# 定义空集合
变量名称 = set()
"""
集合的几把呢使用
"""
# 定义集合
my_set = {"liu", "jin", "tao"}
my_set_empty = set()
print(f"my_set的内容是：{my_set}, 类型是：{type(my_set)}") # my_set的内容是：{'liu', 'jin', 'tao'}, 类型是：<class 'set'>
print(f"my_set的内容是：{my_set_empty}, 类型是：{type(my_set_empty)}") # my_set的内容是：set(), 类型是：<class 'set'>
7.2 添加指定元素（add）
set.add(元素):将指定元素，添加到集合内。
集合本身被修改，添加了新元素
my_set.add("python")
my_set.add("java")
print(f"my_set添加元素结果为：{my_set}") # my_set添加元素结果为：{'python', 'liu', 'tao', 'jin'}
由于集合是去重的，不能有重复的，如果我们添加的元素集合里面有，那么就不会再次进行添加。
7.3 移除指定元素（remove）
set.remove(元素)：将指定元素，从集合内移除。
集合本身被修改，移除了元素
my_set.remove("tao")
print(f"my_set移除元素结果为：{my_set}") # my_set移除元素结果为：{'python', 'java', 'liu', 'jin'}
7.4 随机取元素（pop）
my_set.pop()
print(f"my_set随机取元素结果为：{my_set}") # {'liu', 'jin', 'python'}
7.5 清空集合 （clear）
my_set.clear()
print(f"my_set清空集合结果为：{my_set}") # set()
八、集合的差集
8.1 取集合的差集（difference）
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(f"取差集后的结果是：{set3}, 元素有的集合为：{set1, set2}") # 取差集后的结果是：{2, 3}, 元素有的集合为：({1, 2, 3}, {1, 5, 6})
- 去除元素相同的，得到新的集合（原来的集合不变）
8.2 消除集合的差集 (difference_update)
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(f"消除差集后的集合1为：{set1}, 集合2为：{set2}") # 消除差集后的集合1为：{2, 3}, 集合2为：{1, 5, 6}
- 消除两个集合中相同的元素（此时集合1就会发生变化）
8.3 合并集合（union）
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(f"两集合合并后结果为：{set3}") # 两集合合并后结果为：{1, 2, 3, 5, 6}
- 将两个集合合并起来，但是重复的只保留一个（得到新的集合）
8.4 统计集合元素方法 （len）
set1 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
num = len(set1)
print(num) # 5 （因为集合去重）
8.5 集合的遍历(for )
- 集合没有下标，不能使用while（只能用for处理）
for i in set1:
print(i) # 1 2 3 4 5
集合练习
信息去重：
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9, "liu", "jin", "liu", "jin", "tao"]
my_set = set()
for i in my_list: # 将列表中的元素一个一个拿出来添加到集合中
my_set.add(i)
print(my_set) # {1, 2, 3, 4, 5, 6, 7, 8, 9, 'jin', 'tao', 'liu'}
8.6 集合总结
集合总结：
1、可以容纳多个数据
2、可以容纳不同数据类型的数据
3、数据时无序的（不支持下标索引）
4、不允许重复数据存在
5、可以修改（增加或删除元素）
6、支持（for循环）遍历
九、字典定义
生活中的字典就是：字：含义
字典的定义同样使用{}，不过存储的元素是一个个的键值对，如下所示：
# 定义字典字面量
{key: value, key: value, .....}
# 定义字典字面量
my_dict = {key: value, key: value,......}
# 定义空字典
my_dict = {}
my_dict = dict()
9.1 字典的定义
my_dict = {"name": "张三", "age": 18}
print(type(my_dict)) # <class 'dict'>
print(my_dict) # {'name': '张三', 'age': 18}
# 定义空的字典
empty_dict = {}
my_dict1 = dict()
print(empty_dict) # {}
print(my_dict1) # {}
9.2 获取字典
my_dict = {"name": "张三", "age": 18}
age = my_dict["age"]
print(age) # 18
9.3 字典的嵌套
stu_score_dict = {
"liu": {
"语文": 90,
"数学": 99,
"英语": 66,
},
"jin": {
"语文": 80,
"数学": 89,
"英语": 76,
},
"tao": {
"语文": 95,
"数学": 99,
"英语": 76,
}
}
print(stu_score_dict) # {'周杰轮': {'语文': 90, '数学': 99, '英语': 66}, 'jin': {'语文': 80, '数学': 89, '英语': 76}, 'tao': {'语文': 95, '数学': 99, '英语': 76}}
print(stu_score_dict["tao"]["数学"]) # 99
print(stu_score_dict["liu"]["英语"]) # 66
9.4 字典的注意事项
键值对的 key 和 value 可以是任意类型（key不可为字典）
字典内 key 不允许重复，重复添加等同于覆盖原有数据
字典没有下标，用的是key来检索 value值
十、字典的操作
以下面字典操作为例：
my_dict = {"liu": 99, "jin": 88, "tao": 77}
10.1 新增元素
my_dict["yxy"] = 100
print(f"字典经过新增元素后结果为：{my_dict}") # 字典经过新增元素后结果为：{'liu': 99, 'jin': 88, 'tao': 77, 'yxy': 100}
10.2 更新元素
- 有则跟新，无则添加
my_dict["liu"] = 100
print(f"修改元素后的结果为：{my_dict}") # 修改元素后的结果为：{'liu': 100, 'jin': 88, 'tao': 77, 'yxy': 100}
10.3 删除字典元素（pop）
- 有新的返回值
score = my_dict.pop("yxy")
print(f"删除字典元素后的结果为：{my_dict}") # 删除字典元素后的结果为：{'liu': 100, 'jin': 88, 'tao': 77}
print(score) # 100
10.4 清空字典（clear）
my_dict.clear()
print(my_dict) # {}
2、获取全部的 key
- 注意有返回值哦！
- 可以使用遍历去操作字典的 key 和 value
语法：
字典.keys() # 得到所有的key
my_dicts = {
"liu": "yu",
"jin": "xin",
"tao": "yao"
}
keys = my_dicts.keys()
print(keys) # dict_keys(['liu', 'jin', 'tao'])
3、 遍历字典
重点是keys使我们通过keys方法获取到的一个key列表，然后，我们使用for循环依次遍历列表。这样i就是keys这个列表迭代器里面的每一个元素。
最后我们每次循环都对字典key进行访问器结果值。
# keys拿到的结果，我用for循环拿到key 然后 在获取到value
for i in keys:
print(my_dicts[i])
"""
运行结果：
yu
xin
yao
"""
方法2：
for key in my_dicts:
print(key) # 得到所有的 key
print(my_dicts[key]) # 得到所有的value值
- 效果是一样的。
注意：字典是不能使用while的，因为他不允许下标索引。
统计字典中元素的个数
- 使用len方法实现
number = len(my_dicts)
print(number) # 3
- 用变量计数器
count = 0
for key in my_dicts:
count += 1
print(f"字典中共有：", count)
"""
字典中共有： 1
字典中共有： 2
字典中共有： 3
"""
字典小结
- 可以容纳多个数据
- 可以容纳不同类型的数据
- 每一份数据是key value键值对
- 可以通过key获取到value，key不可重复（重复会覆盖掉）
- 不支持下标索引（因此不能使用while遍历）
- 可以修改（增删或更新）
- 只能for循环遍历
字典练习
"""
完成数据的存储
通过遍历，一级员工升级并+ 1000
"""
def main():
is_dict = {
"王力宏": {
"部门": "科技部",
"工资": 3000,
"级别": 1
},
"周杰轮": {
"部门": "市场部",
"工资": 5000,
"级别": 2
},
"林俊杰": {
"部门": "市场部",
"工资": 7000,
"级别": 3
},
"张学友": {
"部门": "科技部",
"工资": 4000,
"级别": 1
},
"刘德华": {
"部门": "市场部",
"工资": 6000,
"级别": 2
}
}
# 遍历判断等级
for key in is_dict.keys():
if is_dict[key]["级别"] == 1:
is_dict[key]["级别"] = 2
is_dict[key]["工资"] += 1000
print(is_dict[key])
main()
