数据来源

01数据容器

为什么学习数据容器

数据容器

总结

02 列表

1）列表定义

为什么需要列表

列表的定义语法

列表的定义方式

演示

"""演示数据容器之:list列表语法:[元素,元素,......]"""# 定义一个列表listmy_list = ["张三",18,"法外狂徒"]print(my_list)print(type(my_list))# 定义一个嵌套的列表my_list2 = [["张三",18,"法外狂徒"],["刘海柱",19,"职业法师"]]print(my_list2)print(type(my_list2))

总结

2）列表的下标（索引）

演示

# 通过下标索引取出对应位置的数据my_list = ["张三",18,"法外狂徒"]print(f"我是my_list列表的第1个数据：{my_list[0]}")print(f"我是my_list列表的第2个数据：{my_list[1]}")print(f"我是my_list列表的第3个数据：{my_list[2]}")

列表的下标（索引）- 反向

演示

# 通过下标索引取出数据(倒序取出)my_list = ["张三",18,"法外狂徒"]print(f"我是my_list列表的倒数第1个数据：{my_list[-1]}")print(f"我是my_list列表的倒数第2个数据：{my_list[-2]}")print(f"我是my_list列表的倒数第3个数据：{my_list[-3]}")

嵌套列表的下标（索引）

演示

# 取出嵌套列表的元素my_list = [["张三",18,"法外狂徒"],["刘海柱",19,"职业法师"]]print(f"我是my_list列表的第1个数据的第1个数据：{my_list[0][0]}")print(f"我是my_list列表的第2个数据的第2个数据：{my_list[1][1]}")

总结

3）列表的常用操作

列表的常用操作（方法）

列表的查询功能（方法）

演示

"""演示示数据容器之:list列表的常用操作"""my_list = [1,2,3,4,5,6,7]# 1.1 查找某元素在列表内的下标(索引)print(my_list.index(7))# 1.2 如果被查找的元素不存在会报错print(my_list.index(8))

列表的修改功能（方法）

演示

# 2.1 修改特定下际索引的值（正向下标）my_list = [1,2,3]my_list[0] =9print(f"正向下标:{my_list}")# 2.2 修改特定下际索引的值（反向下标）my_list[-1] =666print(f"反向下标:{my_list}")

插入元素

演示

# 3. 在指定下际位置插入新元素my_list = [1,2,3]# 语法：insert(指定位置,要插入的元素)my_list.insert(1,"张三")print(my_list)

追加元素

演示

# 4. 在列表的尾部追加单个新元素# 语法：append(要追加的元素)my_list = [1,2,3]my_list.append("李四")print(my_list)my_list.append([22,34]) # 也可以追加一个列表print(my_list)

追加元素方式2：（追加一批元素）

演示

# 5. 在列表的尾部追加一批新元素my_list = [1,2,3]my_list.extend([4,5,6,7])print(my_list)# 或arr = ["你好","李银河",18]my_list.extend(arr)print(my_list)

删除元素

演示

# 6. 别除指定下际索引的元素(2种方式)my_list = [1,2,3,4,"张",6,7,"三",9]# 6.1 方式1:del列表[下标]# 语法: del 列表[索引]del my_list[4]print(my_list)# 6.2方式2:列表,pop(下标)# 语法: 列表.pop(索引)element = my_list.pop(6) # 我这里要删除列表中的"三"字，因为上面已经删除了一个元素"三"字的下标已经由7变成6，所以这里索引写6print(my_list)print(f"被删除的元素是：{element}")# 两种方式的最大区别：del只能删除指定的元素，pop删除指定的元素并返回被删除的元素

删除某元素在列表中的第一个匹配项

演示

# 7. 除某元素在列表中的第一个匹配项my_list = [1,2,3,4,2,57,2]my_list.remove(2)print(my_list)

清空列表内容

演示

# 8. 清空列表的内容my_list = [1,2,3,4,2,57,2]my_list.clear()print(my_list)

统计列表内容某元素的数量

演示

# 9. 统计列表内容某元素的数量my_list = [1,2,3,4,2,57,2]print(my_list.count(2))

统计列表中全部元素数量

演示

# 10. 统计列表中全部元素数量my_list = [1,2,3,4,2,57,2]print(len(my_list))

列表的方法-总览

使用方式的完整代码演示

"""演示示数据容器之:list列表的常用操作"""# my_list = [1,2,3,4,5,6,7]# # 1.1 查找某元素在列表内的下标(索引)# print(my_list.index(7))## # 1.2 如果被查找的元素不存在会报错# print(my_list.index(8))# 2.1 修改特定下际索引的值（正向下标）# my_list = [1,2,3]# my_list[0] =9# print(f"正向下标:{my_list}")## # 2.2 修改特定下际索引的值（反向下标）# my_list[-1] =666# print(f"反向下标:{my_list}")# 3. 在指定下际位置插入新元素# my_list = [1,2,3]# # 语法：insert(指定位置,要插入的元素)# my_list.insert(1,"张三")# print(my_list)# 4. 在列表的尾部追加单个新元素# 语法：append(要追加的元素)# my_list = [1,2,3]# my_list.append("李四")# print(my_list)## my_list.append([22,34]) # 也可以追加一个列表# print(my_list)# 5. 在列表的尾部追加一批新元素# my_list = [1,2,3]# my_list.extend([4,5,6,7])# print(my_list)# # 或# arr = ["你好","李银河",18]# my_list.extend(arr)# print(my_list)# 6. 别除指定下际索引的元素(2种方式)# my_list = [1,2,3,4,"张",6,7,"三",9]# # 6.1 方式1:del列表[下标]# # 语法: del 列表[索引]# del my_list[4]# print(my_list)# 6.2方式2:列表,pop(下标)# 语法: 列表.pop(索引)# element = my_list.pop(6) # 我这里要删除列表中的"三"字，因为上面已经删除了一个元素"三"字的下标已经由7变成6，所以这里索引写6# print(my_list)# print(f"被删除的元素是：{element}")# 两种方式的最大区别：del只能删除指定的元素，pop删除指定的元素并返回被删除的元素# 7. 除某元素在列表中的第一个匹配项# my_list = [1,2,3,4,2,57,2]# my_list.remove(2)# print(my_list)# 8. 清空列表的内容# my_list = [1,2,3,4,2,57,2]# my_list.clear()# print(my_list)# 9. 统计列表内容某元素的数量# my_list = [1,2,3,4,2,57,2]# print(my_list.count(2))# 10. 统计列表中全部元素数量my_list = [1,2,3,4,2,57,2]print(len(my_list))

列表的方法-说明

列表的特点

总结

练习

演示

# 1. 定义变量my_list = [21,25,21,23,22,20]# 2. 追加数字31，到列表尾部my_list.append(31)print("追加数字31，到列表尾部:",my_list)# 3.追加一个新的列表[29,33,30]my_list.extend([29,33,30])print("追加一个新的列表[29,33,30]:",my_list)# 4. 取出第一个元素（21）print("取出第一个元素:",my_list[0])# 5. 取出最后一个元素（30）print("取出最后一个元素:",my_list[-1])# 6. 查找元素31，在列表中的下标位置print("查找元素31，在列表中的下标位置是:",my_list.index(31))

4）列表的遍历

列表的遍历- while循环

列表的遍历 - for循环

演示

"""演示对lint列表的循环，使用while和for循环两种方式"""def list_while_func():"""使用while循环遍历列表的演示函数:return:None"""index = 0 # 控制循环的变量my_list = ["法外", "狂徒", "李四"]while index < len(my_list):print(my_list[index],end="") # end="" 是让print输出的字符不换行index += 1list_while_func() # 调用函数def list_for_func():"""使用for循环遍历列表的演示函数:return:None"""print("") # print 输出空相当于输出换行my_list = ["法外", "狂徒", "王五"]for item in my_list:print(item,end="")list_for_func() # 调用函数

While循环和for循环的对比

总结

03tuple元组

为什么需要元组

定义元组

演示

"""演示 tuple 元组的定义和操作"""# 定义元组(1,"Hello",True) # 字面量定义t1 = (1,"Hello",True) # 用变量接收t2 = ()# 定义空的元组t3 = tuple() # 定义空的元组对象print(f"t1的类型是:{type(t1)},内容是：{t1}")print(f"t2的类型是:{type(t2)},内容是：{t2}")print(f"t3的类型是:{type(t3)},内容是：{t3}")# 定义单个元素的元组t4 = ("张三",)# 当元组的内容只有一个元素是后面要加逗号，不然就不是元组类型了t5 = ("张三") # 不加逗号的情况print("------注意事项------")print(f"t4的类型是:{type(t4)},内容是：{t4}")print(f"t5的类型是:{type(t5)},内容是：{t5}") # 没有逗号就变成字符串类型了# 元组的嵌套t6 =((1,2,3),(4,5,6))print(f"t6的类型是:{type(t6)},内容是：{t6}")# 下标索引取出元组的内容print("-----------------下标索引取出元组的内容-----------------")print(f"t1的第2个元素是：{t1[1]}") # Helloprint(f"t6的第1个元素内的第2个元素是：{t6[0][1]}")

元组的相关操作

演示

# 元组的操作: index 查找指定元素的第一个索引t7 =(1,3,2,5,2,3,5,3,2,4)print(f"在t7中数字3的索引是:{t7.index(3)}")# 元组的操作: count 统计某个元素出现的次数print(f"在t7中数字5的出现次数是:{t7.count(5)}")# 元组的操作:len函数统计元组元素数量print(f"在t7元组的元素长度（数量）是:{len(t7)}")

遍历元组

# 元组的遍历: whilet8 =(9,3,5,0,2,3,5)index =0while index < len(t8):print(t8[index])index += 1# 元组的遍历:fort9 = ("你好","啊","李银河")for x in t9:print(x)

元组操作完整代码

"""演示 tuple 元组的定义和操作"""# 定义元组(1,"Hello",True) # 字面量定义t1 = (1,"Hello",True) # 用变量接收t2 = ()# 定义空的元组t3 = tuple() # 定义空的元组对象print(f"t1的类型是:{type(t1)},内容是：{t1}")print(f"t2的类型是:{type(t2)},内容是：{t2}")print(f"t3的类型是:{type(t3)},内容是：{t3}")# 定义单个元素的元组t4 = ("张三",)# 当元组的内容只有一个元素是后面要加逗号，不然就不是元组类型了t5 = ("张三") # 不加逗号的情况print("------注意事项------")print(f"t4的类型是:{type(t4)},内容是：{t4}")print(f"t5的类型是:{type(t5)},内容是：{t5}") # 没有逗号就变成字符串类型了# 元组的嵌套t6 =((1,2,3),(4,5,6))print(f"t6的类型是:{type(t6)},内容是：{t6}")# 下标索引取出元组的内容print("-----------------下标索引取出元组的内容-----------------")print(f"t1的第2个元素是：{t1[1]}") # Helloprint(f"t6的第1个元素内的第2个元素是：{t6[0][1]}")print("------------元组的操作------------")# 元组的操作: index 查找指定元素的第一个索引t7 =(1,3,2,5,2,3,5,3,2,4)print(f"在t7中数字3的索引是:{t7.index(3)}")# 元组的操作: count 统计某个元素出现的次数print(f"在t7中数字5的出现次数是:{t7.count(5)}")# 元组的操作:len函数统计元组元素数量print(f"在t7元组的元素长度（数量）是:{len(t7)}")print("-----------元组的遍历-----------")# 元组的遍历: whilet8 =(9,3,5,0,2,3,5)index =0while index < len(t8):print(t8[index])index += 1# 元组的遍历:fort9 = ("你好","啊","李银河")for x in t9:print(x)

元组的相关操作 - 注意事项

演示

# 修改元组 （错误示范）# t1 =(1,2,3,4,5,6)# t1[0] = 10 # 元组不可修改，会报错# 可以修改元组内的list的内容t1 =(1,2,[3,4,5],6,8)t1[2][0] = "Hello"print(t1)

元组的特点

总结

04str字符串

再识字符串

字符串的下标（索引）

演示

"""演示以数据容器的角色,学习字符申的相关操作"""# 通过下标索取值my_str ="你好，李银河"print(f"取my_str的第一个字符：{my_str[0]}")print(f"取my_str的最后一个字符：{my_str[-1]}")# 通过索引修改字符串 （错误示例，字符串不可以直接修改）my_str[-3] = "张"

字符串的常用操作

index()查看特定字符的索引

演示

# index寻找指定元素的第一个索引方法my_str ="你好，李银河"print("好字的索引是：",my_str.index("好"))

replace() 字符串的替换

演示

# replace 方法my_str2 =my_str.replace("李银","张二")print(f"my_str={my_str},my_str2={my_str2}")# 注意：replace 方法是得到一个新的字符串不是修改原来的字符串

split() 字符串的分割

演示

# split 方法# 语法：split("分割符") 分割符就是以什么来分割如：空格、逗号之类的my_str ="你*好*李*银*河"my_str3 =my_str.split("*")print(f"my_str3={my_str3}，my_str3的类型是：{type(my_str3)}")# 注意分割之后，字符串本身不变而是得到一个新的列表对象

strip() 字符串的规整操作（去前后空格）

演示

# strip 方法my_str =" 你好,李银河 222"print(my_str)print(f"清除空格前：{my_str}")# 使用strip方法清除两边空格print(f"清除空格后：{my_str.strip()}") # strip() 不传参就是去除首尾空格print(f"原来的my_str：{my_str}")# 注意：strip()方法也不会修改原来的字符串# 使用strip方法清除指定字符串print(f"清除指定的字符串222：{my_str.strip('222')}") # strip() 传参就是去除传入的字符

count() 统计字符中某字符的出现次数与 len() 统计字符申的长度

# 统计字符中某字符的出现次数 count()my_str =" 222 你好,李银河 222"print(f"2出现的次数是：{my_str.count('2')}")# 统计字符申的长度 len()print(f"my_str的长度是：{len(my_str)}")

字符串常用操作汇总

字符串的遍历

字符串的特点

总结

练习

str = "itheima itcast boxuequ"# 统计字符串中有多少个“it” 使用count() 方法print("字符串的it数量是：",str.count("it"))# 将字符串内的空格，全部替换为字符“I”str1 =str.replace(" ","I")print(f"str1={str1}")# 并且按照”I“进行字符分割，得到列表str_list =str1.split("I")print(f"str_list={str_list}")

05数据容器（序列）切片

序列

序列的常用操作-切片

注意：此操作不会影响序列本身，而是会的得到一个新的序列（因为字符串、元组都是不支持修改的）

"""演示对序列进行切片操作 语法：序列[起始下标：结束下标：步长] 不包括结束下标"""# 对几list进行切片,从1开始,4结束,步长1my_list = [1,2,3,4,5,6]new_my_list = my_list[1:4:1] # [2, 3, 4]print(f"切片后的my_list：{new_my_list}")# 对 tuple 进行切片,从头开始,到最后结束,步长1my_tuple =(1,2,3,4,5,6,7,8)new_my_tuple = my_tuple[::1] # 不写就是从0开始到最后print(f"切片后的my_tuple：{new_my_tuple}") # (1, 2, 3, 4, 5, 6, 7, 8)# 对 str 进行切片,从头开始,到最后结束,步长2my_str ="你好，李银河123"new_my_str =my_str[::2]print(f"切片后的my_str：{new_my_str}") # 你，银13# 对 str 进行切片,从头开始,到最后结束,步长-1my_str ="你好，李银河123"new_my_str =my_str[::-1] # 就是把字符串倒过来print(f"切片后的my_str：{new_my_str}") # 321河银李，好你# 对列表进行切片,从3开始,到结束,步长-1my_list = [1,2,3,4,5,6] # 就是从索引3开始把数据倒过来new_my_list = my_list[3::-1] # [4, 3, 2, 1]print(f"切片后的my_list：{new_my_list}")# 对元组进行切片,从头开始,到尾结束,步长2my_tuple =(1,2,3,4,5,6,7,8)new_my_tuple = my_tuple[::2] # 不写就是从0开始到最后print(f"切片后的my_tuple：{new_my_tuple}") # (1, 3, 5, 7)

总结

06set集合

为什么使用集合

集合的定义

演示

"""演示数据容器集合的使用"""# 定义集合my_set ={"你好，李银河","年龄：18","职业：小黑子","你好，李银河","年龄：18","职业：小黑子","你好，李银河","年龄：18","职业：小黑子"}my_set_empty =set() # 定义空集合print(f"my_set={my_set}，类型是：{type(my_set)}") # 集合不会存储重复的数据，自动去重print(f"my_set_empty={my_set_empty}，类型是：{type(my_set_empty)}")

集合的常用操作 - 修改

添加与删除元素

演示

"""演示数据容器集合的使用"""# 添加新元素 add()my_set ={"你好，李银河","年龄：18","职业：小黑子"}my_set.add("Hello")print(f"my_set:{my_set}")# 移除元素 remove()my_set.remove("Hello")print(f"my_set:{my_set}")

从集合中随机取出元素与清空集合

演示

# 随机取出一个元素 pop() my_set = {"你好，李银河","年龄：18","职业：小黑子"}element = my_set.pop() # 注意：被随机取出的元素会在集合中被移除print(f"随机取出的数据是:{element}")print(f"原来的集合:{my_set}")# 清空集合 clear()my_set = {"你好，李银河","年龄：18","职业：小黑子"}my_set.clear()print(f"清空集合:{my_set}")

取出两个集合的差集

演示

# 取(2个集合的差集)set1 = {1,2,3}set2 = {1,5,6}set3 = set1.difference(set2)print(set3) # {2, 3} 得到一个新的集合print(set1) # {1, 2, 3} 不变print(set2) # {1, 5, 6} 不变

消除2个集合的差集

# 消除2个集合的差集set1 = {1,2,3}set2 = {1,5,6}set1 = set1.difference(set2) # 和取差集一样，区别就是取出的差集重新赋值给set1从而改变了set1print(set1) # {2, 3} set1被改变print(set2) # {1, 5, 6} 不变

两个集合的合并

演示

# 2个集合合并为1个set1 = {1,2,3}set2 = {1,5,6}set3 = set1.union(set2)print(set3) # {1, 2, 3, 5, 6} 得到一个新的集合print(set1) # {1, 2, 3} 不变print(set2) # {1, 5, 6} 不变

统计集合的元素与集合的遍历

# 统计集合元素数量set3 = {1,2,3,5,6}str4 = len(set3)print(f"统计集合元素数量:{str4}")# for 遍历集合（while 无法遍历集合，因为集合没有下标索引）set3 = {1,2,3,5,6}for x in set3:print(f"x={x}")

完整代码

"""演示数据容器集合的使用"""# 定义集合my_set ={"你好，李银河","年龄：18","职业：小黑子","你好，李银河","年龄：18","职业：小黑子","你好，李银河","年龄：18","职业：小黑子"}my_set_empty =set() # 定义空集合print(f"my_set={my_set}，类型是：{type(my_set)}") # 集合不会存储重复的数据，自动去重print(f"my_set_empty={my_set_empty}，类型是：{type(my_set_empty)}")# 添加新元素 add()my_set ={"你好，李银河","年龄：18","职业：小黑子"}my_set.add("Hello")print(f"my_set:{my_set}")# 移除元素 remove()my_set.remove("Hello")print(f"my_set:{my_set}")# 随机取出一个元素 pop()my_set = {"你好，李银河","年龄：18","职业：小黑子"}element = my_set.pop() # 注意：被随机取出的元素会在集合中被移除print(f"随机取出的数据是:{element}")print(f"原来的集合:{my_set}")# 清空集合 clear()my_set = {"你好，李银河","年龄：18","职业：小黑子"}my_set.clear()print(f"清空集合:{my_set}")# 取(2个集合的差集)set1 = {1,2,3}set2 = {1,5,6}set3 = set1.difference(set2)print(set3) # {2, 3} 得到一个新的集合print(set1) # {1, 2, 3} 不变print(set2) # {1, 5, 6} 不变# 消除2个集合的差集set1 = {1,2,3}set2 = {1,5,6}set1 = set1.difference(set2) # 和取差集一样，区别就是取出的差集重新赋值给set1从而改变了set1print(set1) # {2, 3} set1被改变print(set2) # {1, 5, 6} 不变# 2个集合合并为1个set1 = {1,2,3}set2 = {1,5,6}set3 = set1.union(set2)print(set3) # {1, 2, 3, 5, 6} 得到一个新的集合print(set1) # {1, 2, 3} 不变print(set2) # {1, 5, 6} 不变# 统计集合元素数量set3 = {1,2,3,5,6}str4 = len(set3)print(f"统计集合元素数量:{str4}")# for 遍历集合（while 无法遍历集合，因为集合没有下标索引）set3 = {1,2,3,5,6}for x in set3:print(f"x={x}")

集合常用功能总结

集合的特点

总结

07dict 字典

为什么使用字典

字典定义

"""演示数据容器字典的定义"""# 定义字典my_dict1 = {"张三":99,"李四":60,"王五":80}# 定义空字典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的字典my_dict = {"张三":99,"张三":88,"李四":60,"王五":80}print(f"重复Key的字典是：{my_dict}") # {'张三': 88, '李四': 60, '王五': 80}# 结论key重复是只保留后面的key与value

字典数据的获取

演示

# 从字典中基于Key获取Valuemy_dict1 = {"张三":99,"李四":60,"王五":80}print(my_dict1["张三"]) # 99print(my_dict1["李四"]) # 60print(my_dict1["王五"]) # 80

字典的嵌套

演示

# 定义嵌套字典my_dict1 = {"张三":{"语文":99,"数学":88,"英语":66},"李四": {"语文": 95,"数学": 78,"英语": 76},"王五": {"语文": 89,"数学": 38,"英语": 96}}# 从嵌套字典中获取数据# 看看张三的数学成绩print(f'张三的数学成绩:{my_dict1["张三"]["数学"]}')print(f'王五的英语成绩:{my_dict1["王五"]["英语"]}')

总结

字典的常用操作

新增、更新、删除、清空元素

演示

"""演示字典的常用操作"""# 新增元素my_dict1 = {"张三":99,"李四":60,"王五":80}my_dict1["陈六"] = 67print(f"新增元素={my_dict1}")# 更新元素my_dict1["王五"] = 100print(f"更新元素={my_dict1}")# 删除元素 pop()score = my_dict1.pop("李四") # pop删除指定的元素也会返回被删除的元素print(f"删除元素={my_dict1},李四的考试分数是：{score}")# 清空元素my_dict1.clear()print(f"清空元素={my_dict1}")

获取全部的key 、遍历字典、统计字典的元素

演示

# 获取全部的keymy_dict1 = {"张三":99,"李四":60,"王五":80}my_dict_keys =my_dict1.keys()print(f"获取全部的key:{my_dict_keys}")# 遍历字典for K in my_dict1:# k 键key my_dict1[K] 值valueprint(f"遍历字典:{K}:{my_dict1[K]}")# 统计字典内的元素数量print(f"统计字典内的元素数量：{len(my_dict1)}")

字典的常用操作总结

字典的特点

总结

08 5类数据容器的总结对比

数据容器分类

数据容器特点对比

总结

09数据容器的通用操作

数据容器的通用操作-遍历

数据容器的通用统计功能

容器通用转换功能

演示

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}# 类型转换：容器转列表print("-------------容器转列表-------------")print(f"类型转换：集合转列表:{list(my_set)},类型：{type(list(my_set))}")print(f"类型转换：字典转列表:{list(my_dict)},类型：{type(list(my_dict))}")# 类型转换：容器转元组print("-------------容器转元组-------------")print(f"类型转换：集合转元组:{tuple(my_set)},类型：{type(tuple(my_set))}")print(f"类型转换：字典转元组:{tuple(my_dict)},类型：{type(tuple(my_dict))}")# 类型转换：容器转字符串print("-------------容器转字符串------------")print(f"类型转换：集合转字符串:{str(my_set)},类型：{type(str(my_set))}")print(f"类型转换：字典转字符串:{str(my_dict)},类型：{type(str(my_dict))}")# 类型转换：容器转字集合print("-------------容器转集合------------")print(f"类型转换：元组转集合:{set(my_tuple)},类型：{type(set(my_tuple))}")print(f"类型转换：字典转集合:{set(my_dict)},类型：{type(set(my_dict))}")

容器通用排序功能

演示

# sorted() 容器通用排序功能my_list ={3,5,8,2,1,0}my_str ="qegaegrhr"# 注意：排序后的结果都会变成列表对象print(f"正序排序：{sorted(my_list)}")print(f"正序排序：{sorted(my_str)}")print(f"反序排序：{sorted(my_list,reverse=True)}")print(f"反序排序：{sorted(my_str,reverse=True)}")

容器通用功能总览

10字符串大小比较

ASCII码表

字符串比较

演示

"""演示字符串大小比较"""# abc 比较 adcprint(f"abd大于abc?{'abd'>'abc'}")# a 比较 abprint(f"ab大于a?{'ab'>'a'}")# a 比较 Aprint(f"a大于A?{'a'>'A'}")# key1 比较 key2print(f"key1大于key2?{'key1'>'key2'}")

总结

Python数据容器 list列表 tuple元组 str字符串 数据容器（序列）切片 set集合 dict字典 字符串大小比较