小白学习python第四天

学习python第四天

一、数据容器（元组、字符串、集合、字典）

1、元组

昨天我们学习了列表，我们知道列表是可以修改的数据容器，现在我们来学习一个不可以被修改的数据容器元组。

1.1、元组的定义格式

元组使用小括号，而且使用逗号隔开各个数据，数据可以是不同的数据类型。

# 定义元组字面量
(元素, 元素, 元素,..., 元素)# 定义元组变量
变量名 = (元素, 元素, 元素, ... , 元素)# 定义空元组（两种方式）
变量名称 = ()
变量名称 = ruple()

示例演示：

# 定义元组
t1 = (1, 12.03, "糖锅")# 定义单个元素的元组：记得添加逗号！
t2 = ("糖锅", )# 定义空元组
t3 = ()
t4 = tuple()# 定义一个嵌套元组
t5 = ((1, 2, 0, 3), (0, 1))print(f"t1元组的类型是：{type(t1)}，它其中的内容是：{t1}")
print(f"t1元组的类型是：{type(t2)}，它其中的内容是：{t2}")
print(f"t1元组的类型是：{type(t3)}，它其中的内容是：{t3}")
print(f"t1元组的类型是：{type(t4)}，它其中的内容是：{t4}")
print(f"t1元组的类型是：{type(t5)}，它其中的内容是：{t5}")

示例结果：

t1元组的类型是：<class 'tuple'>，它其中的内容是：(1, 12.03, '糖锅')
t1元组的类型是：<class 'tuple'>，它其中的内容是：('糖锅',)
t1元组的类型是：<class 'tuple'>，它其中的内容是：()
t1元组的类型是：<class 'tuple'>，它其中的内容是：()
t1元组的类型是：<class 'tuple'>，它其中的内容是：((1, 2, 0, 3), (0, 1))

如果你想通过下标从元组中取出特定的元素也是可以的，操作和列表一样。

1.2、元组的基本操作

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

示例演示：

t1 = ("糖锅", "菠萝蜜", "糖锅")# 查找元组中特定元素的下标
index1 = t1.index("菠萝蜜")
print(f"t1元组中\"菠萝蜜\"的下标是：{index1}")# 统计t1元组中"糖锅"的个数
count1 = t1.count("糖锅")
print(f"t1元组中\"糖锅\"的个数是：{count1} 个")# 统计元组中的元素个数
count2 = len(t1)
print(f"t1中的元素个数是：{count2} 个")

示例结果：

t1元组中"菠萝蜜"的下标是：1
t1元组中"糖锅"的个数是：2 个
t1中的元素个数是：3 个

元组的遍历和列表类似，大家可以尝试做一下~

示例演示：

t1 = ("糖锅", "菠萝蜜", "糖锅")# while循环遍历
index = 0
while index < len(t1):print(f"元组中包含的元素有：{t1[index]}")index += 1print("-----------------------------------")# for循环遍历
for element in t1:print(f"元组中包含的元素有：{element}")

示例结果：

元组中包含的元素有：糖锅
元组中包含的元素有：菠萝蜜
元组中包含的元素有：糖锅
-----------------------------------
元组中包含的元素有：糖锅
元组中包含的元素有：菠萝蜜
元组中包含的元素有：糖锅

以上是元组中常用的几个操作。值得注意的是，元组中没有修改操作，这是因为元组是只读的， 这是元组和列表的区别，其它特性（有序、任意数量元素、允许重复元素）与列表一致。当然如果你要是在元组中嵌套了列表的话，此时元组中的列表中内容是可以变的。

2、字符串

没错，字符串也是数据容器，它可以存放任意数量的字符，它也是一个不可修改的数据容器。

2.1、字符串的常用操作

关于字符串的定义，大家已经烂熟于心了，这里就不多赘述了，我们来看一下字符串中常用操作吧。

2.1.1、index方法

示例演示：

# index方法
str = "糖锅喜欢笑哈哈~"
index = str.index("喜欢笑哈哈~")
print(f"在字符串中查找\"喜欢笑哈哈~\"，其起始下标为：{index}")

示例结果：

在字符串中查找"喜欢笑哈哈~"，其起始下标为：2

2.1.2、字符串替换

语法：

# 将字符串内的全部：字符串1，替换为字符串2
字符串.replace(字符串1, 字符串2)

注意：这里大家可能会想不是说字符串不可修改吗？这不就是修改操作？其实替换操作并不是修改字符串本身，而是得到一个新的字符串。

示例演示：

# replace方法
str = "糖锅喜欢赚钞票，糖锅喜欢吃火锅"
new_str = str.replace("喜欢", "超级喜欢")
print(f"将字符串\"{str}\"进行替换操作后得到的新字符串为\"{new_str}\"")

示例结果：

将字符串"糖锅喜欢赚钞票，糖锅喜欢吃火锅"进行替换操作后得到的新字符串为"糖锅超级喜欢赚钞票，糖锅超级喜欢吃火锅"

2.1.3、字符串分割

语法：

# 按照指定的分隔符分割字符串，将字符串划分为多个字符串，并存入列表对象中
字符串.split(分割符分割字符串)

注意：字符串本身并没有变化，是得到了一个新字符串。

示例演示：

# split方法
str = "Hello, 糖锅, 你好呀"
new_str = str.split(",")
print(f"字符串分割后得到：{new_str}")

示例结果：

字符串分割后得到：['Hello', ' 糖锅', ' 你好呀']

2.1.4、字符串规整操作

语法：

# 去除前后空格
字符串.strip()# 去除前后指定字符串
字符串.scrip(字符串)

示例演示：

# strip方法
str = "         糖锅你在干什么？     "
# 去除前后空格
new_str = str.strip()
print(f"字符串去除前后空格后：\"{new_str}\"")print("++++++++++++++++++++++++++++++++++")# 去除指定字符串
str = "我是糖锅，糖锅是我"
new_str = str.strip("我是")
print(f"去除指定字符串之后：\"{new_str}\"")

示例结果：

字符串去除前后空格后："糖锅你在干什么？"
++++++++++++++++++++++++++++++++++
去除指定字符串之后："糖锅，糖锅"

注意：去除指定字符串是大家是否有疑惑，其实我们传入的是“我是”，它的意思是：“我”和“是”都会被移除，是按照单个字符的。

2.1.5、统计字符串中某个字符串的个数

语法：

字符串.count("特定字符串")

示例演示：

# 统计字符串中特定字符串的个数
str = "糖锅是我，我是糖锅"
count = str.count("糖锅")
print(f"字符串中\"糖锅\"的个数是：{count} 个")

示例结果：

字符串中"糖锅"的个数是：2 个

2.1.6、统计字符串的长度

语法：

len(字符串)

示例演示：

str = "123456789"
num = len(str)
print(f"字符串的长度为：{num}")

示例结果：

字符串的长度为：9

以上就是字符串的一些常用操作，大家还可以试一下字符串的遍历，和我们之前列表和元组的遍历类似。

2.2、字符串比较

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

示例演示：

# abc和abz比较
print(f"\"abc\"小于\"abz\"的结果为：{'abc' < 'abz'}")# a和ab比较
print(f"\"a\"小于\"ab\"的结果为：{'a' < 'ab'}")

示例结果：

"abc"小于"abz"的结果为：True
"a"小于"ab"的结果为：True

3、序列切片

在介绍字典和元组之前我们先来了解一下序列切片操作。我们之前学习了列表、元组和字符串，它们就属于序列，所谓切片就是从一个序列中取出一个子序列。

3.1、切片语法

# 从序列中，从指定的位置开始，依次取出元素，知道结束位置，然后得到一个新的序列
序列[起始下标: 结束下标: 步长]
# 起始下标可以留空，表示从头开始
# 结束下标也可以留空，表示到尾结束
# 步长表示取出元素的间隔，如步长为1，一个一个取元素， 步长为n表示每次跳过n-1个元素，注意步长可以是负数，步长默认为1

注意：切片不会影响序列本身，此操作会得到一个新的序列。

示例演示：

# 对list进行切片，从1开始，到3结束，步长为1
list1 = [1, 2, 3, 4, 5, 6]
res1 = list1[1: 3]
print(f"list1列表切片结果为：{res1}")# 对tuple进行切片，从头开始到尾结束，步长为3
tuple1 = (1, 2, 3, 4, 5, 6, 7)
res2 = tuple1[::3]
print(f"tuple1元组切片结果为：{res2}")# 对字符串进行切片，从头开始，到4结束，步长为1
str1 = "12345678"
res3 = str1[:4]
print(f"str1切片结果为：{res3}")# 对字符串进行切片，从头开始，到尾结束，步长为-1
str2 = "1234567"
res4 = str2[::-1]
print(f"str2切片结果为：{res4}")# 对列表进行切片，从3开始，到1结束，步长为-1
list2 = [1, 2, 3, 4, 5]
res5 = list2[3: 1: -1]
print(f"list2切片结果为：{res5}")# 对元组进行切片，从头开始，到尾结束，步长为-3
tuple2 = (1, 2, 3, 4, 5, 6, 7, 8, 9)
res6 = tuple2[::-3]
print(f"tuple2切片结果为：{res6}")

示例结果：

list1列表切片结果为：[2, 3]
tuple1元组切片结果为：(1, 4, 7)
str1切片结果为：1234
str2切片结果为：7654321
list2切片结果为：[4, 3]
tuple2切片结果为：(9, 6, 3)

4、集合

我们前面学习的列表、元组和字符串它们都是支持重复元素的，试想一下如果我们需要对内容进行去重操作，是不是有些不方便，这里我们引入集合，集合它不支持元素的重复，内容是无序的。

4.1、语法

# 定义集合字面量
{元素, 元素, ..., 元素}# 定义集合变量
变量名称 = {元素, 元素, ...， 元素}# 定义空集合
变量名称 = set()

示例演示：

# 定义集合
set1 = {"糖锅", "草莓", "葡萄", "糖锅"}# 定义空集合
set2 = set()print(f"set1集合的类型是：{type(set1)}, 它的内容是：{set1}")
print(f"set2集合的类型是：{type(set2)}, 它的内容是：{set2}")

示例结果：

set1集合的类型是：<class 'set'>, 它的内容是：{'葡萄', '草莓', '糖锅'}
set2集合的类型是：<class 'set'>, 它的内容是：set()

4.2、集合的常用操作

因为集合是无序的，所以集合不支持下标索引访问，但是它和列表一样，支持被修改。

4.2.1、添加新元素

语法：

# 将指定元素添加到集合内
集合.add(元素)

示例演示：

set = {"酸角汁", "红毛丹", "酸菜猪脚火锅"}# add方法
set.add("酸角汁")
set.add("米浆粑粑")
print(f"添加元素后的集合内容为：{set}")

示例结果：

添加元素后的集合内容为：{'米浆粑粑', '酸角汁', '红毛丹', '酸菜猪脚火锅'}

4.2.2、移除元素

语法：

# 将指定元素从集合中移除
集合.remove(“元素)

示例演示：

set = {"酸角汁", "红毛丹", "酸菜猪脚火锅"}# remove方法
set.remove("酸菜猪脚火锅")
print(f"集合移除\"酸菜猪脚火锅\"后的内同是：{set}")

示例结果：

集合移除"酸菜猪脚火锅"后的内同是：{'红毛丹', '酸角汁'}

4.2.3、从集合中随机取出一个元素

语法：

集合.pop()

示例演示：

# pop方法
element = set.pop()
print(f"从集合中随机取出一个元素是：\"{element}\"")
print(f"取出元素后，集合的内容为：{set}")

示例结果：

从集合中随机取出一个元素是："红毛丹"
取出元素后，集合的内容为：{'酸菜猪脚火锅', '酸角汁'}

4.2.4、清空集合

语法：

集合.clear()

示例演示：

# clear方法
set.clear()
print(f"集合被清空了，此时集合中没有内容：{set}")

示例结果：

集合被清空了，此时集合中没有内容：set()

4.2.5、取两个集合的差集

语法：

# 取出集合1和集合2的差集，即集合1有而集合2没有的元素
集合1.difference(集合2)

示例演示：

# difference方法
set1 = {"子弟薯片", "酸角汁", "老街饵丝"}
set2 = {"酸角汁", "红毛丹"}set3 = set1.difference(set2)
print(f"集合set1和集合set2的差集是：{set3}")

示例结果：

集合set1和集合set2的差集是：{'子弟薯片', '老街饵丝'}

4.2.6、消除两个集合的差集

语法：

# 对比集合1和集合2，在集合1中，删除和集合2相同的元素
# 集合1变化，集合2不变
集合1.difference_update(集合2)

示例演示：

# difference_update方法
set1 = {"子弟薯片", "酸角汁", "老街饵丝"}
set2 = {"酸角汁", "红毛丹"}set1.difference_update(set2)
print(f"此时集合set1的内容是：{set1}")
print(f"此时集合set2的内容是：{set2}")

示例结果：

此时集合set1的内容是：{'子弟薯片', '老街饵丝'}
此时集合set2的内容是：{'红毛丹', '酸角汁'}

4.2.7、合并两个集合

语法：

集合1.union(集合2)

示例演示：

# union方法
set1 = {"子弟薯片", "酸角汁", "老街饵丝"}
set2 = {"酸角汁", "红毛丹"}set3 = set1.union(set2)
print(f"合并两个集合的结果为：{set3}")

示例结果：

合并两个集合的结果为：{'酸角汁', '子弟薯片', '老街饵丝', '红毛丹'}

4.2.8、统计集合中元素的数量

语法：

len(集合)

示例演示：

set = {"酸角汁", "红毛丹", "酸菜猪脚火锅", "酸角汁"}# len方法
num = len(set)
print(f"集合中的元素的个数为：{num} 个")

示例结果：

集合中的元素的个数为：3 个

注意：不要看集合中写了四个长度就是四，别忘记集合可是会去重的噢~

4.2.9、集合的遍历

示例演示：

set = {"酸角汁", "红毛丹", "酸菜猪脚火锅"}# for循环遍历集合
for element in set:print(f"集合中的元素有：{element}")

示例结果：

集合中的元素有：红毛丹
集合中的元素有：酸角汁
集合中的元素有：酸菜猪脚火锅

因为集合不支持下标索引，所以不能使用while循环。

5、字典

5.1、字典的定义

语法：

# 定义一个字典字面量
{key: value, key:value, ..., key: value}# 定义字典变量
字典变量名 = {key: value, key:value, ..., key: value}# 定义空字典
字典变量 = {}
字典变量 = dict()

示例演示：

# 定义字典
dict1 = {"糖锅": 23, "冰红茶": 4.5, "糖果": 666}# 定义空集合
dict2 = {}
dict3 = dict()print(f"dict1的内容是：{dict1}, 它的类型是：{type(dict1)}")
print(f"dict1的内容是：{dict2}, 它的类型是：{type(dict2)}")
print(f"dict1的内容是：{dict3}, 它的类型是：{type(dict3)}")# 定义重复key的字典
dict4 = {"糖锅": 23, "糖锅": 23}
print(f"重复key字典内容是：{dict4}")# 基于key获取value
dict5 = {"A": 1, "B": 2, "C": 3}
value = dict5["A"]
print(f"通过key获取value：{value}")# 定义嵌套字典
dict6 = {"糖锅": {"年龄": 23,"身高": 189},"糖果": {"年龄": 22,"身高": 162}
}# 从嵌套字典中获取信息
# 获取dict6中糖果的身高
h = dict6["糖果"]["身高"]
print(f"糖果的身高是：{h}cm")

示例结果：

dict1的内容是：{'糖锅': 23, '冰红茶': 4.5, '糖果': 666}, 它的类型是：<class 'dict'>
dict1的内容是：{}, 它的类型是：<class 'dict'>
dict1的内容是：{}, 它的类型是：<class 'dict'>
重复key字典内容是：{'糖锅': 23}
通过key获取value：1
糖果的身高是：162cm

5.2、字典的常用操作

5.2.1、新增元素

语法：

字典[key] = value

示例演示：

# 新增元素
dict = {"木瓜凉水": 2,"玉米汁": 3
}dict["酸角汁"] = 2
print(f"新增元素后的字典内容为：{dict}")

示例结果：

新增元素后的字典内容为：{'木瓜凉水': 2, '玉米汁': 3, '酸角汁': 2}

5.2.2、更新元素

语法：

字典[key] = value

示例演示：

# 更新元素
dict = {"木瓜凉水": 2,"玉米汁": 3,"酸角汁": 2
}dict["酸角汁"] = 2.5
print(f"修改元素后的字典内容为：{dict}")

示例结果：

修改元素后的字典内容为：{'木瓜凉水': 2, '玉米汁': 3, '酸角汁': 2.5}

5.2.3、删除元素

语法：

字典.pop(key)

示例演示：

# 删除元素
dict = {"木瓜凉水": 2,"玉米汁": 3,"酸角汁": 2
}dict.pop("玉米汁")
print(f"删除元素后字典的内容是：{dict}")

示例结果：

删除元素后字典的内容是：{'木瓜凉水': 2, '酸角汁': 2}

5.2.4、清空字典

语法：

字典.clear()

示例演示：

# 清空字典
dict = {"木瓜凉水": 2,"玉米汁": 3,"酸角汁": 2
}dict.clear()
print(f"字典被清空了：{dict}")

示例结果：

字典被清空了：{}

5.2.5、获取全部的key（通过此操作可以实现遍历字典）

语法：

字典.keys()

示例演示：

# 获取全部的key
dict = {"木瓜凉水": 2,"玉米汁": 3,"酸角汁": 2
}keys = dict.keys()
print(f"字典中的全部key为：{keys}")# for循环遍历字典（方法一：获取全部key来实现遍历）
for key in keys:print(f"字典的key是：{key}, value是：{dict[key]}")print("------------------------------------")# for循环遍历字典（方法二）
for key in dict:print(f"字典的key是：{key}, value是：{dict[key]}")

示例结果：

字典中的全部key为：dict_keys(['木瓜凉水', '玉米汁', '酸角汁'])
字典的key是：木瓜凉水, value是：2
字典的key是：玉米汁, value是：3
字典的key是：酸角汁, value是：2
------------------------------------
字典的key是：木瓜凉水, value是：2
字典的key是：玉米汁, value是：3
字典的key是：酸角汁, value是：2

5.2.6、统计字典的元素数量

语法：

len(字典)

示例演示：

# 统计字典元素数量
dict = {"木瓜凉水": 2,"玉米汁": 3,"酸角汁": 2
}num = len(dict)
print(f"字典的元素数量为：{num} 个")

示例结果：

字典的元素数量为：3 个

6、数据容器的通用操作

6.1、len()、max()、min()

示例演示：

list = [1, 2, 3, 4, 5]
tuple = (1, 2, 3, 4)
str = "123456789"
set = {1, 2, 3, 4, 5, 6, 7}
dict = {"key1": 1, "key2": 2, "key3": 3}print(f"列表中的元素个数是：{len(list)} 个")
print(f"元组中的元素个数是：{len(tuple)} 个")
print(f"字符串中的元素个数是：{len(str)} 个")
print(f"集合中的元素个数是：{len(set)} 个")
print(f"字典中的元素个数是：{len(dict)} 个")print("===================================================")print(f"列表中的元素最大值是：{max(list)}")
print(f"元组中的元素最大值是：{max(tuple)}")
print(f"字符串中的元素最大值是：{max(str)}")
print(f"集合中的元素最大值是：{max(set)}")
print(f"字典中的元素最大值是：{max(dict)}")print("===================================================")print(f"列表中的元素最小值是：{min(list)}")
print(f"元组中的元素最小值是：{min(tuple)}")
print(f"字符串中的元素最小值是：{min(str)}")
print(f"集合中的元素最小值是：{min(set)}")
print(f"字典中的元素最小值是：{min(dict)}")

示例结果：

列表中的元素个数是：5 个
元组中的元素个数是：4 个
字符串中的元素个数是：9 个
集合中的元素个数是：7 个
字典中的元素个数是：3 个
===================================================
列表中的元素最大值是：5
元组中的元素最大值是：4
字符串中的元素最大值是：9
集合中的元素最大值是：7
字典中的元素最大值是：key3
===================================================
列表中的元素最小值是：1
元组中的元素最小值是：1
字符串中的元素最小值是：1
集合中的元素最小值是：1
字典中的元素最小值是：key1

6.2、类型转化

6.2.1、list(容器)

将给定的容器转换为列表

示例演示：

list1 = [1, 2, 3, 4, 5]
tuple = (1, 2, 3, 4)
str = "123456789"
set = {1, 2, 3, 4, 5, 6, 7}
dict = {"key1": 1, "key2": 2, "key3": 3}print(f"列表转列表的结果是：{list(list1)}")
print(f"元组转列表的结果是：{list(tuple)}")
print(f"字符串转列表的结果是：{list(str)}")
print(f"集合转列表的结果是：{list(set)}")
print(f"字典转列表的结果是：{list(dict)}")

示例结果：

列表转列表的结果是：[1, 2, 3, 4, 5]
元组转列表的结果是：[1, 2, 3, 4]
字符串转列表的结果是：['1', '2', '3', '4', '5', '6', '7', '8', '9']
集合转列表的结果是：[1, 2, 3, 4, 5, 6, 7]
字典转列表的结果是：['key1', 'key2', 'key3']

6.2.2、str(容器)

将给定容器转换为字符串

示例演示：

list1 = [1, 2, 3, 4, 5]
tuple1 = (1, 2, 3, 4)
str1 = "123456789"
set = {1, 2, 3, 4, 5, 6, 7}
dict = {"key1": 1, "key2": 2, "key3": 3}print(f"列表转字符串的结果是：{str(list1)}")
print(f"元组转字符串的结果是：{str(tuple1)}")
print(f"字符串转字符串结果是：{str(str1)}")
print(f"集合转字符串的结果是：{str(set)}")
print(f"字典转字符串的结果是：{str(dict)}")

示例结果：

列表转字符串的结果是：[1, 2, 3, 4, 5]
元组转字符串的结果是：(1, 2, 3, 4)
字符串转字符串结果是：123456789
集合转字符串的结果是：{1, 2, 3, 4, 5, 6, 7}
字典转字符串的结果是：{'key1': 1, 'key2': 2, 'key3': 3}

6.2.3、tuple(容器)

将给定容器转换为元组

示例演示：

list1 = [1, 2, 3, 4, 5]
tuple1 = (1, 2, 3, 4)
str = "123456789"
set = {1, 2, 3, 4, 5, 6, 7}
dict = {"key1": 1, "key2": 2, "key3": 3}print(f"列表转元组的结果是：{tuple(list1)}")
print(f"元组转元组的结果是：{tuple(tuple1)}")
print(f"字符串转元组的结果是：{tuple(str)}")
print(f"集合转元组的结果是：{tuple(set)}")
print(f"字典转元组的结果是：{tuple(dict)}")

示例结果：

列表转元组的结果是：(1, 2, 3, 4, 5)
元组转元组的结果是：(1, 2, 3, 4)
字符串转元组的结果是：('1', '2', '3', '4', '5', '6', '7', '8', '9')
集合转元组的结果是：(1, 2, 3, 4, 5, 6, 7)
字典转元组的结果是：('key1', 'key2', 'key3')

6.2.4、set(容器)

将给定容器转换为集合

示例演示：

list1 = [1, 2, 3, 4, 5]
tuple1 = (1, 2, 3, 4)
str1 = "123456789"
set1 = {1, 2, 3, 4, 5, 6, 7}
dict = {"key1": 1, "key2": 2, "key3": 3}print(f"列表转集合的结果是：{set(list1)}")
print(f"元组转集合的结果是：{set(tuple1)}")
print(f"字符串转集合结果是：{set(str1)}")
print(f"集合转集合的结果是：{set(set1)}")
print(f"字典转集合的结果是：{set(dict)}")

示例结果：

列表转集合的结果是：{1, 2, 3, 4, 5}
元组转集合的结果是：{1, 2, 3, 4}
字符串转集合结果是：{'7', '1', '5', '6', '9', '8', '4', '2', '3'}
集合转集合的结果是：{1, 2, 3, 4, 5, 6, 7}
字典转集合的结果是：{'key1', 'key3', 'key2'}

6.3、容器通用排序功能

语法：

sorted(容器, [reverse = True]) # 加上第二个参数就是降序排序，默认升序

示例演示：

list1 = [9, 2, 7, 4, 5]
tuple1 = (1, 45, 3, 0)
str1 = "1563284"
set1 = {1, 2, 3, 4, 5, 6, 7}
dict = {"key1": 1, "key3": 2, "key2": 3}print(f"列表对象的排序结果：{sorted(list1)}")
print(f"元组对象的排序结果：{sorted(tuple1)}")
print(f"字符串对象的排序结果：{sorted(str1)}")
print(f"集合的排序结果：{sorted(set1)}")
print(f"字典对象的排序结果：{sorted(dict)}")

示例结果：

列表对象的排序结果：[2, 4, 5, 7, 9]
元组对象的排序结果：[0, 1, 3, 45]
字符串对象的排序结果：['1', '2', '3', '4', '5', '6', '8']
集合的排序结果：[1, 2, 3, 4, 5, 6, 7]
字典对象的排序结果：['key1', 'key2', 'key3']

山水有相逢，各位好汉！明日见~