# 数据容器入门
# 数据容器是什么？
# Python中的数据容器是一种可以容纳多份数据的数据类型
# 容器容纳的每一份数据称之为一个元素
# 每一个元素，可以是任意类型的数据，如字符串、数字、布尔等
"""
数据容器根据特点的不同，如：
· 是否支持重复元素
· 是否可以修改
· 是否有序 等，
分为5类，分别是：
列表（list），元组（tuple），字符串（str），集合（set），字典（dict）
"""
# ================================================================
# 列表 list
# 列表可以一次性存储多个数据,列表内的每一个数据称之为元素
"""
· 以[]作为标识
· 列表内的每一个元素之间用, 逗号隔开
基本语法：
# 字面量
[元素1, 元素2, 元素3, 元素4, ......]
# 定义变量
变量名称 = [元素1, 元素2, 元素3, 元素4, ......]
# 定义空列表
变量名称 = []
变量名称 = list()
"""
name_list_nor = ["itheima", "itcast", "python"]
print(name_list_nor)
print(type(name_list_nor))
my_list_nor = ["itheima", 666, True]
print(my_list_nor)
print(type(my_list_nor))
# 嵌套列表的定义
my_list_spi = [[1, 2, 3], [4, 5, 6]]
print(my_list_spi)
print(type(my_list_spi))
# 列表的下标索引
# 在列表中的多个元素是有顺序的，每一个元素都有其位置的下标索引，又前往后，从0开始
# 可以通过下标取得对应位置的元素
my_list_index = ["Tom", "Lily", "Rose"]
print(my_list_index[0])
print(my_list_index[1])
print(my_list_index[2])
# 列表也可以进行反向索引，此时下标从-1开始
print(my_list_index[-1])
print(my_list_index[-2])
print(my_list_index[-3])
# print(my_list_index[-4])# 取值超出范围时会报如下错误
# IndexError: list index out of range
# 嵌套列表的下标索引
# 由于嵌套列表中的元素也为列表，所以在取值时需要两层下标索引
my_list_spi_index = [[1, 2, 3], [4, 5, 6]]
print(my_list_spi_index[0][0])
print(my_list_spi_index[0][1])
print(my_list_spi_index[0][2])
print(my_list_spi_index[1][-1])
print(my_list_spi_index[1][-2])
print(my_list_spi_index[1][-3])
# 列表的常用操作
"""
列表提供了一系列功能：
插入元素
删除元素
清空列表
修改元素
统计元素个数 等等
这些功能我们都称之为：列表的方法
**在python中，如果将函数定义为class的成员，那么函数就会称之为：方法
**函数和方法除了定义的位置和使用方法不同，没有任何区别
"""
# 查找某元素的下标 列表.index(元素)
# 功能：查找指定元素在列表的下场，如果找不到，报错ValueError
list_to_method = ["itheima", "itcast", "python"]
index = list_to_method.index("itheima")
print(f"itheima在列表中的下标索引值为{index}")
# index = list_to_method.index("it")# 报错：ValueError: 'it' is not in list
# 修改特定位置的元素值 列表[下标] = 值
list_to_method[0] = 66666
print(f"list_to_method[0]修改后的值为：{list_to_method}")
# 列表插入元素 列表.insert(下标,元素)
# 在指定的下标位置，插入指定的元素
list_to_method.insert(1, True)
print(f"list_to_method插入后的值为：{list_to_method}")
# 列表追加元素 list.append(元素)
# 将指定元素追加到列表的尾部
list_to_method.append("追加单个元素")
print(f"list_to_method追加单个元素后的值为：{list_to_method}")
# 列表追加一批元素 列表.extend(其他数据容器)
# 将其他数据容器的内容取出，依次追加到列表尾部
list_to_append = [1, 2, 3, 4]
list_to_method.extend(list_to_append)
print(f"list_to_method批量追加元素后的值为：{list_to_method}")
# 删除指点下标索引的元素
# del 列表[下标]
del list_to_method[-1]
print(f"list_to_method用del删除元素后的值为：{list_to_method}")
# 列表.pop(下标)
# pop具有返回值，其返回值是下标所对应的数据
list_to_method.pop(-2)
print(f"list_to_method用pop(-2)删除元素后的值为：{list_to_method}")
pop = list_to_method.pop()
print(f"pop取出的数据为{pop}")
print(f"list_to_method用pop()删除元素后的值为：{list_to_method}")
# 删除某元素在列表中的第一个匹配项 列表.remove(元素)
list_to_method = [1, 3, 2, 3]
list_to_method.remove(3)
print(f"list_to_method用remove(3)删除元素后的值为：{list_to_method}")
# 统计某元素在列表内的数量
list_to_method = [1, 1, 1, 2, 2, 3, 4]
print(f"list_to_method中1的数量为{list_to_method.count(1)}")
print(f"list_to_method中2的数量为{list_to_method.count(2)}")
print(f"list_to_method中3的数量为{list_to_method.count(3)}")
# 统计列表中所有元素的数量 len(列表)
print(f"list_to_method的长度为{len(list_to_method)}")
# 清空列表内容 列表.clear()
list_to_method.clear()
print(f"list_to_method清空后的值为：{list_to_method}")
"""
列表的常用功能练习
现有列表内容为[21, 25, 21, 23, 22, 20]
请通过列表的功能对其进行
1.定义这个列表，并用变量接收它
2.追加一个数字31到列表的尾部
3.追加一个新列表[29,33,30]到列表的尾部
4.取出第一个元素(应是21)
5.取出最后一个元素(应是30)
6.查找元素31，在列表中的下标位置
"""
list_pri = [21, 25, 21, 23, 22, 20]
list_pri.append(31)
list_pri.extend([29, 33, 30])
print(list_pri[0])
print(list_pri[-1])
print(list_pri.index(31))
# 列表的循环遍历
# 将容器内的元素依次取出进行处理的行为，称之为：遍历、迭代
# while
def list_while_func():
"""
使用while遍历列表的演示函数
:return ： None
"""
my_list_while = ["itheima", "itcast", "python"]
# 循环控制变量通过下标索引来控制，默认为0、
# 每一次循环将下标索引变量+1
# 循环条件： 下标索引变量 < 列表的元素变量
# 定义一个变量用来标记列表的下标
index = 0 # 初始值为0
while index < len(my_list_while):
# 通过index变量取出对应下标的元素
element = my_list_while[index]
print(f"列表的元素：{element}")
# 至关重要，将循环变量(index)每一次循环都+1
index += 1
list_while_func()
# for
def list_for_func():
"""
使用for遍历列表的演示函数
:return ： None
"""
my_list_for = ["itheima", "itcast", "python"]
# for 临时变量 in 数据容器:
for element in my_list_for:
print(f"列表的元素：{element}")
list_for_func()
"""
while和for之间的细节对比：
· 在循环控制上：
while循环可以自定义循环条件、并自行控制
for循环不可以自定义循环条件、只可以一个个从容器内取出数据
· 在无限循环上：
while循环可以通过条件控制做到无限循环
for循环理论上不可以，因为被遍历的容器容量不是无限的
· 在使用场景上：
while循环适用于任何想要的循环场景
for循环适用于遍历数据容器的场景或简单的固定次数循环场景
"""
# 小练习 取偶数
list_todo = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def for_list():
for x in list_todo:
if((x % 2) != 0):
list_todo.remove(x)
print(list_todo)
for_list()
list_todo = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def while_list():
index = 0
while index < len(list_todo):
element = list_todo[index]
if((element % 2) != 0):
list_todo.remove(element)
index += 1
print(list_todo)
while_list()
# ================================================================
# 元组 tuple
# 元组同列表一样，都是可以封装多个、不同类型的元素在内
# 但是 元组一旦定义完成，就不可修改
"""
为什么使用元组？
因为列表是可以修改的，如果想要传递的信息不被篡改，列表就不合适了
所以当我们需要在程序内封装数据，又不希望封装的数据被篡改，那么元组就非常合适了
元组定义：
定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型
# 定义元组字面量
(元素, 元素, 元素, ......, 元素)
# 定义元组变量
变量名称 = (元素, 元素, 元素, ......, 元素)
# 定义空元组
变量名称 = () # 方式一
变量名称 = tuple() # 方式二
"""
# 定义元组
t1 = (1,"hello", True)
t2 = ()
t3 = tuple()
print(f"t1的类型是 {type(t1)} , t1的值为 {t1}")
print(f"t2的类型是 {type(t2)} , t2的值为 {t2}")
print(f"t3的类型是 {type(t3)} , t3的值为 {t3}")
# 定义一个元素的元组
# 注意，必须带有逗号，否则不是元组类型
t4 = ("hello")
print(f"t4的类型是 {type(t4)} , t4的值为 {t4}")
t4 = ("hello", )
print(f"t4的类型是 {type(t4)} , t4的值为 {t4}")
# 元组的嵌套
# 同列表一样，元组也支持嵌套
t5 = ( (1, 2, 3), (4, 5, 6) )
print(f"t5的类型是 {type(t5)} , t5的值为 {t5}")
# 下标索引取出元素
num = t5[1][2]
print(f"从嵌套元组中取出的数据是{num}")
# 元组的操作
t6 = ("itheima", "itcost", "python")
# index查找方法
index = t6.index("itcost")
print(f"在元组t6中查找\"itcost\"的下标是 {index}")
# count统计方法
t6 = ("itheima", "itcost", "itcost", "itcost", "itcost", "python")
count = t6.count("itcost")
print(f"在元组t6中统计\"itcost\"的个数是 {count}")
# len统计长度
lenth = len(t6)
print(f"元组t6的长度为 {lenth}")
# 元组的遍历
# while
print("while循环遍历元组")
index = 0
while index < len(t6):
print(f"t6元组的元素有： {t6[index]}")
# 至关重要
index += 1
# for
print("for循环遍历元组")
for element in t6:
print(f"t6元组的元素有： {element}")
# 修改元组内容
# t6[0] = "it"
# 报错 : TypeError: 'tuple' object does not support item assignment
# 但是如果元组里有列表的话可以修改元组里列表的值
t6 = (1, 2, ["itheima", "itcast"])
print(f"t6的内容是 {t6}")
t6[2][0] = "the"
t6[2][1] = "best"
print(f"修改后t6的内容是 {t6}")
"""
元组的特点：
· 可以容纳多个数据
· 可以容纳不同类型的数据
· 数据是有序存储的（可以使用下标索引）
· 允许重复数据存在
· 不可以修改（增加或删除元素等）
· 支持for和while循环
"""
# 小练习
# 定义一个元组，内容是("李明", 11, ["football", "music"])
# 删除爱好中的football，增加一个coding到爱好list内
t_test = ("李明", 11, ["football", "music"])
t_test[2].pop(0)
print(f"修改后t_test的内容是 {t_test}")
t_test[2].append("coding")
print(f"修改后t_test的内容是 {t_test}")
# ================================================================
# 字符串
# 字符串是字符的容器，一个字符串可以存放任意数量的字符
"""
字符串是一个无法修改的数据容器
所以：
· 修改指定下标的字符
· 移除特定下标的字符
· 追加字符 等等
均无法完成，若必要进行修改只会得到一个新字符串
"""
# 字符串的下标索引
my_str = "itheima and itcast"
print(f"my_str[0]的值为 {my_str[0]}")
print(f"my_str[-1]的值为 {my_str[-1]}")
# 字符串的常用操作
# index方法
index = my_str.index("and")
print(f" \"and \" 的起始下标为 {index}")
# replace方法 字符串.replace(字符串1, 字符串2)
# 将字符串内的全部字符串1替换为字符串2，此时是得到了一个新字符串
new_str = my_str.replace("it", "程序")
print(f"将字符串 {my_str}， 替换后得到： {new_str}")
# split方法 字符串.split(分隔符字符串)
# 按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中，字符串本身不变，而是得到一个新的列表对象
split_str = my_str.split(" ")
print(f"将字符串 {my_str}， 分隔后得到： {split_str}")
# strip方法 字符串.strip()
# 字符串的规整操作，去除前后指定字符串，若没有参数就是去除空格
my_str = " itheima and itcast "
print(f"将字符串 \"{my_str}\"， 去除后得到： \"{my_str.strip()}\"")
my_str = "1212221itheima and itcast21221211"
strip_str = my_str.strip("12")
print(f"将字符串 \"{my_str}\"， 去除后得到： \"{strip_str}\"")
# count
# 统计字符串中某字符串的出现次数
my_str = "itheima and itcast"
count = my_str.count("it")
print(f"字符串 {my_str} 中it出现的次数为 {count}")
# len
# 统计字符串的长度
num = len(my_str)
print(f"字符串 {my_str} 的长度为 {num}")
# 遍历
# while
index = 0
print("while循环遍历字符串")
while index < num:
print(f"字符串中含有：{my_str[index]}")
index += 1
# for
print("for循环遍历字符串")
for element in my_str:
print(f"字符串中含有：{element}")
"""
字符串的特点：
· 只可以存储字符串
· 长度任意（取决于内存大小）
· 支持下标索引
· 允许重复字符串存在
· 不可以修改（增加或删除元素等）
· 支持for循环
"""
# 小练习
# 给一个字符串"itheima itcast boxuegu"
# 统计字符串内有多少个 "it" 字符
# 将字符串内的空格，全部替换为字符 "|"
# 按照 "|" 进行分分割，得到列表
str_test = "itheima itcast boxuegu"
count = str_test.count("it")
print(f"字符串内的it有{count}个")
str_test_new = str_test.replace(" ", "|")
print(f"替换后的字符串为 {str_test_new}")
str_test_list = str_test_new.split("|")
print(f"分割后得到的列表为 {str_test_list}")
# ================================================================
# 序列
# 指：内容连续、有序、可使用下标索引的一类数据容器
# 列表、元组、字符串均可以视为序列
# 序列的常用操作 - 切片
# 切片：从一个序列中，取出一个子序列
# 语法：序列[起始下标:结束下标:步长]
# 表示从序列中，从指定位置开始，依次取出元素、到指定位置结束，得到一个新序列
"""
· 起始下标表示从何处开始，可以留空，留空视作从头开始
· 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
· 步长表示，一次取元素间隔
· 步长1表示，一个个取元素
· 步长2表示，每次跳过一个元素取
· 步长N表示，每次跳过N-1个元素取
· 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）
此操作不会影响序列本身，而是会产生一个新序列，因为元组和字符串不可修改
"""
# 对list进行切片，从1开始，4结束，步长1
my_list = [0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1:4] # 步长默认是1， 所以可以省略不写
print(f"结果1: {result1}")
# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result2 = my_tuple[:] # 起始和结束不写表示从头到尾，步长为1可以省略
print(f"结果2: {result2}")
# 对str进行切片，从头开始，到最后结束，步长2
my_str = "01234567"
result3 = my_str[::2]
print(f"结果3: {result3}")
# 对str进行切片，从头开始，到最后结束，步长-1
my_str = "01234567"
result4 = my_str[::-1] # 等同于将序列反转了
print(f"结果4: {result4}")
# 对列表进行切片，从3开始，到1结束，步长-1
my_list = [0, 1, 2, 3, 4, 5, 6]
result5 = my_list[3:1:-1]
print(f"结果5: {result5}")
# 对元组进行切片，从头开始，到尾结束，步长-2
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result6 = my_tuple[::-2]
print(f"结果2: {result6}")
# 联系，在"万过薪月，员序程马黑来，nohtyP学"这个字符串中取出"黑马程序员"
str_test = "万过薪月，员序程马黑来，nohtyP学"
numHei = str_test.index("黑")
numYuan = str_test.index("员")
if(numHei > numYuan):
str_result = str_test[numHei:numYuan-1:-1]
else:
str_result = str_test[numHei:numYuan+1:1]
#因为切片得到的结果也是序列，所以可以直接操作
str_result = str_test[::-1][9:14]
print(str_result)
# ================================================================
# 集合 set
# 集合的主要特点是：不支持重复元素且元素无序
"""
# 定义集合字面量
{元素,元素 ,元素 , ......, 元素}
# 定义集合变量
变量名称 = {元素, 元素, 元素, ......, 元素}
# 定义空集合
变量名称 = set()
"""
# 定义集合
my_set = {"传智教育", "黑马程序员", "itheima","传智教育", "黑马程序员", "itheima", "传智教育", "黑马程序员", "itheima"}
my_set_empty = set() # 定义空集合
print(f"my_set的内容是 {my_set}， 类型是 {type(my_set)}")
# 集合是无序的，所以不支持下标索引访问，但是集合与列表一样允许修改
# 集合的常用操作
# 添加新元素 集合.add(元素)
# 集合本身被修改，添加了新元素
my_set.add("python")
print(f"my_set添加元素后的结果是： {my_set}")
my_set.add("itheima")
print(f"my_set添加重复元素后的结果是： {my_set}")
# 移除元素 集合.remove(元素)
# 集合本身被修改，移除了元素
my_set.remove("python")
print(f"my_set移除元素后的结果是： {my_set}")
# 随机取出一个元素 集合.pop()
# 会得到一个元素的结果，同时集合本身被修改，元素被移除
element = my_set.pop()
print(f"my_set移除的元素是 {element} , my_set变成： {my_set}")
# 清空集合 集合.clear()
# 集合本身被清空
my_set.clear()
print(f"my_set清空后的结果是： {my_set}")
# 取2个集合的差集 集合1.difference(集合2)
# 取出集合1和集合2的差集（集合1有集合2没有的）
# 得到一个新集合，集合1和集合2不变
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(set3 , set1 , set2)
# 消除2个集合的差集 集合1.difference_update(集合2)
# 对比集合1和集合2，在集合1内，删除和集合2相同的元素
# 集合1被修改，集合2不变
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(set1 , set2)
# 2个集合合并为一个 集合1.union(集合2)
# 将集合1和集合2组合成新集合
# 得到新集合，集合1和集合2不变
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(set3 , set1 , set2)
# 统计集合元素数量
set1 = {1, 2, 3, 1, 5, 6, 4}
print(len(set1))
# 集合的遍历
# 集合不支持下标索引，不能用while循环， 可以用for循环
print("for循环遍历集合")
for element in set1:
print(f"集合的元素有：{element}")
"""
集合的特点：
· 可以容纳多个数据
· 可以容纳不同类型的数据（混装）
· 数据是无序存储的（不支持下标索引）
· 不允许重复数据存在
· 可以修改（增加或删除元素）
· 支持for循环
"""
# 集合小练习
# 有列表对象为["黑马程序员", "传智播客", "黑马程序员", "传智播客", "itheima", "itcast", "itheima", "itcast", "best"]
# 定义一个空集合
# 通过for循环遍历列表
# 在for循环中将列表的元素添加至集合
# 最终得到元素去重后的集合对象，并打印输出
my_list = ["黑马程序员", "传智播客", "黑马程序员", "传智播客", "itheima", "itcast", "itheima", "itcast", "best"]
set_test = set()
for element in my_list:
set_test.add(element)
print(f"最后得到的集合为: {set_test}")
# ================================================================
# 字典、映射 dict
"""
为什么使用字典：
字典可以实现用key取出value的操作
字典的定义：
同样使用{}，不过存储的元素是一个个 键值对，
# 定义字典字面量
{key: value, key: value, ......, key: value}
# 定义字典变量
my_dict = {key: value, key: value, ......, key: value}
# 定义空字典
my_dict = {}
my_dict = dict()
"""
# 定义字典
my_dict1 = {"王立红": 99, "周婕纶": 88, "林俊节": 77}
# 定义空字典
my_dict2 = {}
my_dict3 = dict()
print(f"字典1的内容是: {my_dict1}, 类型是{type(my_dict1)}")
print(f"字典2的内容是: {my_dict2}, 类型是{type(my_dict2)}")
print(f"字典3的内容是: {my_dict3}, 类型是{type(my_dict3)}")
# 定义重复key的字典
# 字典中的key不允许重复，新值会将旧值覆盖掉
my_dict1 = {"王立红": 99, "王立红": 88, "林俊节": 77}
print(f"字典1的内容是: {my_dict1}, 类型是{type(my_dict1)}")
# 从字典中基于key获取value
# 字典可以通过key值取得对应的value
my_dict1 = {"王立红": 99, "周婕纶": 88, "林俊节": 77}
score = my_dict1["王立红"]
print(f"my_dict1[\"王立红\"]的值为： {score}")
# 字典的嵌套
# 字典的key和value可以是任意数据类型（key不可为字典）
stu_score_dict = {
"王立红": {
"语文": 77,
"数学": 66,
"英语": 33
}, "周婕纶": {
"语文": 88,
"数学": 86,
"英语": 55
}, "林俊节": {
"语文": 99,
"数学": 96,
"英语": 66
}
}
print(f"学生的考试信息是 {stu_score_dict}")
# 从嵌套字典中获取数据
score = stu_score_dict["周婕纶"]["语文"]
print(f"stu_score_dict[\"周婕纶\"][\"语文\"]的值为：{score}")
score = stu_score_dict["林俊节"]["英语"]
print(f"stu_score_dict[\"林俊节\"][\"英语\"]的值为：{score}")
# 字典的常用操作
# 新增元素
# 语法：字典[key] = value
# 结果：字典被修改，新增了元素
# 更新元素
# 语法：字典[key] = value
# 结果：字典被修改，元素被更新
# 因为key不可以重复，所以对已存在的key执行赋值就是更新了其对应的value
stu_score_dict = {
"王立红": 33,
"周婕纶": 55,
"林俊节": 66
}
stu_score_dict["张雪有"] = 77
print(f"stu_score_dict为：{stu_score_dict}")
stu_score_dict["王立红"] = 77
print(f"stu_score_dict为：{stu_score_dict}")
# 删除元素
# 语法: 字典.pop()
# 结果: 获得指定key的value，同时字典被修改，指定key的数据被删除
score = stu_score_dict.pop("周婕纶")
print(f"取出的值为: {score}, 此时字典为: {stu_score_dict}")
# 获取全部key
# 语法: 字典.keys()
# 结果: 得到字典中全部的key
keys = stu_score_dict.keys()
print(f"字典的全部key为: {keys}, keys的数据类型为: {type(keys)}")
# 遍历字典
# 字典不支持下标索引，所以不能用while循环
# for
for key in keys:
print(f"字典的key为: {key}")
print(f"字典的value为: {stu_score_dict[key]}\n")
# 直接对字典进行for循环
for key in stu_score_dict:
print(f"字典取出的key为: {key}")
print(f"字典对应的value为: {stu_score_dict[key]}\n")
# 统计字典的元素数量
# len()函数
num = len(stu_score_dict)
print(f"字典的长度是: {num}")
# 清空元素
stu_score_dict.clear()
print(f"字典被清空后为: {stu_score_dict}")
"""
字典的特点如下：
· 可以容纳多个数据
· 可以容纳不同类型的数据
· 每一份数据都是key-value键值对
· 可以通过key获取到value，可以不可重复（重复会覆盖）
· 不支持下标索引
· 可以修改（增加或删除更新元素等）
· 支持for循环，不支持while循环
"""
# 小练习
"""
有如下员工信息，请使用字典完成数据的记录
姓名 部门 工资 级别
王立红 科技部 3000 1
周婕纶 市场部 5000 2
林俊节 市场部 7000 3
张雪有 科技部 4000 1
刘德桦 市场部 6000 2
并通过for循环，对所有级别为1级的员工，级别上升一级，薪水增加1000元
"""
dicr_test = {
"王立红": {
"部门": "科技部",
"工资": "3000",
"级别": "1",
},
"周婕纶": {
"部门": "市场部",
"工资": "5000",
"级别": "2",
},
"林俊节": {
"部门": "市场部",
"工资": "7000",
"级别": "3",
},
"张雪有": {
"部门": "科技部",
"工资": "4000",
"级别": "1",
},
"刘德桦": {
"部门": "市场部",
"工资": "6000",
"级别": "2",
}
}
print(dicr_test)
for key in dicr_test:
grade = int(dicr_test[key]["级别"])
if(1 == grade):
dicr_test[key]["级别"] = str(grade + 1)
GZ = int(dicr_test[key]["工资"])
dicr_test[key]["工资"] = str(GZ + 1000)
print(dicr_test)
# ================================================================
# 数据容器的通用统计功能
# len(容器) 统计容器的元素个数
# max(容器) 统计容器的最大元素
# min(容器) 统计容器的最小元素
# 容器的通用转换功能，将给定容器转换为指定容器
# list() str() tuple() set()
# 通用排序功能
# sorted(容器,[reverse=True]) 后面这个参数用于是否从大到小排序
# ================================================================
# 字符串比较大小
# 字符串是按位比较，也就是一位位进行对比，只要有一位大，那么整体就大
print(f"ab > a : {'ab' > 'a'}")
print(f"ab > b : {'ab' > 'b'}")
# 此时就会发现之比较了第一位字符
03-06
6132
01-23
03-21
12-03
06-01
“相关推荐”对你有帮助么？
-
非常没帮助 -
没帮助 -
一般 -
有帮助 -
非常有帮助
提交
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
