深入解析Python数据容器

Python数据容器

1，数据容器介绍
2，数据容器的分类
3，数据容器：list（列表）
- 3.1，列表的定义
- 3.2，列表的下标索引
- 3.3，列表的常用操作
- - 3.3.1，查找指定元素下标
  - 3.3.2，修改元素值
  - 3.3.3，插入元素
  - 3.3.4，追加元素
  - 3.3.5，批量追加元素
  - 3.3.6，元素的删除
  - 3.3.7，清空列表
  - 3.3.8，统计某元素数量
  - 3.3.9，统计列表元素总数
- 3.4，列表的遍历
- - 3.4.1，while循环遍历列表
  - 3.4.2，for循环遍历链表
4，数据容器：tuple（元组）
- 4.1，元组的定义
- 4.2，元组的常用操作
5，数据容器：str（字符串）
- 5.1，字符串的定义
- 5.2，字符串的常用操作
- - 5.2.1，字符串的替换
  - 5.2.2，字符串的分割
  - 5.2.3，字符串的规整操作
  - 5.2.4，统计字符串出现的次数
  - 5.2.5，统计字符串长度
6，序列
- 6.1，序列的切片
7，数据容器：set（集合）
- 7.1，集合的定义
- 7.2，集合的常用操作
8，数据容器：dict（字典）
- 8.1，字典的定义
- 8.2，字典的常用操作
9，总结与拓展
- 9.1，数据容器总结对比
- 9.2，数据容器的通用操作

1，数据容器介绍

Python中，数据容器是一种可以容纳多份数据的Python数据类型；
容纳的每一份数据称之为1个元素；
每一个元素，可以是任意类型的数据，如字符串、数字、布尔等；

2，数据容器的分类

五种数据容器各有特点，但都可以满足容纳多个元素的特性，接下来将对其进行一一介绍。

3，数据容器：list（列表）

3.1，列表的定义

以[]作为标识；
列表内每一个元素之间使用“,（逗号）”隔开；
列表内的每一个数据，称之为元素；
列表可以一次存储多个数据，多个数据可以为不同的数据类型；
列表允许重复数据存在
列表是有序存储（有下标序号）
列表是可以修改的
列表支持嵌套。

# 定义列表1
name_list1 = ['John','Bob','Alice']
# 定义列表2（列表2中元素数据类型不一致）
name_list2 = ['John',666,True]
# 定义列表3（嵌套列表）
name_list3 = [[1,2,3],[4,5,6]]# 打印输出列表：['John', 'Bob', 'Alice']
print(name_list1)
# 打印输出列表：['John', 'Bob', 'Alice']
print(name_list2)# 打印输出变量类型：<class 'list'>
print(type(name_list1))
# 打印输出变量类型：<class 'list'>
print(type(name_list2))
# 打印输出变量类型：<class 'list'>
print(type(name_list3))

3.2，列表的下标索引

学习了列表的定义，思考如何从列表中取出特定位置的数据？

在这里插入图片描述

# 语法：列表[下标索引]
name_list = ['John','Bob','Alice']
print(name_list[0])  # 结果：John
print(name_list[1])  # 结果：Bob
print(name_list[2])  # 结果：Alice

另外一种索引方式是反向索引，也就是从后往前：从-1（代表最后一个元素）开始依次递减。

-1代表倒数第一个元素；
-2代表倒数第二个元素；
-3代表代数第三个元素；
…

# 语法：列表[下标索引]
name_list = ['John','Bob','Alice']
print(name_list[-1])  # 结果：Alice
print(name_list[-2])  # 结果：Bob
print(name_list[-3])  # 结果：John

如果列表是嵌套的列表，同样支持下标索引。

在这里插入图片描述

# 两层嵌套list
my_list = [[1,2,3],[4,5,6]]# 获取内层第一个list
print(my_list[0])  # 结果：[1, 2, 3]
# 获取内层第一个list的第一个元素
print(my_list[0][0])   # 结果：1
print(my_list[1][1])   # 结果：5

3.3，列表的常用操作

列表提供了一系列内置的功能，如插入元素、删除元素、清空列表、统计元素个数…
这些功能我们都称之为：列表的方法。

在这里插入图片描述
方法和函数功能一样，有传入参数，有返回值，只是方法的使用格式不同：

函数的使用：num = add(1,2)
方法的使用： 先创建一个Student实例，然后：num=student.add(1,2)（通过一个具体的类调用）

在这里插入图片描述

3.3.1，查找指定元素下标

语法：列表.index(元素)
功能：查找指定元素在列表的下标，如果找不到，报错ValueError

mylist = ['John','Bob','Alice']index = mylist.index("Bob")
print(f"Bob在列表中的下标索引值是：{index}")

运行结果是：Bob在列表中的下标索引值是：1

3.3.2，修改元素值

语法：列表[下标] = 值
功能：修改特定索引处的元素值

mylist = ['John','Bob','Alice']mylist[0] = "Blank"
print(f"列表元素值被修改后，变为：{mylist}")

运行结果是：列表元素值被修改后，变为：['Blank', 'Bob', 'Alice']

3.3.3，插入元素

语法：列表.insert(下标，元素)
功能：在指定的下标位，插入指定的元素

# 在John和Bob之间插入一个Rose
mylist = ['John','Bob','Alice']mylist.insert(1,"Rose")
print(f"插入新元素后，变为：{mylist}")

运行结果是：插入新元素后，变为：['John', 'Rose', 'Bob', 'Alice']

3.3.4，追加元素

语法：列表.append(元素)
功能：将指定元素，追加到列表的尾部

mylist = ['John','Bob','Alice']mylist.append(3)
print(f"追加新元素后，变为：{mylist}")

运行结果是：追加新元素后，变为：['John', 'Bob', 'Alice', 3]

3.3.5，批量追加元素

语法：列表.extend(其他数据容器)
功能：将其他数据容器的内容取出，依次追加到列表尾部

mylist = ['John','Bob','Alice']
mylist2 = ['JD','TB']mylist.extend([4,5,6])
print(f"批量追加元素后，变为：{mylist}")
mylist.extend(mylist2)
print(f"批量追加元素后，变为：{mylist}")

运行结果是：
批量追加元素后，变为：['John', 'Bob', 'Alice', 4, 5, 6]
批量追加元素后，变为：['John', 'Bob', 'Alice', 4, 5, 6, 'JD', 'TB']

3.3.6，元素的删除

元素删除语法1：del 列表[下标]。删除指定索引处的元素
元素删除语法2：列表.pop(下标)。弹出指定元素

# 删除元素方式一
mylist = ['John','Bob','Alice']
del mylist[2]
print(f"删除元素后，变为：{mylist}")    # 输出：删除元素后，变为：['John', 'Bob']# 删除元素方式二
mylist = ['John','Bob','Alice']
element = mylist.pop(2)# 运行结果：删除元素后，变为：['John', 'Bob']，取出的元素是：Alice
print(f"删除元素后，变为：{mylist}，取出的元素是：{element}")

以上两种删除都是根据下标删除元素，还有一种删除方式是根据元素内容删除。

语法：列表.remove(元素)
功能：删除指定元素在列表中的第一个匹配项

mylist = [1,2,3,2,3]
mylist.remove(2)  # 从前往后搜索，删除第一个2print(f"按元素内容删除元素后，变为：{mylist}")

注意：上述代码只会删除第一个2，如果想删除两个需要调用两次 remove()。

3.3.7，清空列表

语法：列表.clear()
功能：清空列表内容

mylist = [1,2,3,2,3]
mylist.clear()print(f"列表清空后，变为：{mylist}")

运行结果是：列表清空后，变为：[]

3.3.8，统计某元素数量

语法：列表.count(元素)
功能：统计某元素在列表内的数量

mylist = [1,2,3,2,3,2]
print(f"列表内该元素数量为：{mylist.count(2)}")

运行结果是：列表内该元素数量为：3

3.3.9，统计列表元素总数

语法：len(列表)
功能：可以得到一个int型数字，表示列表内的元素数量

mylist = [1,2,3,2,3,2]
print(f"列表内元素数量为：{len(mylist)}")

运行结果是：列表内元素数量为：6

3.4，列表的遍历

既然数据容器可以存储多个元素，那么就会有需求从容器内依次取出元素进行操作。将容器内元素依次取出进行处理的行为，称之为：遍历、迭代。

3.4.1，while循环遍历列表

mylist = [1,2,3,2,3,2]index =0
# while循环遍历打印列表元素
while index < len(mylist):element = mylist[index]print(f"列表的元素：{element}")# index加1，至关重要index += 1

运行结果如下：
在这里插入图片描述

3.4.2，for循环遍历链表

语法： for 临时变量 in 数据容器：然后在循环体内对临时变量进行处理

mylist = [1,2,3,2,3,2]# for循环打印列表元素
for i in mylist:print(f"列表的元素：{i}")

运行结果如下：
在这里插入图片描述

4，数据容器：tuple（元组）

通过之前的学习我们了解到，列表是可以修改的。但如果想要传递的信息不能被篡改，列表就不再合适了。

因此引入了元组。

元组一旦定义完成，就不可修改。
当我们需要在程序内封装数据，又不希望封装的数据被篡改，那么元组就非常合适了。

4.1，元组的定义

以（）作为标识
元组内每一个元素之间使用“,（逗号）”隔开
元组可以一次存储多个数据，多个数据可以为不同的数据类型
元组支持嵌套
元组也可以通过下标索引取出相应值（用法和列表相同）
元组内数据是有序存储的（有下标索引）
元组不可修改，强行修改会报错
元组允许重复数据存在
但是如果元组内部嵌套了一个list，可以修改元组内list的内容

t1 = (1,"Hello",True)# 定义空元组方式一
t2 = ()
# 定义空元组方式二
t3 = tuple()# 元组的嵌套
t4 = ((1,2,3),(4,5,6))# 通过下标索引取出元素6
element = t4[1][2]
print(element)print(f"t1的类型是：{type(t1)}，内容是{t1}")
print(f"t2的类型是：{type(t2)}，内容是{t2}")
print(f"t3的类型是：{type(t3)}，内容是{t3}")
print(f"t4的类型是：{type(t4)}，内容是{t4}")

运行结果：
在这里插入图片描述

# 定义元组
t1 = (1)
t2 = (1,)
print(f"t1的类型是{type(t1)}")
print(f"t2的类型是{type(t2)}")

运行结果：
在这里插入图片描述

4.2，元组的常用操作

由于元组不可修改，因此元组的相关操作较少。
在这里插入图片描述

t1 = (1,"Hello",True,"IT","Test","Hello")# 查找某元素索引
num1 = t1.index("IT")
print(f"在元组t1中查找IT，下标是：{num1}")# 统计某元素数量
num2 = t1.count("Hello")
print(f"在元组t1中统计元素Hello数量为：{num2}")# 计算元组长度
num3 = len(t1)
print(f"元组t1中元素个数为：{num3}")t2 = (1,2,[3,4,5])
t2[2][0] = 7
print(f"修改元组内的列表，结果为：{t2}")   # 修改元组内的列表，结果为：(1, 2, [7, 4, 5])# 元组的遍历，while循环方式
index = 0
while index < len(t1):print(f"while循环遍历，元组的元素有：{t1[index]}")index += 1# 元组的遍历：for循环方式
for element in t1:print(f"for循环遍历，元组中的元素有{element}")

运行结果：
在这里插入图片描述

5，数据容器：str（字符串）

字符串是字符的容器，一个字符串可以存放任意数量的字符。

5.1，字符串的定义

字符串同样支持使用while循环或for循环进行遍历
字符串数据容器只能存储字符串
允许重复字符串存在
和列表、元组一样，字符串也可以通过下标进行访问
字符串和元组一样，属于不可修改的数据容器
如果必须修改，只能得到一个新字符串，原字符串无法修改

my_str = "Hello World"# index()：通过下标索引取值
value = my_str.index("World")
print(f"在字符串my_str中查找World，其起始下标是：{value}")

运行结果为：在字符串my_str中查找World，其起始下标是：6

5.2，字符串的常用操作

在这里插入图片描述

5.2.1，字符串的替换

语法：字符串.replace(字符串1,字符串2)
功能：将字符串内的全部字符串1替换为字符串2
注意：此函数不是修改的字符串本身，而是得到一个新字符串

my_str = "Hello World"new_my_str = my_str.replace("Hello", "NIHAO")
print(f"字符串替换后，my_str为：{my_str}")   # 注意字符串不可修改，此处不会导致原字符串发生变化
print(f"字符串替换后，返回的new_my_str为：{new_my_str}") # 输出：字符串替换后，返回的new_my_str为：NIHAO World

运行结果为：
在这里插入图片描述

5.2.2，字符串的分割

语法：字符串.split（分割符字符串）
功能：按照指定的分隔字符串，将字符串划分为多个字符串，并存入列表对象中
注意：字符串本身不变，而是得到了一个列表对象

my_str = "Hello World learn python"my_str_list = my_str.split(" ")
print(f"将字符串my_str进行分割后得到：{my_str_list}，其类型是：{type(my_str_list)}")

运行结果为：
在这里插入图片描述

5.2.3，字符串的规整操作

语法：字符串.strip()
功能：去除前后空格

my_str = "  12Hello World learn python21       "new_str = my_str.strip()
print(f"将字符串my_str进行strip后，原字符串为：{my_str}")
print(f"将字符串my_str进行strip后得到：{new_str}")

运行结果为：
在这里插入图片描述

语法：字符串.strip(指定字符串)
功能：去除前后指定字符串

my_str1 = "12Hello World learn python1"
my_str2 = "12Hello World learn python2"
my_str3 = "12Hello World learn python12"new_str1 = my_str1.strip("12")
new_str2 = my_str2.strip("12")
new_str3 = my_str2.strip("12")
print(f"将字符串my_str1进行strip后得到：{new_str1}")
print(f"将字符串my_str2进行strip后得到：{new_str2}")
print(f"将字符串my_str3进行strip后得到：{new_str3}")

运行结果为：
在这里插入图片描述

注意：

strip之后原字符串不变，得到的是新字符串
strip(1,2) 将（1，2）划分为两个小子串，只要存在满足任意一个就会被去掉

5.2.4，统计字符串出现的次数

语法：字符串.count(指定字符串)
功能：统计字符串中某指定字符串的出现次数

my_str = "Hello World or learn python"num = my_str.count("or")
print(f"字符串my_str中or出现的次数为：{num}")

运行结果为：
在这里插入图片描述

5.2.5，统计字符串长度

语法：len(字符串)
功能：统计字符串长度

my_str = "Hello World"num = len(my_str)
print(f"字符串my_str长度为：{num}")

在这里插入图片描述

6，序列

序列是指内容连续、有序、可使用下标索引的一类数据容器。

列表、元组、字符串均可以视为序列。

在这里插入图片描述

6.1，序列的切片

切片是指从一个序列中取出一个子序列。序列支持切片，即：列表、元组、字符串，均支持进行切片操作。

语法：序列[起始下标:结束下标 :步长]
功能：表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列。

起始下标可以留空，留空表示从头开始
结束下标可以留空，留空视作截取到结尾
切片操作不会影响原序列本身，而是会得到一个新序列
步长可省略，默认为1
步长表示依次取元素的间隔，步长为负数表示反向取
步长为2表示每次跳过一个元素取，步长N表示每次跳过N-1个元素取

mylist = [1,2,3,4,5,6]# 对list进行切片，从1开始，4结束（不含4），步长1
result1 = mylist[1:4]
print(f"结果1：{result1}")# 对tuple进行切片，从头开始，到最后结束，步长1（原封不动取下来）
my_tuple = (0,1,2,3,4,5,6)
result2 = my_tuple[:]   # 或my_tuple[::1]
print(f"结果2：{result2}")# 对str进行切片，从头开始，到尾结束，步长2
my_str = "01234567"
result3 = my_str[::2]
print(f"结果3：{result3}")
# 对str进行切片，从头到尾，步长-1
result4 = my_str[::-1]
print(f"结果4：{result4}")   # -1表示从后向前取1.相当于逆置# 对列表进行切片，从3开始到1结束，步长-1
mylist = [1,2,3,4,5,6]
result5 = mylist[3:1:-1]
print(f"结果5：{result5}")# 对元组进行切片，从头到尾，步长-2
my_tuple = (0,1,2,3,4,5,6)
result6 = my_tuple[::-2]
print(f"结果6：{result6}")

运行结果如下：
在这里插入图片描述

7，数据容器：set（集合）

目前已经学习到的几种数据容器基本已经满足大多数应用场景。但不难发现仍然存在一些局限。

列表可修改、支持重复元素且有序
元组、字符串不可修改，支持重复元素且有序

列表、元组、字符串都支持重复元素。如果场景需要对内容进行去重处理，列表、元组、字符串就不方便了。

因此，我们本节引入集合。集合最主要的特点就是不支持元素的重复。并且集合内容无序。

7.1，集合的定义

集合通过{}定义，多个元素之间使用,隔开
集合可以容纳不同数据类型
集合无序且不重复
集合不支持下标索引访问。（因此集合不是序列）
集合允许修改

# 定义集合
my_set = {"Hello","Python","World","Hello","Python","World","Hello","Python","World"}
print(f"my_set的内容是：{my_set}，类型是：{type(my_set)}")   # 集合不重复且无序# 定义空集合
my_set_empty = set()

运行结果如下：
在这里插入图片描述

7.2，集合的常用操作

在这里插入图片描述

my_set = {"Hello","Python","World"}# 查看集合的元素数量（去重后的）
print(f"集合的长度为：{len(my_set)}")# 集合的添加元素操作
my_set.add("IT")
print(f"my_set添加元素后变为： {my_set}")# 集合的移除元素操作
my_set.remove("Hello")
print(f"my_set移除元素后变为： {my_set}")# 集合的随机取出元素操作
element = my_set.pop()
print(f"my_set随机取出元素后变为： {my_set}")# 集合的清空集合操作
my_set.clear()
print(f"my_set集合清空后变为： {my_set}"

运行结果如下：
在这里插入图片描述

接下来重点介绍集合的一些特殊操作。

语法：集合1.difference(集合2)
功能：取出集合1和集合 2的差集（集合1有而集合2没有的）
结果：得到新集合，集合1和集合2不变

set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.difference(set2)# set1和set2本身不变
print(f"set1：{set1}")
print(f"set2：{set2}")print(f"set3：{set3}")

运行结果如下：
在这里插入图片描述

语法：集合1.difference_update(集合2)
功能：对比集合1和集合 2，在集合1中删除和集合2相同的元素
结果：集合1被修改，集合2不变

set1 = {1,2,3}
set2 = {1,5,6}
set1.difference_update(set2)print(f"set1：{set1}")
print(f"set2：{set2}")

运行结果如下：
在这里插入图片描述

语法：集合1.union(集合2)
功能：将集合1和集合2组合成新集合
结果：得到新集合，集合1和集合2不变

set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.union(set2)print(f"set1：{set1}")
print(f"set2：{set2}")
print(f"set3：{set3}")

运行结果如下：
在这里插入图片描述

由于集合不支持下标索引，因此一般通过for循环遍历

set1 = {1,2,6,4,5}
for i in set1:print(f"集合的元素有：{i}")

运行结果如下：
在这里插入图片描述

8，数据容器：dict（字典）

生活中的字典是通过字找到对应的含义，Python中的字典也是一样的道理，可以通过key找到与之对应的value。

在这里插入图片描述

8.1，字典的定义

字典和集合一样，使用{}定义
字典同集合一样，不支持使用下标索引。可通过key找对应的value
字典存储的元素是一个个的键值对
字典可以修改
键值对内key和value通过:分隔
键值对之间使用，分隔
key不可重复，重复会对原有数据覆盖
key和value可以是任意类型数据（但key不可为字典类型）

# 定义空字典方式一
my_dict2 = {}
# 定义空字典方式二
my_dict3 = dict()# 字典定义
my_dict1 = {"小明":99,"小王":88,"小张":77}
print(f"字典1的内容是：{my_dict1}。类型是：{type(my_dict1)}")# 通过Key找到value
score = my_dict1["小明"]
print(f"小明的考试成绩为：{score}")

运行结果如下：
在这里插入图片描述

可将如下表格表达为字典：
在这里插入图片描述

# 定义嵌套字典
stu_score_dict = {"王力鸿":{"语文":77,"数学":66,"英语":33},"周杰轮":{"语文":88,"数学":86,"英语":55},"林俊节":{"语文":99,"数学":96,"英语":66}
}print(f"学生的考试信息是 :{stu_score_dict}")# 查询嵌套字典信息
score1 = stu_score_dict["周杰轮"]["语文"]
score2 = stu_score_dict["林俊节"]["英语"]
print(f"周杰轮的语文分数是：{score1}")
print(f"林俊节的英语分数是：{score2}")

运行结果是：
在这里插入图片描述

8.2，字典的常用操作

在这里插入图片描述

# 演示字典的常用操作
my_dict = {"a":1, "b":2, "c":3}# 新增元素
my_dict["d"] = 4
print(f"字典新增元素后，结果是：{my_dict}")# 更新元素和新增元素操作一致（无则新增，有则更新）
my_dict["d"] = 5
print(f"字典更新元素后，结果是：{my_dict}")# 删除元素
my_dict.pop("a")
print(f"字典删除元素后，结果是：{my_dict}")# 清空元素
my_dict.clear()
print(f"字典清空后，结果是：{my_dict}")my_dict = {"a":1, "b":2, "c":3}# 获取全部的key（可用于字典遍历）
keys = my_dict.keys()
print(f"字典的全部keys是：{keys}")  # 输出结果字典的全部keys是：dict_keys(['a', 'b', 'c'])# 字典遍历方式一
for key in my_dict.keys():print(f"遍历方式一：key是：{key}，value是：{my_dict[key]}")# 字典遍历方式二（直接对字典进行for循环，每次循环都是直接得到key）
for key in my_dict:print(f"遍历方式二：key是：{key}，value是：{my_dict[key]}")# 统计字典内元素数量
num = len(my_dict)
print(f"字典内元素数量为：{num}个")

运行结果如下：
在这里插入图片描述

9，总结与拓展

9.1，数据容器总结对比

以上几种数据容器可以从如下角度进行简单分类。

支持：列表、元组、字符串（序列类型）
不支持：集合、字典（非序列类型）

支持：列表、元组、字符串（序列类型）
不支持：集合、字典（非序列类型）

支持：列表、集合、字典
不支持：元组、字符串

列表：一组数据，可修改，可重复的存储场景；
元组：一组数据，不可修改，可重复的存储场景；
字符串：一串字符串的存储场景；
集合：一组数据，去重的存储场景；
字典：一组数据，可用key检索value的存储场景

9.2，数据容器的通用操作

五类数据容器都支持for循环遍历
len()函数：统计容器内元素个数
max()函数：统计容器内最大元素
min()函数：统计容器的最小元素
字符串的排序和比较实际是按照相应字符的ASCII码值

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

运行结果如下：
在这里插入图片描述

list(容器)：将给定容器转换为列表
str(容器)：将给定容器转换为字符串
tuple(容器)：将给定容器转换为元组
set(容器)：将给定容器转换为集合

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(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_str)}")
print(f"集合转元组，结果为：{tuple(my_set)}")
print(f"字典转元组，结果为：{tuple(my_dict)}")
print("****************")# 容器转字符串
print(f"列表转字符串，结果为：{str(my_list)}")   # 实际上变成了字符串："[1, 2, 3, 4, 5]"
print(f"元组转字符串，结果为：{str(my_tuple)}")   # 实际上变成了字符串："(1, 2, 3, 4, 5)"
print(f"集合转字符串，结果为：{str(my_set)}")   # 实际上变成了："{1, 2, 3, 4, 5}"
print(f"字典转字符串，结果为：{str(my_dict)}")  # 实际上变成："{'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5}"
print("****************")# 容器转为集合（集合数据无序）
print(f"列表转集合，结果为：{set(my_list)}")
print(f"元组转集合，结果为：{set(my_tuple)}")
print(f"字符串转集合，结果为：{set(my_str)}")
print(f"字典转集合，结果为：{set(my_dict)}")
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(f"元组转列表，结果为：{list(my_tuple)}")
print(f"字符串转列表，结果为：{list(my_str)}")
print(f"集合转列表，结果为：{list(my_set)}")
print(f"字典转列表，结果为：{list(my_dict)}")

运行结果如下：
在这里插入图片描述

注意：dict类型转成str类型会保留value，dict类型转为list、tuple和set时不保留value。

语法：sorted(容器,[reverse=True])
功能：将给定容器排序（reverse是反转，默认为False）
结果：排序完成得到一个列表对象

my_list = [5,3,8,7,1]
my_tuple = (7,5,9,3,8)
my_str = "qwerty"
my_set = {4,9,6,5,8}
my_dict = {"key3":1,"key5":2,"key1":3,"key2":4,"key4":5}# 容器排序操作
print(f"列表对象的排序结果为：{sorted(my_list,reverse=True)}")
print(f"元组对象的排序结果为：{sorted(my_tuple)}")
print(f"字符串对象的排序结果为：{sorted(my_str)}")
print(f"字典对象的排序结果为：{sorted(my_dict)}")