数据容器入门

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

数据容器根据特点的不同，如：

• 是否支持重复元素
• 是否可以修改
• 是否有序，等

分为5类，分别是：

1. 列表（list）
2. 元组（tuple）
3. 字符串（str）
4. 集合（set）
5. 字典（dict）

数据容器：list（列表）

列表的定义

# 定义一个列表 listmy_list = ["itheima", "itcast", "python"]  
print(my_list)  
print(type(my_list))  
  
my_list = ["itheima", 666, True]  
print(my_list)  
print(type(my_list))

"""
列表内的每一个数据，称之为元素
	以 [] 作为标识
	列表内每一个元素之间用, 逗号隔开

注意：列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套
"""

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

列表的下标索引

下标索引： 如图，列表中的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次递增。 我们只需要按照下标索引，即可取得对应位置的元素。

# 通过下标索引取出对应位置的数据  
my_list = ["Tom", "Lily", "Rose"]  
# 列表[下标索引], 从前向后从0开始，每次+1，  从后向前从-1开始，每次-1  
print(my_list[0])  
print(my_list[1])  
print(my_list[2])  
# 错误示范；通过下标索引取数据，一定不要超出范围  
print(my_list[3])

或者，可以反向索引，也就是从后向前：从-1开始，依次递减（-1、-2、-3......） 如图，从后向前，下标索引为：-1、-2、-3，依次递减。

# 通过下标索引取出数据（倒序取出）  
my_list = ["Tom", "Lily", "Rose"]
print(my_list[-1])  
print(my_list[-2])  
print(my_list[-3])

如果列表是嵌套的列表，同样支持下标索引 如图，下标就有2个层级了。

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

列表的常用操作

函数与方法

在 Python 中，如果将函数定义为 class（类）的成员，那么函数会称之为：方法

# 函数
def add(x, y):
	return x + y

# 方法
class Student:
	def add(self, x, y):
	return x + y

方法和函数功能一样， 有传入参数，有返回值，只是方法的使用格式不同：

# 函数的使用
num = add(1, 2)

# 方法的使用
student = Student()
num = student.add(1, 2)

列表的查询功能（方法）

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

mylist = ["itcast", "itheima", "python"]  
# 1.1 查找某元素在列表内的下标索引  
index = mylist.index("itheima")  
print(f"itheima在列表中的下标索引值是：{index}")  
# 1.2如果被查找的元素不存在，会报错  
index = mylist.index("hello")  
print(f"hello在列表中的下标索引值是：{index}")

列表的修改功能（方法）

修改特定位置（索引）的元素值

语法：列表[下标] = 值 可以使用如上语法，直接对指定下标（正向、反向下标均可）的值进行：重新赋值（修改）

mylist = ["itcast", "itheima", "python"]  
# 2. 修改特定下标索引的值  
mylist[0] = "传智教育"  
print(f"列表被修改元素值后，结果是：{mylist}")

插入元素

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

mylist = ["itcast", "itheima", "python"]  
# 3. 在指定下标位置插入新元素  
mylist.insert(1, "best")  
print(f"列表插入元素后，结果是：{mylist}")

追加元素

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

mylist = ["itcast", "itheima", "python"]  
# 4. 在列表的尾部追加```单个```新元素  
mylist.append("黑马程序员")  
print(f"列表在追加了元素后，结果是：{mylist}")

追加元素方式2

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

mylist = ["itcast", "itheima", "python"]  
# 5. 在列表的尾部追加```一批```新元素  
mylist2 = [1, 2, 3]  
mylist.extend(mylist2)  
print(f"列表在追加了一个新的列表后，结果是：{mylist}")

删除元素

语法1：del 列表[下标] 语法2：列表.pop(下标)

mylist = ["itcast", "itheima", "python"]  
# 6.1 方式1：del 列表[下标]  
del mylist[2]  
print(f"列表删除元素后结果是：{mylist}")  
# 6.2 方式2：列表.pop(下标)  
mylist = ["itcast", "itheima", "python"]  
element = mylist.pop(2)  
print(f"通过pop方法取出元素后列表内容：{mylist}, 取出的元素是：{element}")

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

语法：列表.remove(元素)

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

清空列表内容

语法：列表.clear()

mylist = ["itcast", "itheima", "python"]  
# 8. 清空列表  
mylist.clear()  
print(f"列表被清空了，结果是：{mylist}")

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

语法：列表.count(元素)

# 9. 统计列表内某元素的数量  
mylist = ["itcast", "itheima", "itcast", "itheima", "python"]  
count = mylist.count("itheima")  
print(f"列表中itheima的数量是：{count}")

统计列表内，有多少元素

语法：len(列表)

# 10. 统计列表中全部的元素数量  
mylist = ["itcast", "itheima", "itcast", "itheima", "python"]  
count = len(mylist)  
print(f"列表的元素数量总共有：{count}个")

列表的特点

经过上述对列表的学习，可以总结出列表有如下特点：

• 可以容纳多个元素（上限为2**63-1、9223372036854775807个）
• 可以容纳不同类型的元素（混装）
• 数据是有序存储的（有下标序号）
• 允许重复数据存在
• 可以修改（增加或删除元素等）

list（列表）的遍历

# 定义列表
mylist = ["itcast", "itheima", "python"]  

# while 遍历
index = 0
while index < len(mylist):
	elements = mylist[index]
	print(elements)
	index += 1

# for 遍历
for i in mylist:
	print(i)

while 循环和 for 循环的对比 while 循环和 for 循环，都是循环语句，但细节不同：

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

数据容器：tuple（元组）

元组一旦定义完成，就不可修改

元组的定义

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

# 定义元组  
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的内容是：{t4}")  
# 元组的嵌套  
t5 = ( (1, 2, 3), (4, 5, 6) )  
print(f"t5的类型是：{type(t5)}, 内容是：{t5}")

注意：元组只有一个数据，这个数据后面要添加逗号。

元组的操作

# 元组的操作：index查找方法  
t6 = ("传智教育", "黑马程序员", "Python")  
index = t6.index("黑马程序员")  
print(f"在元组t6中查找黑马程序员，的下标是：{index}")  
# 元组的操作：count统计方法  
t7 = ("传智教育", "黑马程序员", "黑马程序员", "黑马程序员", "Python")  
num = t7.count("黑马程序员")  
print(f"在元组t7中统计黑马程序员的数量有：{num}个")  
# 元组的操作：len函数统计元组元素数量  
t8 = ("传智教育", "黑马程序员", "黑马程序员", "黑马程序员", "Python")  
num = len(t8)  
print(f"t8元组中的元素有：{num}个")

• 不可以修改元组的内容，否则会直接报错
• 可以修改元组内的 list 的内容（修改元素、增加、删除、反转等）
• 不可以替换 list 为其它 list 或其它类型

元组的遍历

# 元组的遍历：while  
index = 0  
while index < len(t8):  
    print(f"元组的元素有：{t8[index]}")  
    # 至关重要  
    index += 1  
  
# 元组的遍历：for  
for element in t8:  
    print(f"2元组的元素有：{element}")

元组的特点

• 可以容纳多个数据
• 可以容纳不同类型的数据（混装）
• 数据是有序存储的（下标索引）
• 允许重复数据存在
• 不可以修改（增加或删除元素等）
• 支持for循环

数据容器：str（字符串）

字符串是字符的容器，一个字符串可以存放任意数量的字符。 如，字符串："itheima" 和其它容器如：列表、元组一样，字符串也可以通过下标进行访问。

• 从前向后，下标从0开始
• 从后向前，下标从-1开始

my_str = "itheima and itcast"  
# 通过下标索引取值  
value = my_str[2]  
value2 = my_str[-16]  
print(f"从字符串{my_str}取下标为2的元素，。值是：{value},取下标为-16的元素。值是：{value2}")

同元组一样，字符串是一个：无法修改的数据容器。

字符串的常用操作

# index方法  
value = my_str.index("and")  
print(f"在字符串{my_str}中查找and，其起始下标是：{value}")  
  
# replace方法  
new_my_str = my_str.replace("it", "程序")  
print(f"将字符串{my_str}，进行替换后得到：{new_my_str}")  
  
# split方法  
my_str = "hello python itheima itcast"  
my_str_list = my_str.split(" ")  
print(f"将字符串{my_str}进行split切分后得到：{my_str_list}, 类型是：{type(my_str_list)}")  
  
# strip方法  
my_str = "  itheima and itcast  "  
new_my_str = my_str.strip() # 不传入参数，去除首尾空格  
print(f"字符串{my_str}被strip后，结果：{new_my_str}")  
  
my_str = "12itheima and itcast21"  
new_my_str = my_str.strip("12")  
print(f"字符串{my_str}被strip('12')后，结果：{new_my_str}")  
  
# 统计字符串中某字符串的出现次数, count  
my_str = "itheima and itcast"  
count = my_str.count("it")  
print(f"字符串{my_str}中it出现的次数是：{count}")  
# 统计字符串的长度, len()  
num = len(my_str)  
print(f"字符串{my_str}的长度是：{num}")

字符串的遍历

# where
my_str = "布丁困困"
index = 0
while index < len(my_str):
	print(my_str[index])
	index += 1

# for
my_str = "布丁困困"
for i in my_str:
	print(i)

字符串的特点

• 只可以存储字符串
• 长度任意（取决于内存大小）
• 支持下标索引
• 允许重复字符串存在
• 不可以修改（增加或删除元素等）
• 支持for循环

数据容器（序列）的切片

序列

序列是指：内容连续、有序，可使用下标索引的一类数据容器 列表、元组、字符串，均可以可以视为序列。

如图，序列的典型特征就是：有序并可用下标索引，字符串、元组、列表均满足这个要求

序列的切片

序列支持切片，即：列表、元组、字符串，均支持进行切片操作 切片：从一个序列中，取出一个子序列。 语法：序列[起始下标:结束下标:步长]

表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：

• 起始下标表示从何处开始，可以留空，留空视作从头开始
• 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
• 步长表示，依次取元素的间隔
  • 步长1表示，一个个取元素
  • 步长2表示，每次跳过1个元素取
  • 步长N表示，每次跳过N-1个元素取
  • 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）

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

# 对list进行切片，从1开始，4结束，步长1  
my_list = [0, 1, 2, 3, 4, 5, 6]  
result1 = my_list[1:4]      # 步长默认是1，所以可以省略不写  
print(f"结果1：{result1}")  
  
# 对tuple进行切片，从头开始，到最后结束，步长1  
my_tuple = (0, 1, 2, 3, 4, 5, 6)  
result2 = my_tuple[:]     # 起始和结束不写表示从头到尾，步长为1可以省略  
print(f"结果2：{result2}")  
  
# 对str进行切片，从头开始，到最后结束，步长2  
my_str = "01234567"  
result3 = my_str[::2]  
print(f"结果3：{result3}")  
  
  
# 对str进行切片，从头开始，到最后结束，步长-1  
my_str = "01234567"  
result4 = my_str[::-1]          # 等同于将序列反转了  
print(f"结果4：{result4}")  
  
  
# 对列表进行切片，从3开始，到1结束，步长-1  
my_list = [0, 1, 2, 3, 4, 5, 6]  
result5 = my_list[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}")

数据容器：set（集合）

集合最主要的特点就是：不支持元素的重复（自带去重功能）、并且内容无序。

# 定义集合  
my_set = {"传智教育", "黑马程序员", "itheima", "传智教育", "黑马程序员", "itheima", "传智教育", "黑马程序员", "itheima"}  
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 = {"传智教育", "黑马程序员", "itheima", "传智教育", "黑马程序员", "itheima", "传智教育", "黑马程序员", "itheima"}  
# 添加新元素  
my_set.add("Python")  
my_set.add("传智教育")      #  
print(f"my_set添加元素后结果是：{my_set}")

移除元素

语法：集合.remove(元素)

my_set = {"传智教育", "黑马程序员", "itheima", "传智教育", "黑马程序员", "itheima", "传智教育", "黑马程序员", "itheima"}  
# 移除元素  
my_set.remove("黑马程序员")  
print(f"my_set移除黑马程序员后，结果是：{my_set}")

从集合中随机取出元素

语法：集合.pop() 结果：会得到一个元素的结果。同时集合本身被修改，元素被移除。

my_set = {"传智教育", "黑马程序员", "itheima"}  
element = my_set.pop()  
print(f"集合被取出元素是：{element}, 取出元素后：{my_set}")

清空集合

语法：集合.clear()

my_set = {"传智教育", "黑马程序员", "itheima"}  
# 清空集合, clear  
my_set.clear()  
print(f"集合被清空啦，结果是：{my_set}")

取出2个集合的差集

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

# 取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个集合的差集

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

# 消除2个集合的差集  
set1 = {1, 2, 3}  
set2 = {1, 5, 6}  
set1.difference_update(set2)  
print(f"消除差集后，集合1结果：{set1}")  
print(f"消除差集后，集合2结果：{set2}")

2个集合合并

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

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

查看集合的元素数量

语法：len(集合) 功能：统计集合内有多少元素

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

集合的遍历

# 集合的遍历  
# 集合不支持下标索引，不能用while循环  
# 可以用for循环  
set1 = {1, 2, 3, 4, 5}  
for element in set1:  
    print(f"集合的元素有：{element}")

注意：集合不支持下标索引，所以也就不支持使用while循环。

集合的特点

• 可以容纳多个数据
• 可以容纳不同类型的数据（混装）
• 数据是无序存储的（不支持下标索引）
• 不允许重复数据存在
• 可以修改（增加或删除元素等）
• 支持for循环

数据容器：dict（字典、映射）

# 定义字典  
my_dict1 = {"王力鸿": 99, "周杰轮": 88, "林俊节": 77}  
# 定义空字典  
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 = {"王力鸿": 99, "王力鸿": 88, "林俊节": 77}  
print(f"重复key的字典的内容是：{my_dict1}")

• 使用{}存储原始，每一个元素是一个键值对
• 每一个键值对包含 Key 和 Value（用冒号分隔）
• 键值对之间使用逗号分隔
• Key 和 Value 可以是任意类型的数据（key不可为字典）
• Key 不可重复，重复会对原有数据覆盖

# 从字典中基于Key获取Value  
my_dict1 = {"王力鸿": 99, "周杰轮": 88, "林俊节": 77}  
score = my_dict1["王力鸿"]  
print(f"王力鸿的考试分数是：{score}")  
score = my_dict1["周杰轮"]  
print(f"周杰轮的考试分数是：{score}")  
# 定义嵌套字典  
stu_score_dict = {  
    "王力鸿": {  
        "语文": 77,  
        "数学": 66,  
        "英语": 33  
    }, "周杰轮": {  
        "语文": 88,  
        "数学": 86,  
        "英语": 55  
    }, "林俊节": {  
        "语文": 99,  
        "数学": 96,  
        "英语": 66  
    }  
}  
print(f"学生的考试信息是：{stu_score_dict}")  
  
# 从嵌套字典中获取数据  
# 看一下周杰轮的语文信息  
score = stu_score_dict["周杰轮"]["语文"]  
print(f"周杰轮的语文分数是：{score}")  
score = stu_score_dict["林俊节"]["英语"]  
print(f"林俊节的英语分数是：{score}")

字典的常用操作

my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}  
# 新增元素  
my_dict["张信哲"] = 66  
print(f"字典经过新增元素后，结果：{my_dict}")  
# 更新元素  
my_dict["周杰轮"] = 33  
print(f"字典经过更新后，结果：{my_dict}")  
# 删除元素  
score = my_dict.pop("周杰轮")  
print(f"字典中被移除了一个元素，结果：{my_dict}, 周杰轮的考试分数是：{score}")  
  
# 清空元素, clear  
my_dict.clear()  
print(f"字典被清空了，内容是：{my_dict}")  
  
# 获取全部的key  
my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}  
keys = my_dict.keys()  
print(f"字典的全部keys是：{keys}")  
# 遍历字典  
# 方式1：通过获取到全部的key来完成遍历  
for key in keys:  
    print(f"字典的key是:{key}")  
    print(f"字典的value是：{my_dict[key]}")  
  
# 方式2：直接对字典进行for循环，每一次循环都是直接得到key  
for key in my_dict:  
    print(f"2字典的key是:{key}")  
    print(f"2字典的value是：{my_dict[key]}")  
  
# 统计字典内的元素数量, len()函数  
num = len(my_dict)  
print(f"字典中的元素数量有：{num}个")

字典的特点

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

数据容器分类

数据容器可以从以下视角进行简单的分类：

• 是否支持下标索引
  • 支持：列表、元组、字符串 - 序列类型
  • 不支持：集合、字典 - 非序列类型
• 是否支持重复元素：
  • 支持：列表、元组、字符串 - 序列类型
  • 不支持：集合、字典 - 非序列类型
• 是否可以修改
  • 支持：列表、集合、字典
  • 不支持：元组、字符串

数据容器特点对比

数据容器的通用操作

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(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(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(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(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(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(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 = [3, 1, 2, 5, 4]  
my_tuple = (3, 1, 2, 5, 4)  
my_str = "bdcefga"  
my_set = {3, 1, 2, 5, 4}  
my_dict = {"key3": 1, "key1": 2, "key2": 3, "key5": 4, "key4": 5}  
  
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(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)}")

字符串大小比较

在程序中，字符串所用的所有字符如：

• 大小写英文单词
• 数字
• 特殊符号 !、\、|、@、#、空格等 都有其对应的ASCII码表值

每一个字符都能对应上一个：数字的码值 字符串进行比较就是基于数字的码值大小进行比较的。

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