一文学会Python 数据结构：详解list、tuple、set、dict 和字符串的高级操作

狗蛋的博客之旅

已于 2023-05-20 22:51:54 修改

阅读量1.1k

点赞数 4

分类专栏： Python 文章标签： python 开发语言

于 2023-02-19 17:46:40 首次发布

本文链接：https://blog.csdn.net/weixin_43263566/article/details/129108535

版权

Python 专栏收录该内容

28 篇文章 14 订阅

订阅专栏

数据来源

01 数据容器

为什么学习数据容器

数据容器

总结

02 列表

1）列表定义

为什么需要列表

列表的定义语法

列表的定义方式

演示

"""
演示数据容器之:list列表
语法:[元素,元素,......]
"""
# 定义一个列表list
my_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] =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)

追加元素方式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，所以这里索引写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))

列表的方法-总览

使用方式的完整代码演示

"""
演示示数据容器之: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 += 1


list_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循环的对比

总结

03 tuple元组

为什么需要元组

定义元组

演示

"""
演示 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]}") # Hello
print(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)}")

遍历元组

# 元组的遍历: while
t8 =(9,3,5,0,2,3,5)
index =0
while index < len(t8):
    print(t8[index])
    index += 1

# 元组的遍历:for
t9 = ("你好","啊","李银河")
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]}") # Hello
print(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("-----------元组的遍历-----------")
# 元组的遍历: while
t8 =(9,3,5,0,2,3,5)
index =0
while index < len(t8):
    print(t8[index])
    index += 1

# 元组的遍历:for
t9 = ("你好","啊","李银河")
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)

元组的特点

总结

04 str字符串

再识字符串

字符串的下标（索引）

演示

"""
演示以数据容器的角色,学习字符申的相关操作
"""
# 通过下标索取值
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结束,步长1
my_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 进行切片,从头开始,到最后结束,步长1
my_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 进行切片,从头开始,到最后结束,步长2
my_str ="你好，李银河123"
new_my_str =my_str[::2]
print(f"切片后的my_str：{new_my_str}") # 你，银13

# 对 str 进行切片,从头开始,到最后结束,步长-1
my_str ="你好，李银河123"
new_my_str =my_str[::-1]  # 就是把字符串倒过来
print(f"切片后的my_str：{new_my_str}") # 321河银李，好你

# 对列表进行切片,从3开始,到结束,步长-1
my_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}")

# 对元组进行切片,从头开始,到尾结束,步长2
my_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)

总结

06 set集合

为什么使用集合

集合的定义

演示

"""
演示数据容器集合的使用
"""
# 定义集合
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从而改变了set1
print(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从而改变了set1
print(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}")

集合常用功能总结

集合的特点

总结

07 dict 字典

为什么使用字典

字典定义

"""
演示数据容器字典的定义
"""
# 定义字典
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获取Value
my_dict1 = {"张三":99,"李四":60,"王五":80}
print(my_dict1["张三"]) # 99
print(my_dict1["李四"]) # 60
print(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["陈六"] = 67
print(f"新增元素={my_dict1}")

# 更新元素
my_dict1["王五"] = 100
print(f"更新元素={my_dict1}")

# 删除元素 pop()
score = my_dict1.pop("李四")  # pop删除指定的元素也会返回被删除的元素
print(f"删除元素={my_dict1},李四的考试分数是：{score}")

# 清空元素
my_dict1.clear()
print(f"清空元素={my_dict1}")

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

演示

# 获取全部的key
my_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] 值value
    print(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 比较 adc
print(f"abd大于abc?{'abd'>'abc'}")

# a 比较 ab
print(f"ab大于a?{'ab'>'a'}")

# a 比较 A
print(f"a大于A?{'a'>'A'}")

# key1 比较 key2
print(f"key1大于key2?{'key1'>'key2'}")