Python 5 数据容器

数据容器入门

Python中的数据容器：一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素

每一个元素，可以是任意类型的数据，如字符串、数字、布尔等

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

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

分为5类，分别是：

列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

列表的定义语法

列表内的每一个数据，称之为元素

• 以[]作为标识
• 列表内每一行之间用，用逗号隔开

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

Demo

"""
演示数据容器之：list列表
语法：[元素,元素......]
"""
#定义一个列表list
my_list = ["hello","world","python"]
print(my_list)
print(type(my_list))
mt_list = ["zhangsan",666,True]
print(my_list)
print(type(my_list))
# 定义一个嵌套的列表
my_list = [[1, 2, 3], [4, 5, 6]]
print(my_list)
print(type(my_list))

运行结果

['hello', 'world', 'python']
<class 'list'>
['hello', 'world', 'python']
<class 'list'>
[[1, 2, 3], [4, 5, 6]]
<class 'list'>

列表的下标索引

列表中的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次递增

我们只需要按照下标索引，即可取得对应位置的元素

或者，可以反向索引，也就是从后向前，从-1开始，依次递减（-1、-2、-3…..）

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

Demo

# 通过下标索引取出对应位置的数据
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])
# 通过下标索引取出数据（倒序取出）
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])
#取出嵌套列表的元素
my_list = [[1, 2, 3], [4, 5, 6]]
print(my_list[1][1])

运行结果

Tom
Lily
Rose
Rose
Lily
Tom
5

列表的常用操作方法

列表除了可以：定义、使用下标索引获取值以外，列表也提供了一系列功能

• 插入元素
• 删除元素
• 清空列表
• 修改元素
• 统计元素个数

这些功能我们都称之为：列表的方法

函数是一个封装的代码单元，可以提供特定功能

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

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

查找某元素的下标

功能：查找指定元素在列表的下标，如果找不到，报错ValueError

语法：列表.index(元素)

index就是列表对象（变量）内置的方法（函数）

插入元素

语法：列表.insert（下标，元素），在指定的下标位置，插入指定的元素

追加元素

语法：列表.append（下标，元素），将指定的元素，追加到列表的尾部

追加元素方式2

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

删除元素

语法1：del 列表[下标]

语法2：列表.pop(下标)

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

语法：列表.remove(元素)

清空列表内容

语法：列表.clear()

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

语法：列表.count(元素)

统计列表内，有多少元素

语法：len(列表)

可以得到一个int数字，表示列表内的元素数量

Demo1

"""
演示数据之：list列表的常用操作
"""
mylist = ["hello", "world", "python"]
# 1.1 查找某元素在列表内的下标索引
index = mylist.index("hello")
print(f"hello在列表中的下标索引值是：{index}")
# 1.2 如果被查找的元素不存在，会报错
# index = mylist.index("hi")
# print(f"hi在列表中的下标索引值是：{index}")
# 2. 修改特定下标索引的值
mylist[0] = "hi"
print(f"列表被修改元素值后，结果是：{mylist}")
# 3. 在指定下标位置插入新元素
mylist.insert(1,"best")
print(f"列表插入元素后，结果是：{mylist}")
# 4. 在列表的尾部追加新元素
mylist.append("张三")
print(f"列表在追加了元素后，结果是：{mylist}")
# 5. 在列表的尾部追加一批新元素
mylist2 = [1, 2, 3]
mylist.extend(mylist2)
print(f"列表在追加了一个新的列表后，结果是{mylist}")
# 6. 删除指定下标索引的元素
mylist = ["hello", "world", "python"]
# 6.1 方式1：del 列表[下标]
del mylist[2]
print(f"列表删除元素后结果是：{mylist}")
# 6.2 方式2：列表.pop(下标)
mylist = ["hello", "world", "python"]
element = mylist.pop(2)
print(f"通过pop方法取出元素后列表内容：{mylist}，取出的元素是{element}")
# 7. 删除某元素在列表中的第一个匹配项
mylist = ["hello", "world", "hello", "world", "python"]
mylist.remove("world")
print(f"通过remove方法移出元素后，列表的结果是：{mylist}")
# 8. 清空列表
mylist.clear()
print(f"列表被清空了，结果是：{mylist}")
# 9. 统计列表内某元素的数量
mylist = ["hello", "world", "hello", "world", "python"]
count = mylist.count("world")
print(f"列表中world的数量是：{count}")
# 10. 统计列表中全部的元素数量
mylist = ["hello", "world", "hello", "world", "python"]
count = len(mylist)
print(f"列表的元素数量总共有：{count}个")

运行结果

hello在列表中的下标索引值是：0
列表被修改元素值后，结果是：['hi', 'world', 'python']
列表插入元素后，结果是：['hi', 'best', 'world', 'python']
列表在追加了元素后，结果是：['hi', 'best', 'world', 'python', '张三']
列表在追加了一个新的列表后，结果是['hi', 'best', 'world', 'python', '张三', 1, 2, 3]
列表删除元素后结果是：['hello', 'world']
通过pop方法取出元素后列表内容：['hello', 'world']，取出的元素是python
通过remove方法移出元素后，列表的结果是：['hello', 'hello', 'world', 'python']
列表被清空了，结果是：[]
列表中world的数量是：2
列表的元素数量总共有：5个

列表的特点

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

Demo2

"""
演示List常用操作的课后练习
"""
# 1.定义这个列表，并用变量接收它，内容是：[21,25,21,23,22,20]
mylist = [21, 25, 21, 23, 22, 20]
# 2.追加一个数字31，到列表的尾部
mylist.append(31)
# 3.追加一个新列表[29, 33, 30]，到列表的尾部
mylist.extend([29, 33, 30])
# 4.取出第一个元素（应是21）
num1 = mylist[0]
print(f"从列表中取出来第一个元素，应该是21，实际上是：{num1}")
# 5.取出最后一个元素（应是30）
num2 = mylist[-1]
print(f"从列表中取出来最后一个元素，应该是30，实际上是：{num2}")
# 6.查找元素31，在列表中的下标位置
index = mylist.index(31)
print(f"元素31在列表的下标位置是：{index}")
print(f"最后列表的内容是：{mylist}")

运行结果

从列表中取出来第一个元素，应该是21，实际上是：21
从列表中取出来最后一个元素，应该是30，实际上是：30
元素31在列表的下标位置是：6
最后列表的内容是：[21, 25, 21, 23, 22, 20, 31, 29, 33, 30]

列表的循环遍历

列表的遍历-while循环

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

如何遍历列表的元素呢？-可以使用前面学过的while循环

如何在循环中取出列表的元素呢？-使用列表[下标]的方式取出

循环条件如何控制？

• 定义一个变量表示下标，从0开始
• 循环条件为 下标值<列表的元素数量

列表的循环-for循环

除了while循环外，Python中还有另外一种循环形式：for循环。

对比while，for循环更加适合对列表等数据容器进行遍历。

语法：

for 临时变量 in 数据容器：
	对临时变量进行处理

表示，从容器内，依次取出元素并赋值到临时变量上。

在每一次的循环中，我们可以对临时变量（元素）进行处理。

while循环和for循环的对比

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

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

Demo

"""
演示对list列表的循环，使用while和for循环2种方式
"""
def list_while_func():
    """
    使用while循环遍历列表的演示函数
    :return None
    """
    my_list = ["hello", "world", "Python"]
    # 循环控制变量通过下标索引来控制，默认0
    # 每一次循环将下标索引变量+1
    # 循环条件：下标索引变量 < 列表的元素数量
    # 定义一个变量用来标记列表的下标
    index = 0   #初始化为0
    while index < len(my_list):
        # 通过index变量取出对应下标的元素
        element = my_list[index]
        print(f"列表的元素：{element}")
        # 至关重要 将循环变量（index）每一次循环都+1
        index += 1

def list_for_func():
    """
    使用for循环遍历列表的演示函数
    :return: None
    """
    my_list = [1, 2, 3, 4, 5]
    # for 临时变量 in 数据容器：
    for element in my_list:
        print(f"列表的元素有：{element}")

list_while_func()
list_for_func()

运行结果

列表的元素：hello
列表的元素：world
列表的元素：Python
列表的元素有：1
列表的元素有：2
列表的元素有：3
列表的元素有：4
列表的元素有：5

元组的定义和操作

元组和列表一样，都是可以封装多个、不同类型的元素在内，但最大的不同点在于：元组一旦定义完成，就不可修改

所以，当我们需要在程序内封装数据，又不希望封装的数据被篡改，那么元组就非常合适了

定义元组

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

#定义元组字面量
(元素,元素,......,元素)
#定义元素变量
变量名称 = (元素,元素,......,元素)
#定义空元组
变量名称 =（）			#方式1
变量名称 = tuple()    	 #方式2

元组也支持嵌套：

# 定义一个嵌套元组
t1 = ( (1, 2, 3), (4, 5, 6) )
print(t1[0][0])	#结果：1

注意事项：

# 定义3个元素的元组
t1 = (1, 'Hello', True)
# 定义1个元素的元组
t2 = ('Hello', )	# 注意，必须带有逗号，否则不是元组类型

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

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

# 根据下标（索引）取出数据
t1 = (1, 2, 'hello')
print(t1[2]) # 结果：'hello'

# 根据index()，查找特定元素的第一个匹配项
t1 = (1, 2, 'hello', 3, 4, 'hello')
print(t1.index('hello'))	# 结果：2

# 统计某个数据在元组内出现的次数
t1 = (1, 2, 'hello', 3, 4, 'hello')
print(t1.count('hello'))	# 结果：2

# 统计元组内的元素个数
t1 = (1, 2, 3)
print(len(t1))	# 结果：3

元组的相关操作-注意事项

• 不可以修改元组的内容，否则会直接报错
• 可以修改元组内的list的内容（修改元素、增加、删除、反转等）

Demo

"""
演示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}")
# 元组的嵌套
t5 = ( (1, 2, 3), (4, 5, 6) )
print(f"t5的类型是：{type(t5)}，内容是：{t5}")
# 下标索引去取出内容
num = t5[1][2]
print(f"从嵌套元组中取出的数据是：{num}")
# 元组的操作：index查找方法
t6 = ("传智教育", "黑马程序员", "Python")
index = t6.index("黑马程序员")
print(f"在元组t6中查找黑马程序员的下标是：{index}")
# 元组的操作：count统计方法
t7 = ("传智教育", "黑马程序员", "黑马程序员", "黑马程序员", "Python")
num = t7.count("黑马程序员")
print(f"在元组t7中查统计黑马程序员的数量有：{num}个")
# 元组的操作：len函数统计元组元素数量
t8 = ("传智教育", "黑马程序员", "黑马程序员", "黑马程序员", "Python")
nun = len(t8)
print(f"t8元组中的元素有：{num}个")
# 元组的遍历：while
index = 0
while index < len(t8):
    print(f"元组的元素有：{t8[index]}")
    # 至关重要
    index += 1
# 元组的遍历：for
for element in t8:
    print(f"2元组的元素有：{element}")
# 修改元组内容
# t8[0] = "itcast"
# 定义一个元组
t9 = (1, 2, ["hello", "world"])
print(f"t9的内容是：{t9}")
t9[2][0] = "张三"
t9[2][1] = "李四"
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中查找黑马程序员的下标是：1
在元组t7中查统计黑马程序员的数量有：3个
t8元组中的元素有：3个
元组的元素有：传智教育
元组的元素有：黑马程序员
元组的元素有：黑马程序员
元组的元素有：黑马程序员
元组的元素有：Python
2元组的元素有：传智教育
2元组的元素有：黑马程序员
2元组的元素有：黑马程序员
2元组的元素有：黑马程序员
2元组的元素有：Python
t9的内容是：(1, 2, ['hello', 'world'])
t9的内容是：(1, 2, ['张三', '李四'])

字符串的定义和操作

字符串的下标（索引）

和其他容器如：列表、元组一样，字符串也可以通过下标进行访问

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

# 通过下标获取特定位置字符
name = "itheima"
print(name[0])	#结果i
print(name[-1])	#结果a

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

所以：

• 修改指定下标的字符（如：字符串[0]=”a”）
• 移除特定下标的字符（如：del字符串[0]、字符串.remove()、字符串.pop()等）
• 追加字符等（如：字符串.append()）

均无法完成。如果必须要做，只能得到一个新的字符串，旧的字符串无法修改

字符串的常用操作

• 查找特定字符串的下标索引值

  语法：字符串.index(字符串)

  my_str = “itcast and itheima"
  print(my_str.index("and"))	# 结果7

• 字符串的替换

  语法：字符串.replace(字符串1, 字符串2)

  功能：将字符串内的全部：字符串1，替换为字符串2

  注意：不是修改字符串本身，而是得到了一个新字符串

• 字符串的分割

  语法：字符串.split(分隔符字符串)

  功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中

  注意：字符串本身不变，而是得到了一个列表对象

• 字符串的规整操作（去前后空格）

  语法：字符串.strip()

  my_str = " itheima and itcast "
  print(my_str.strip())	#结果："itheima and itcast"

• 字符串的规整操作（去前后指定字符串）

  语法：字符串.strip(字符串)

  my_str = "12itheima and itcast21"
  print(my_str.strip("12"))		#结果："itheima and itcast"

  注意，传入的是“12”其实就是：“1”和“2”都会移除，是按照单个字符。

字符串常用操作汇总

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

字符串的遍历

同列表、元组一样，字符串也支持while循环和for循环进行遍历

my_str = "Python"
index = 0
while index < len(my_str):
	print(my_str[index])
	index += 1

my_str = "Python"
for i in my_str:
	print(i)

运行结果都为：

P
y
t
h
o
n

字符串的特点

作为数据容器，字符串有如下特点：

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

Demo

"""
演示以数据容器的角色，学习字符串中的相关操作
"""
my_str = "itheima and itcast"
# 通过下标索引取值
value = my_str[2]
value2 = my_str[-16]
print(f"从字符串{my_str}去下标为2的元素，值是：{value}，取下标为-16的元素，值是：{value2}")
# my_str[2] = "H"
# 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}")

运行结果

从字符串itheima and itcast去下标为2的元素，值是：h，取下标为-16的元素，值是：h
在字符串itheima and itcast中查找and,其起始下标是：8
将字符串itheima and itcast，进行替换后得到：程序heima and 程序cast
将字符串hello python itheima itcast进行split切分后得到：['hello', 'python', 'itheima', 'itcast']，类型是：<class 'list'>
字符串 itheima and itcast 被strip后，结果：itheima and itcast
字符串12itheima and itcast21被strip('12')后，结果：itheima and itcast
字符串itheima and itcast中it出现的次数是：2
字符串itheima and itcast的长度是：18

Demo2

"""
字符串课后练习演示
"itheima itcast bouxuegu"
"""
my_str = "itheima itcast bouxuegu"
# 统计字符串内有多少个"it"字符
num = my_str.count("it")
print(f"字符串{my_str}中有{num}个it字符")
# 将字符串内的空格，全部替换为字符："|"
new_my_str = my_str.replace(" ","|")
print(f"字符串{my_str}被替换空格后，结果是：{new_my_str}")
# 并按照"|"进行字符串分割，得到列表
my_str_list = new_my_str.split("|")
print(f"字符串{new_my_str}按照|分割后结果是：{my_str_list}")

运行结果

字符串itheima itcast bouxuegu中有2个it字符
字符串itheima itcast bouxuegu被替换空格后，结果是：itheima|itcast|bouxuegu
字符串itheima|itcast|bouxuegu按照|分割后结果是：['itheima', 'itcast', 'bouxuegu']

数据容器（序列）的切片

序列

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

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

序列的常用操作-切片

序列支持切片，即：列表、元组、字符串、均支持进行切片操作

切片：从一个序列中，取出一个子序列

语法：序列[起始下标;结束下标;步长]

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

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

Demo

"""
演示对序列进行切片操作
"""
# 对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_list[::-2]
print(f"结果6：{result6}")

运行结果

结果1：[1, 2, 3]
结果2：(0, 1, 2, 3, 4, 5, 6)
结果3：0246
结果4：76543210
结果5：[3, 2]
结果6：[6, 4, 2, 0]

Demo2

"""
演示序列的切片的课后练习
"万过薪月，员序程马黑来，nohtyP学"
"""
my_str = "万过薪月，员序程马黑来，nohtyP学"
# 倒序字符串，切片取出
result1 = my_str[::-1][9:14]
print(f"方式1结果：{result1}")
# 切片取出，然后倒序
result2 = my_str[5:10][::-1]
print(f"方式2结果：{result2}")
# split分隔", " replace替换"来"为空，倒序字符串
result3 = my_str.split("，")[1].replace("来","")[::-1]
print(f"方式3结果：{result3}")

运行结果

方式1结果：黑马程序员
方式2结果：黑马程序员
方式3结果：黑马程序员

集合的定义和操作

集合的定义

基本语法：

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

和列表、元组、字符串等定义基本相同：

• 列表使用：[]
• 元组使用：()
• 字符串使用：””
• 集合使用：{}

集合的常用操作-修改

首先，因为集合是无序的，所以集合不支持：下标索引访问

但是集合和列表一样，是允许修改的，所以我们来看看集合的修改方法。

• 添加新元素

  语法：集合.add(元素)。将指定元素，添加到集合内

  结果：集合本身被修改，添加了新元素

  my_set = {"Hello", "World"}
  my_set.add("itheima")
  print(my_set)	#结果{'Hello', 'itheima', 'World'}

• 移除元素

  语法：集合.remove(元素)，将指定元素，从集合内移除

  结果：集合本身被修改，移除了元素

  my_set = {"Hello", "World"}
  my_set.add("Hello")
  print(my_set)	#结果{'World'}

• 从集合中随机取出元素

  语法：集合.pop()，功能，从集合中随机取出一个元素

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

  my_set = {"Hello", "World", "itheima"}
  element = my_set.pop()
  print(my_set)	#结果{'World', 'itheima'}
  print(element)	#结果'Hello'

• 清空集合

  语法：集合.clear()，功能，清空集合

  结果：集合本身被清空

  my_set = {"Hello", "World", "itheima"}
  my_set.clear()
  print(my_set)	#结果：set()	空集合

• 取出2个集合的差集

  语法：集合1.difference(集合2)，功能：取出集合1和集合2的差集（集合1有而集合2没有的）

  结果：得到一个新集合，集合1和集合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个集合的差集

  语法：集合1.difference_update(集合2)

  功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素

  结果：集合1被修改，集合2不变

  set1 = {1, 2, 3}
  set2 = {1, 5, 6}
  set1.difference_update(set2)
  print(set1)		#结果：{2, 3}
  print(set2)		#结果：{1, 5, 6}

• 2个集合合并

  语法：集合1.union(集合2)

  功能：将集合1和集合2组合成新集合

  结果：得到新集合，集合1和集合2不变

  set1 = {1, 2, 3}
  set2 = {1, 5, 6}
  set3 = set1.union(set2)
  print(set3)		#结果：{1, 2, 3, 5, 6}，新集合
  print(set1)		#结果：{1, 2, 3}，set1不变
  print(set2)		#结果：{1, 5, 6}，set2不变

编号	操作	说明
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(集合)	得到一个整数，记录了集合的元素数量

集合的特点

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

Demo

"""
演示数据容器集合的使用
"""
# 定义集合
my_set = {"传智教育", "黑马程序员", "itheima", "传智教育", "黑马程序员", "itheima", "传智教育", "黑马程序员", "itheima"}
my_set_empty = set()    # 定义空集合
print(f"my_set的内容是：{my_set}，类型是：{type(my_set_empty)}")
# 添加新元素
my_set.add("Python")
my_set.add("传智教育")
print(f"my_set添加元素后结果是：{my_set}")
# 移除元素
my_set.remove("黑马程序员")
print(f"my_set移除黑马程序员后，结果是：{my_set}")
# 随机取出一个元素
my_set = {"传智教育", "黑马程序员", "itheima", "传智教育", "黑马程序员", "itheima", "传智教育", "黑马程序员", "itheima"}
element = my_set.pop()
print(f"集合被取出元素是：{element}，取出元素后：{my_set}")
# 清空集合：clear
my_set.clear()
print(f"集合被清空，结果是：{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 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(f"消除差集后，set1的内容：{set1}")
print(f"消除差集后，set2的内容：{set2}")
# 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()
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}")

运行结果

my_set的内容是：{'传智教育', '黑马程序员', 'itheima'}，类型是：<class 'set'>
my_set添加元素后结果是：{'传智教育', '黑马程序员', 'itheima', 'Python'}
my_set移除黑马程序员后，结果是：{'传智教育', 'itheima', 'Python'}
集合被取出元素是：传智教育，取出元素后：{'黑马程序员', 'itheima'}
集合被清空，结果是：set()
取出差集后的结果是：{2, 3}
取差集后，原有set1的内容：{1, 2, 3}
取差集后，原有set2的内容：{1, 5, 6}
消除差集后，set1的内容：{2, 3}
消除差集后，set2的内容：{1, 5, 6}
2集合合并结果：{1, 2, 3, 5, 6}
合并后集合1：{1, 2, 3}
合并后集合2：{1, 5, 6}
集合内的元素数量有：5个
集合的元素有：1
集合的元素有：2
集合的元素有：3
集合的元素有：4
集合的元素有：5

Demo2

"""
演示集合的课后练习题
my_list = ['黑马程序员', '传智博客', '黑马程序员', '传智博客',
    'itheima', 'itcast', 'itheima', 'itcast', 'best']
"""
my_list = ['黑马程序员', '传智博客', '黑马程序员', '传智博客',
    'itheima', 'itcast', 'itheima', 'itcast', 'best']

# 定义一个空集合
my_set = set()

# 通过for循环遍历列表
for element in my_list:
    # 在for循环中将列表的元素添加至集合
    my_set.add(element)

# 最终得到元素去重后的集合对象，并打印输出
print(f"列表的内容是：{my_list}")
print(f"通过for循环后，得到的集合对象是：{my_set}")

运行结果

列表的内容是：['黑马程序员', '传智博客', '黑马程序员', '传智博客', 'itheima', 'itcast', 'itheima', 'itcast', 'best']
通过for循环后，得到的集合对象是：{'黑马程序员', '传智博客', 'itcast', 'best', 'itheima'}

字典的定义

字典的定义

字典的定义，同样使用{}，不过存储的元素是一个个的：键值对，如下语法：

# 定义字典字面量
{key: value, key:value, ......, key:value}
# 定义字典变量
my_dict = {key: value, key: value, ......, key: value}
# 定义空字典
my_dict = {}		# 空字典定义方式1
my_dict = dict()	# 空字典定义方式2

字典内Key不允许重复，重复添加等同于覆盖原有数据

字典数据的获取

字典同集合一样，不可以使用下标索引

但是字典可以通过Key值来取得对应的Value

# 语法，字典[Key]可以取到对应的Value
stu_score = {"王力鸿": 99, "周杰轮": 88, "林俊节": 77}
print(stu_score["王力鸿"])		#结果99
print(stu_score["周杰轮"])		#结果88
print(stu_score["林俊节"])		#结果77

字典的嵌套

字典的Key和Value可以是任意数据类型（Key不可为字典）

那么，就表明，字典是可以嵌套的

需求如下：记录学生各科的考试信息

Demo

"""
演示数据容器字典的定义
"""
# 定义字典
my_dict1 = {"王力鸿": 99, "周杰轮": 88, "林俊节": 77}
# 定义空字典
my_dict2 = {}
my_dict3 = dict()
print(f"字典1的内容是：{my_dict1}，类型：{type(my_dict1)}")
print(f"字典1的内容是：{my_dict2}，类型：{type(my_dict2)}")
print(f"字典1的内容是：{my_dict3}，类型：{type(my_dict3)}")
# 定义重复Key的字典
my_dict1 = {"王力鸿": 99, "王力鸿": 88, "林俊节": 77}
print(f"重复key的字典的内容是：{my_dict1}")
# 从字典中基于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}")

运行结果

字典1的内容是：{'王力鸿': 99, '周杰轮': 88, '林俊节': 77}，类型：<class 'dict'>
字典1的内容是：{}，类型：<class 'dict'>
字典1的内容是：{}，类型：<class 'dict'>
重复key的字典的内容是：{'王力鸿': 88, '林俊节': 77}
王力鸿的考试分数是：99
王力鸿的考试分数是：88
学生的考试信息是：{'王力鸿': {'语文': 77, '数学': 66, '英语': 33}, '周杰轮': {'语文': 88, '数学': 86, '英语': 55}, '林俊节': {'语文': 99, '数学': 96, '英语': 66}}
周杰轮的语文分数是：88
林俊节的英语分数是：66

字典的常用操作

• 新增元素

  语法：字典[Key] = Value，结果：字典被修改，新增了元素

  stu_score = {
  	"王力鸿": 77,
  	"周杰轮": 88,
  	"林俊节": 99
  }
  # 新增：张学油的考试成绩
  stu_score['张学油'] = 66
  print(stu_score)		# 结果：{'王力鸿': 77, '周杰轮': 88, '林俊节': 99, '张学油': 66}

• 更新元素

  语法：字典[Key]=Value，结果：字典被修改，元素被更新

  注意：字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值

  stu_score = {
  	"王力鸿": 77,
  	"周杰轮": 88,
  	"林俊节": 99
  }
  #更新：王力鸿的考试成绩
  stu_score['王力鸿'] = 100
  print(stu_score)		#结果：{'王力鸿': 100, '周杰轮': 88, '林俊节': 99}

• 删除元素

  语法：字典.pop(Key)，结果：获得指定Key的Value，同时字典被修改，指定Key的数据被删除

  stu_score = {
  	"王力鸿": 77,
  	"周杰轮": 88,
  	"林俊节": 99
  }
  value = stu_score.pop("王力鸿")
  print(value)		# 结果：77
  print(stu_score)	# 结果：{'周杰轮': 88, '林俊节': 99}

• 清空字典

  语法：字典.clear()，结果：字典被修改，元素被清空

  stu_score = {
  	"王力鸿": 77,
  	"周杰轮": 88,
  	"林俊节": 99
  }
  stu_score.clear()
  print(stu_score)	# 结果：{}

• 获取全部的key

  语法：字典.keys()，结果：得到字典中的全部Key

  stu_score = {
  	"王力鸿": 77,
  	"周杰轮": 88,
  	"林俊节": 99
  }
  keys = stu_score.keys()
  print(keys)	# 结果：dict_keys(['王力鸿', '周杰轮', '林俊节']}

字典的常用操作总结

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

字典的特点

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

Demo

"""
演示字典的常用操作
"""
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}个")

运行结果

字典经过新增元素后，结果：{'周杰轮': 99, '林俊节': 88, '张学油': 77, '张信哲': 66}
字典经过更新后，结果：{'周杰轮': 33, '林俊节': 88, '张学油': 77, '张信哲': 66}
字典中被移除了一个元素，结果：{'林俊节': 88, '张学油': 77, '张信哲': 66}，周杰轮的考试分数是：33
字典被清空了，内容是：{}
字典的全部keys是：dict_keys(['周杰轮', '林俊节', '张学油'])
字典的key是：周杰轮
字典的value是：99
字典的key是：林俊节
字典的value是：88
字典的key是：张学油
字典的value是：77
2字典的key是：周杰轮
2字典的value是：99
2字典的key是：林俊节
2字典的value是：88
2字典的key是：张学油
2字典的value是：77
字典中的元素数量有：3个

Demo2

"""
演示字典的课后练习：升职加薪，对所有级别为1级的员工，级别上升1级，薪水增加1000元
"""
# 组织字典记录数据
info_dict = {
    "王力鸿": {
        "部门": "科技部",
        "工资": 3000,
        "级别": 1
    },
    "周杰轮": {
        "部门": "市场部",
        "工资": 5000,
        "级别": 2
    },
    "林俊节": {
        "部门": "市场部",
        "工资": 7000,
        "级别": 3
    },
    "张学油": {
        "部门": "科技部",
        "工资": 4000,
        "级别": 1
    },
    "刘德滑": {
        "部门": "市场部",
        "工资": 6000,
        "级别": 2
    }
}
print(f"员工在升值加薪之前的结果：{info_dict}")
# for循环遍历字典
for name in info_dict:
    # if条件判断符合条件员工
    if info_dict[name]["级别"] == 1:
        # 升职加薪操作
        # 获取到员工的信息字典
        employee_info_dict = info_dict[name]
        # 修改员工的信息
        employee_info_dict["级别"] += 1       # 级别+1
        employee_info_dict["工资"] += 1000    # 工资+1000
        # 将员工的信息更新回info_dict
        info_dict[name] = employee_info_dict
# 输出结果
print(f"对员工进行升级加薪后的结果是：{info_dict}")

运行结果

员工在升值加薪之前的结果：{'王力鸿': {'部门': '科技部', '工资': 3000, '级别': 1}, '周杰轮': {'部门': '市场部', '工资': 5000, '级别': 2}, '林俊节': {'部门': '市场部', '工资': 7000, '级别': 3}, '张学油': {'部门': '科技部', '工资': 4000, '级别': 1}, '刘德滑': {'部门': '市场部', '工资': 6000, '级别': 2}}
对员工进行升级加薪后的结果是：{'王力鸿': {'部门': '科技部', '工资': 4000, '级别': 2}, '周杰轮': {'部门': '市场部', '工资': 5000, '级别': 2}, '林俊节': {'部门': '市场部', '工资': 7000, '级别': 3}, '张学油': {'部门': '科技部', '工资': 5000, '级别': 2}, '刘德滑': {'部门': '市场部', '工资': 6000, '级别': 2}}

5类数据容器的总结与对比

数据容器分类

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

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

数据容器特点对比

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

基于各类数据容器的特点，它们的应用场景如下：

• 列表：一批数据，可修改、可重复的存储场景
• 元组：一批数据，不可修改、可重复的存储场景
• 字符串：一串字符串的存储场景
• 集合：一批数据，去重存储场景
• 字典：一批数据，可用Key检索Value的存储场景

数据容器的通用操作

数据容器的通用操作 - 遍历

数据容器尽管各自有各自的特点，但是它们也有通用的一些操作

首先，在遍历上：

• 5类数据容器都支持for循环遍历
• 列表、元组、字符串支持while循环，集合、字典不支持（无法下标索引）

尽管遍历的形式各有不同，但是，它们都支持遍历操作

数据容器的通用统计功能

除了遍历这个共性外，数据容器可以通用非常多的功能方法

• len(容器)

  统计容器的元素个数

  my_list = [1, 2, 3]
  my_tuple = (1, 2, 3, 4, 5)
  my_str = "itheima"
  print(len(my_list))		# 结果3
  print(len(my_tuple))	# 结果5
  print(len(my_str))		# 结果7

• max(容器)

  统计容器的最大元素

  my_list = [1, 2, 3]
  my_tuple = (1, 2, 3, 4, 5)
  my_str = "itheima"
  print(max(my_list))		# 结果3
  print(max(my_tuple))	# 结果5
  print(max(my_str))		# 结果t

• min(容器)

  统计容器的最小元素

  my_list = [1, 2, 3]
  my_tuple = (1, 2, 3, 4, 5)
  my_str = "itheima"
  print(min(my_list))		# 结果1
  print(min(my_tuple))	# 结果1
  print(min(my_str))		# 结果a

容器的通用转换功能

除了下标索引这个共性外，还可以通用类型转换

list(容器)将给定容器转换为列表

str(容器)将给定容器转换为字符串

tuple(容器)将给定容器转换为元组

set(容器)将给定容器转换为集合

容器通用排序功能

通用排序功能

sorted(容器, [reverse=True])

将给定容器进行排序

容器通用功能总览

功能	描述
通用for循环	遍历容器（字典是遍历key）
max()	容器内最大元素
min()	容器内最小元素
len()	容器元素个数
list()	转换为列表
tuple()	转换为元组
str()	转换为字符串
set()	转换为集合
sorted(序列, [reverse = True])	排序，reverse = True表示降序 得到一个排好序的列表

Demo

"""
演示数据容器的通用功能
"""
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": 4, "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 = "bcdefga"
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)}")

运行结果

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

拓展-字符串大小比较的方式

1. 字符串如何比较

   从头到尾，一位位进行比较，其中一位大，后面就无需比较了

2. 单个字符之间如何确定大小？

   通过ASCII码表，确定字符对应的码值数字来确定大小

Demo

"""
演示字符串大小比较
"""
# abc 比较 abd
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