Python数据容器

Python数据容器

数据容器介绍

一种可以存储多个元素的Python数据类型，数据容器种类：list(列表)、tuple(元组)、str(字符串)、set(集合)、dict(字典)

List列表

List列表定义

语法：[元素1, 元素2, 元素3, ......]
元素：数据容器内的每一份数据，都称之为元素
限制: 元素的数据类型没有任何限制，甚至元素也可以是列表，这样就定义了嵌套列表

# 定义一个列表list
my_list = ["python", "java", "mysql"]
print(my_list)
print(type(my_list))

my_list = ["python", 11, True]
print(my_list)
print(type(my_list))

# 定义一个嵌套列表
my_list = [[1, 2], [3, 4]]
print(my_list)
print(type(my_list))

# 结果
['python', 'java', 'mysql']
<class 'list'>
['python', 11, True]
<class 'list'>
[[1, 2], [3, 4]]
<class 'list'>

List列表下标索引

语法：列表[下标索引]
下标：列表的每一个元素，都有编号称之为下标索引。从前向后的方向，编号从0开始递增，从后向前的方向，编号从-1开始递减。
注意：下标索引的取值范围，超出范围无法取出元素，并且会报错

# 通过下标索引取出对应位置的数据
my_list = ["python", "java", "mysql"]
# 列表[下标索引]，从前向后从0开始，每次+1， 从后向前从-1开始，每次-1
print(my_list[0])
print(my_list[1])
print(my_list[2])
# 错误案例，超出范围报错：list index out of range
# print(my_list[3])

# 通过下标索引倒序取出
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])

# 取出嵌套列表的元素
my_list = [[1, 2], [3, 4]]
print(my_list[1][1])

# 结果
python
java
mysql
mysql
java
python
4

列表的常用操作

1. 列表的常见方法：

编号	使用方式	作用
1	列表.append(元素)	向列表中追加一个元素
2	列表.extend(容器)	将数据容器的内容依次取出，追加到列表尾部
3	列表.insert(下标, 元素)	在指定下标处，插入指定的元素
4	del 列表[下标]	删除列表指定下标元素
5	列表.pop(下标)	删除列表指定下标元素
6	列表.remove(元素)	从前向后，删除此元素第一个匹配项
7	列表.clear()	清空列表
8	列表.count(元素)	统计此元素在列表中出现的次数
9	列表.index(元素)	查找指定元素在列表的下标，找不到报错ValueError
10	len(列表)	统计容器内有多少元素

2. 列表特点：

• 可容纳多个元素
• 可容纳不同元素类型
• 数据有序存储的
• 允许重复数据存在
• 可以增删改元素

my_list = ["python", "java", "mysql"]
# 1.1 查找元素在列表内的下标索引
index = my_list.index("python")
print(f"python的索引值：{index}")

# 1.2 如果查找的不存在，会报错 '123123' is not in list
# index = my_list.index("123123")
# print(f"不存在的索引值：{index}")

# 2 修改特定下标的值
my_list[0] = "linux"
print(f"列表元素修改后的结果：{my_list}")

# 3 在指定下标位置插入元素
my_list.insert(1, "docker")
print(f"列表插入元素后的结果：{my_list}")

# 4 在列表尾部追加单个元素
my_list.append("html")
print(f"列表追加元素后的结果：{my_list}")

# 5 在列表尾部追加一批元素
my_list2 = [1, 2, 3]
my_list.extend(my_list2)
print(f"列表追加了新的列表后的结果：{my_list}")

# 6 删除指定下标元素 del（2种方式）
my_list = ["python", "java", "mysql"]
del my_list[0]
print(f"列表删除元素后的结果：{my_list}")

# 6.2 方式2 pop方法
my_list = ["python", "java", "mysql"]
element = my_list.pop(0)
print(f"通过pop方法取出元素后的列表内容：{my_list}，取出的元素是：{element}")

# 7 删除某元素在列表中的第一个匹配项
my_list = ["python", "java", "mysql", "linux", "docker"]
my_list.remove("linux")
print(f"通过remove方法移除元素后的结果：{my_list}")

# 8 清空列表
my_list.clear()
print(f"列表被清空了，结果是：{my_list}")

# 9 统计列表内某元素的数量
my_list = ["python", "java", "mysql", "linux", "java"]
count = my_list.count("java")
print(f"列表中java的数量有：{count}个")

# 10 统计列表的元素数量
my_list = ["python", "java", "mysql", "linux", "java"]
count = len(my_list)
print(f"列表的元素数量有：{count}个")

# 结果
python的索引值：0
列表元素修改后的结果：['linux', 'java', 'mysql']
列表插入元素后的结果：['linux', 'docker', 'java', 'mysql']
列表追加元素后的结果：['linux', 'docker', 'java', 'mysql', 'html']
列表追加了新的列表后的结果：['linux', 'docker', 'java', 'mysql', 'html', 1, 2, 3]
列表删除元素后的结果：['java', 'mysql']
通过pop方法取出元素后的列表内容：['java', 'mysql']，取出的元素是：python
通过remove方法移除元素后的结果：['python', 'java', 'mysql', 'docker']
列表被清空了，结果是：[]
列表中java的数量有：2个
列表的元素数量有：5个

列表的循环遍历

while与for对比：

• while循环可以自定循环条件，并自行控制，for循环不可以自定循环条件，只可以一个个从容器内取出数据
• while循环可以通过条件控制做到无限循环，for循环理论上不可以，因为被遍历的容器容量不是无限的
• while循环适用于任何想要循环的场景，for循环适用于，遍历数据容器的场景或简单的固定次数循环场景
• while更灵活，for循环更简单

def list_while_func():
    """
    使用while循环便利列表的函数
    :return:
    """
    my_list = ["python", "java", "mysql"]
    i = 0
    while i < len(my_list):
        print(my_list[i])
        i += 1

list_while_func()

def list_for_func():
    """
    使用for循环便利列表的函数
    :return:
    """
    my_list = ["python", "java", "mysql"]
    for x in range(0, len(my_list)):
        print(my_list[x])

list_for_func()

# 结果
python
java
mysql
python
java
mysql

元组的定义和操作

定义方式：

• 多个元素定义：(元素, 元素, 元素, ......)
• 单个元素定义：(元素, ) 单个元素必须加个逗号后面跟个空格，否则类型就不是tuple

操作方法：

方法	作用
index()	查找某个数据，如果数据存在返回对应的下标，否则报错
count()	统计某个数据在当前元组出现的次数
len(元组)	统计元组内的元素个数

注意事项：不可修改内容（可以修改内部list的内部元素）例子：t9 = (1, 2, [3, 4]) 3和4是可以修改的
元组特点：和list基本相同（有序、任意数量元素、允许重复元素），唯一不同在于不可修改。支持for循环

# 定义元组
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 = ('Hello', )
print(f"t4的类型是：{type(t4)}，内容是：{t4}")

# 元组的嵌套
t5 = ((1,2,3), (4,5,6))
print(f"t5的类型是：{type(t5)}，内容是：{t5}")

# 下标索引去取出内容
num = t5[1][2]
print(f"从嵌套元组中取出的数据是：{num}")

# 元组的操作：index方法
t6 = ("java","python","mysql")
index = t6.index("java")
print(f"在元组t6中查找java的下标是：{index}")

# 元组的操作：count方法
t7 = ("java","python","mysql","java")
count = t7.count("java")
print(f"在元组t7中java元素数量是：{count}")

# 元租的操作：len函数
t8 = ("java","python","mysql","linux","docker")
num = len(t8)
print(f"元组t8的元素数量是：{num}")

# 元组遍历：while
index = 0
while index < len(t8):
    print(f"while循环元组的元素有：{t8[index]}")
    index += 1

# 元组遍历：for
for element in t8:
    print(f"for循环元组的元素有：{element}")

# 错误案例：修改元组内容！ 元组内容是不可更改的
# t8[0] = "vue"

# 可以修改元组中list列表
t9 = (1, 2, [1, 2])
print(f"t9的内容是：{t9}")
t9[2][0] = 3
print(f"t9的内容是：{t9}")

# 结果
t1的类型是：<class 'tuple'>，内容是：(1, 'Hello', True)
t2的类型是：<class 'tuple'>，内容是：()
t3的类型是：<class 'tuple'>，内容是：()
t4的类型是：<class 'tuple'>，内容是：('Hello',)
t5的类型是：<class 'tuple'>，内容是：((1, 2, 3), (4, 5, 6))
从嵌套元组中取出的数据是：6
在元组t6中查找java的下标是：0
在元组t7中java元素数量是：2
元组t8的元素数量是：5
while循环元组的元素有：java
while循环元组的元素有：python
while循环元组的元素有：mysql
while循环元组的元素有：linux
while循环元组的元素有：docker
for循环元组的元素有：java
for循环元组的元素有：python
for循环元组的元素有：mysql
for循环元组的元素有：linux
for循环元组的元素有：docker
t9的内容是：(1, 2, [1, 2])
t9的内容是：(1, 2, [3, 2])

字符串的定义和操作

操作方法：

编号	方法	描述
1	字符串[下标]	根据下标索引取出特定位置字符
2	字符串.index(字符串）	查找给定字符的第一个匹配项的下标
3	字符串.replace(字符串1, 字符串2)	将字符串内的全部字符串1，替换为字符串2不会修改原字符串，而是得到一个新的
4	字符串.split(字符串)	按照给定字符串，对字符串进行分隔不会修改原字符串，而是得到一个新的列表
5	字符串.strip()、字符串.strip(字符串)	移除首尾的空格和换行符或指定字符串
6	字符串.count(字符串)	统计字符串内某字符串的出现次数
7	len(字符串)	统计字符串的字符个数

字符串特点：

• 只可以存储字符串
• 长度任意
• 支持下标索引
• 允许重复字符存在
• 不可以增删改元素
• 支持for循环

my_str = "java and python"
# 通过下标索引取值
value = my_str[2]
value2 = my_str[-13]
print(f"从字符串{my_str}取下标为2的值是：{value}，取下标为-13的值是：{value2}")

# my_str[2] = "H"
# index方法
value = my_str.index("and")
print(f"在字符串{my_str}中查找and，起始下标为：{value}")

# replace方法
new_str = my_str.replace("java", "linux")
print(f"子啊字符串{my_str}替换后，字符串值为：{new_str}")

# split方法
my_str = "mysql java python docker"
my_str_list = my_str.split(" ")
print(f"字符串{my_str}进行split切分后得到：{my_str_list}")

# strip方法
my_str = " java and python   "
new_str = my_str.strip()
print(f"字符串{my_str}被strip后为：{new_str}")

my_str = "12java and python21"
new_str = my_str.strip('12')
print(f"字符串{my_str}被strip('12')后为：{new_str}")

# 统计字符串中某个字符串的出现次数
my_str = "java and python"
count = my_str.count("a")
print(f"字符串{my_str}中a的出现次数：{count}")

# 统计字符串的长度
my_str = "java and python"
num = len(my_str)
print(f"字符串{my_str}长度：{num}")

# 结果
从字符串java and python取下标为2的值是：v，取下标为-13的值是：v
在字符串java and python中查找and，起始下标为：5
子啊字符串java and python替换后，字符串值为：linux and python
字符串mysql java python docker进行split切分后得到：['mysql', 'java', 'python', 'docker']
字符串 java and python   被strip后为：java and python
字符串12java and python21被strip('12')后为：java and python
字符串java and python中a的出现次数：3
字符串java and python长度：15

数据容器的（序列）的切片

序列：内容连续、有序，可使用下标索引的一类数据容器。列表、元组、字符串，均可以可以视为序列。序列支持切片，即：列表、元组、字符串，均支持进行切片操作
切片：从一个序列中，取出一个子序列
语法：序列[起始下标:结束下标:步长]：从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列

• 从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列
• 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
• 步长表示，依次取元素的间隔 （可以为负数，表示倒序执行）
  • 步长1表示，一个个取元素
  • 步长2表示，每次跳过1个元素取
  • 步长N表示，每次跳过N-1个元素取
  • 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）
• 起始、结束、步长均可省略，起始为从头开始可省略，结束为最后结束可以省略，步长为1可以省略

注意：切片不会影响序列本身，而是会得到一个新的序列（列表、元组、字符串）

# 对list进行切片，从1开始，4结束，步长1
my_list = [1,2,3,4,5,6]
result = my_list[1:4]  # 步长默认是1，可以不写
print(f"结果1：{result}")

# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (1,2,3,4,5,6)
result = my_tuple[:]  # 起始和结束不写表示从头到尾，步长默认为1
print(f"结果2：{result}")

# 对字符串进行切片，从头开始，到最后结束，步长2
my_str = "0123456"
result = my_str[::2]
print(f"结果3：{result}")

# 对字符串进行切片，从头开始，到最后结束，步长-1
my_str = "0123456"
result = my_str[::-1]  # 等同于将序列反转
print(f"结果4：{result}")

# 对列表进行切片，从3开始，到1结束，步长-1
my_list = [1,2,3,4,5,6]
result = my_list[3:1:-1]
print(f"结果5：{result}")

# 对元组进行切片，从头开始，到最后结束，步长-2
my_tuple = (1,2,3,4,5,6)
result = my_tuple[::-2]
print(f"结果6：{result}")

# 结果
结果1：[2, 3, 4]
结果2：(1, 2, 3, 4, 5, 6)
结果3：0246
结果4：6543210
结果5：[4, 3]
结果6：(6, 4, 2)

集合的定义和操作

语法：{元素, 元素, ......, 元素}
特点：

• 集合内不允许重复元素（去重）
• 集合内元素是无序的（不支持下标索引）
• 可以增删改
• 支持for循环
• 可以容纳不同数据类型的数据

操作方法：

编号	方法	描述
1	集合.add(元素)	集合内添加一个元素
2	集合.remove(元素)	移除集合内指定的元素
3	集合.pop()	从集合中随机取出一个元素
4	集合.clear()	将集合清空
5	集合1.difference(集合2)	得到一个新集合，内含2个集合的差集，原有的2个集合内容不变
6	集合1.difference_update(集合2)	在集合1中，删除集合2中存在的元素集合1被修改，集合2不变
7	集合1.union(集合2)	得到1个新集合，内含2个集合的全部元素，原有的2个集合内容不变
8	len(集合)	得到一个整数，记录了集合的元素数量

# 定义集合
my_set = {"java", "python", "mysql", "java", "python", "mysql", "java", "python", "mysql"}
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)}")

# 添加新元素
my_set.add("redis")
my_set.add("java")
print(f"my_set添加新元素结果是：{my_set}")

# 移除元素
my_set.remove("java")
print(f"my_set移除java元素结果是：{my_set}")

# 随机取一个元素
my_set = {"java", "python", "mysql"}
element = my_set.pop()
print(f"随机取出的元素是：{element}，my_set结果是：{my_set}")

# 清空集合
my_set.clear()
print(f"执行clear后结果为：{my_set}")

# 取2个集合的差集
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.difference(set2)
print(f"取出差集的结果是：{set3}")
print(f"取差集后，set1内容是：{set1}")
print(f"取差集后，set2内容是：{set2}")

# 消除2个集合的差集
set1.difference_update(set2)
print(f"消除差集的结果是：{set3}")
print(f"消除差集后，set1内容是：{set1}")
print(f"消除差集后，set2内容是：{set2}")

# 2个集合合并
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.union(set2)
print(f"合并后的结果是：{set3}")
print(f"合并后，set1内容是：{set1}")
print(f"合并后，set2内容是：{set2}")

# 统计集合元素数量len()
set1 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
num = len(set1)
print(f"集合内的元素数量是：{num}")

# 集合的遍历
# 集合不支持下标索引，所以不支持wile
for element in set1:
    print(f"集合的元素有：{element}")

# 结果
my_set的内容是：{'mysql', 'java', 'python'}，类型是：<class 'set'>
my_set_empty的内容是：set()，类型是：<class 'set'>
my_set添加新元素结果是：{'mysql', 'java', 'python', 'redis'}
my_set移除java元素结果是：{'mysql', 'python', 'redis'}
随机取出的元素是：mysql，my_set结果是：{'java', 'python'}
执行clear后结果为：set()
取出差集的结果是：{2, 3}
取差集后，set1内容是：{1, 2, 3}
取差集后，set2内容是：{1, 5, 6}
消除差集的结果是：{2, 3}
消除差集后，set1内容是：{2, 3}
消除差集后，set2内容是：{1, 5, 6}
合并后的结果是：{1, 2, 3, 5, 6}
合并后，set1内容是：{1, 2, 3}
合并后，set2内容是：{1, 5, 6}
集合内的元素数量是：5
集合的元素有：1
集合的元素有：2
集合的元素有：3
集合的元素有：4
集合的元素有：5

字典的定义

字典：字典可以提供基于Key检索Value的场景实现
语法：{key:value,key:value,.....}
注意事项：

• 键值对的Key和Value可以是任意类型（Key不可为字典）
• 字典内Key不允许重复，重复添加等同于覆盖原有数据
• 字典不可用下标索引，而是通过Key检索Value

# 定义字典
my_dict1 = {"蟹老板":"80", "章鱼哥":"70", "派大星":"75"}
# 空字典
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_dict1 = {"蟹老板":"80", "蟹老板":"70", "派大星":"75"}
print(f"重复key的字典内容是：{my_dict1}")

# 从字典中基于key获取value
my_dict1 = {"蟹老板":"80", "章鱼哥":"70", "派大星":"75"}
score = my_dict1["蟹老板"]
print(f"根据key：java获取的value值是：{score}")

# 定义嵌套字典
stu_score_dict = {
    "蟹老板": {
        "语文": 80,
        "数学": 80,
        "英语": 80
    },
    "章鱼哥": {
        "语文": 70,
        "数学": 75,
        "英语": 60
    },
    "派大星": {
        "语文": 74,
        "数学": 79,
        "英语": 78
    }
}
print(f"学生的考试信息是：{stu_score_dict}")
print(f"蟹老板语文成绩是：{stu_score_dict['蟹老板']['语文']}")

# 结果
字典1的内容是：{'蟹老板': '80', '章鱼哥': '70', '派大星': '75'}，类型是：<class 'dict'>
字典2的内容是：{}，类型是：<class 'dict'>
字典3的内容是：{}，类型是：<class 'dict'>
重复key的字典内容是：{'蟹老板': '70', '派大星': '75'}
根据key：java获取的value值是：80
学生的考试信息是：{'蟹老板': {'语文': 80, '数学': 80, '英语': 80}, '章鱼哥': {'语文': 70, '数学': 75, '英语': 60}, '派大星': {'语文': 74, '数学': 79, '英语': 78}}
蟹老板语文成绩是：80

字典的操作

注意事项：新增和更新元素的语法一致，如果Key不存在即新增，如果Key存在即更新（Key不可重复）
字典特点：

• 可以容纳多个数据
• 可以容纳不同类型的数据
• 每一份数据是Key:Value键值对
• 可以通过Key获取到Value，Key不可重复（重复会覆盖）
• 不支持下标索引
• 可以修改（增加或删除更新元素等）
• 支持for循环，不支持while循环

操作方法：

编号	方法	描述
1	字典[Key]	获取指定Key对应的Value值
2	字典[Key] = Value	添加或更新键值对
3	字典.pop(Key)	取出Key对应的Value并在字典内删除此Key的键值对
4	字典.clear()	清空字典
5	字典.keys()	获取字典的全部Key，可用于for循环遍历字典
6	字典.keys()	计算字典内的元素数量

# 定义字典
my_dict = {"蟹老板": 80, "章鱼哥": 70, "派大星": 75}

# 新增元素
my_dict["海绵宝宝"] = 77
print(f"添加元素，结果：{my_dict}")

# 更新元素
my_dict["蟹老板"] = 90
print(f"修改元素，结果：{my_dict}")

# 删除元素
score = my_dict.pop("海绵宝宝")
print(f"删除海绵宝宝，分数为：{score}，字典内容：{my_dict}")

# 清空字典
my_dict.clear()
print(f"字典被清空了，结果：{my_dict}")

# 获取全部key
my_dict = {"蟹老板": 80, "章鱼哥": 70, "派大星": 75}
keys = my_dict.keys()
print(f"字典的全部key是：{keys}")

# 遍历字典
# 方式一：通过获取全部key完成遍历
for key in keys:
    print(f"字典1的key是：{key}")
    print(f"字典1的value是：{my_dict[key]}")

# 方式二：直接对字典for循环，每一次循环都是得到的key
for key in my_dict:
    print(f"字典2的key是：{key}")
    print(f"字典2的value是：{my_dict[key]}")

# 统计字典的元素数量
num = len(my_dict)
print(f"字典的元素数量是：{num}")

# 结果
添加元素，结果：{'蟹老板': 80, '章鱼哥': 70, '派大星': 75, '海绵宝宝': 77}
修改元素，结果：{'蟹老板': 90, '章鱼哥': 70, '派大星': 75, '海绵宝宝': 77}
删除海绵宝宝，分数为：77，字典内容：{'蟹老板': 90, '章鱼哥': 70, '派大星': 75}
字典被清空了，结果：{}
字典的全部key是：dict_keys(['蟹老板', '章鱼哥', '派大星'])
字典1的key是：蟹老板
字典1的value是：80
字典1的key是：章鱼哥
字典1的value是：70
字典1的key是：派大星
字典1的value是：75
字典2的key是：蟹老板
字典2的value是：80
字典2的key是：章鱼哥
字典2的value是：70
字典2的key是：派大星
字典2的value是：75
字典的元素数量是：3

数据容器对比

	列表	元组	字符串	集合	字典
元素数量	支持多个	支持多个	支持多个	支持多个	支持多个
元素类型	任意	任意	仅字符	任意	Key：Value，Key：除字典外任意类型;Value：任意类型
下标索引	支持	支持	支持	不支持	不支持
重复元素	支持	支持	支持	不支持	不支持
可修改性	支持	不支持	不支持	支持	支持
数据有序	是	是	是	否	否
使用场景	可修改、可重复的一批数据记录场景	不可修改、可重复的一批数据记录场景	一串字符的记录场景	不可重复的数据记录场景	以Key检索Value的数据记录场景

数据容器通用操作

操作方法：

编号	方法	描述
1	通用for循环	遍历容器（字典是遍历key）
2	max()	容器内最大元素
3	min()	容器内最小元素
4	len()	容器元素个数
5	list()	转换为列表
6	tuple()	转换为元组
7	str()	转换为字符串
8	set()	转换为集合
9	sorted(序列，reverse=True)	排序，reverse=True表示降序

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最大元素
print("-----------------------------最大元素-----------------------------")
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最小元素
print("-----------------------------最小元素-----------------------------")
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)}")

# 容器转列表
print("-----------------------------容器转列表-----------------------------")
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("-----------------------------容器转元组-----------------------------")
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("-----------------------------容器转字符串-----------------------------")
print(f"列表转字符串的结果：{str(my_list)}")
print(f"元组转字符串的结果：{str(my_tuple)}")
print(f"字符串转字符串结果：{str(my_str)}")
print(f"集合转字符串的结果：{str(my_set)}")
print(f"字典转字符串的结果：{str(my_dict)}")

# 容器转集合
print("-----------------------------容器转集合-----------------------------")
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)}")


my_list = [5, 3, 1, 4, 2]
my_tuple = (3, 2, 1, 4, 5)
my_str = "abcdefg"
my_set = {3, 4, 5, 2, 1}
my_dict = {"key3": 1, "key5": 2, "key1": 3, "key2": 4, "key4": 5}

# 进行容器的排序
print("-----------------------------容器的排序-----------------------------")
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("---------------------------容器的反向排序----------------------------")
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)}")

# 结果
列表 元素个数：5
元组 元素个数：5
字符串 元素个数：7
集合 元素个数：5
字典 元素个数：5
-----------------------------最大元素-----------------------------
列表 最大元素：5
元组 最大元素：5
字符串最大元素：g
集合 最大元素：5
字典 最大元素：key5
-----------------------------最小元素-----------------------------
列表 最小元素：1
元组 最小元素：1
字符串最小元素：a
集合 最小元素：1
字典 最小元素：key1
-----------------------------容器转列表-----------------------------
列表转列表的结果：[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')
-----------------------------容器转字符串-----------------------------
列表转字符串的结果：[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}
字符串转集合结果：{'a', 'd', 'e', 'f', 'c', 'g', 'b'}
集合转集合的结果：{1, 2, 3, 4, 5}
字典转集合的结果：{'key3', 'key2', 'key4', 'key1', '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']
列表对象的反向排序结果：[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']

拓展-字符串大小比较

ASCII码表，在程序中，字符串都有其对应的ASCII码表值，所用的所有字符如：

• 大小写英文单词
• 数字
• 特殊符号(!、\、|、@、#、空格等）

字符串是按位比较，也就是一位位进行对比，只要有一位大，那么整体就大。

# abd 比较 abc
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"key2大于key1，结果：{'key2' > 'key1'}")

# 结果
abd大于abc，结果：True
ab大于a，结果：True
a大于A，结果：True
key2大于key1，结果：True

1. 字符串如何比较？：从头到尾，一位位进行比较，其中一位大，后面就无需比较了。
2. 单个字符之间如何确定大小？：通过ASCII码表，确定字符对应的码值数字来确定大小