0基础学Python——第五章：数据容器
目录
hello小伙伴们，今天来分享Python中的数据容器啦！本期内容很多很多很多~因为想用一篇直接列出数据容器的基础知识，所以希望感兴趣的友友可以继续看哦。话不多说，开始了！
数据容器
首先我们需要了解下学习数据容器的原因，我们先思考一个问题：如果我们想要在程序中记录5名学生的姓名信息，应该怎么做呢？有以下两种方法。
① 定义5个变量（不高级且低效）
name1='王力'
name2='周杰'
name3='林俊'
name4='张学'
name5='刘德'② 定义一个变量（优雅且高效）
name_list=['王力','周杰','林俊','张学','刘德']
print(name_list)由此可见，通过使用列表这个数据容器，完成了多份数据的容纳，其使得代码变得很高效，因此我们需要学习数据容器来优雅地写代码。
上面的name_list这类的数据容器为列表，数据容器指的是一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素，每一个元素可以是任意类型的数据，如字符串、数字、布尔等。在Python中，根据特点的不同将数据容器分为5类，分别为列表(list)、元组(tuple)、字符串(str)、集合(set)、字典(dict)。接下来会为大家详细介绍这5类数据容器。
列表
列表定义方式
列表的定义方式如下：
变量名称=[元素1,元素2,元素3,元素4,······]
注意：
① 列表中的每一个数据都称为元素；
② 列表以[ ]作为标识；
③ 列表内每一个元素之间都用逗号（英文）隔开。
下面举一个例子，希望方便大家理解。
# 定义一个列表list
my_list=["itheima","ityueliang","python"]
print(my_list)
print(type(my_list))列表可以一次存储多个数据，且可以为不同的数据类型；元素也可以为列表，因此列表也支持嵌套，称为嵌套列表。举例如下。
# 定义一个元素为不同数据类型的列表
my_list=["ityueliang",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开始，依次递增（0，1，2，3，······）；若从后往前的方向，从-1开始，依次递减（-1，-2，-3，······）。只需按照下标索引，即可获取对应位置的元素。但是请注意通过下标索引取数据时，一定不要超出范围！
# 通过下标索引取出对应位置的数据
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])列表的相关操作（方法）
| 序号 | 使用方式 | 作用 |
| 1 | 列表.append(元素) | 向列表中追加一个元素 |
| 2 | 列表.extend(容器) | 将数据容器中的内容依次取出，追加到列表尾部 |
| 3 | 列表.insert(下标,元素) | 在指定的下标处插入指定的元素 |
| 4 | del列表[下标] | 删除列表指定下标的元素 |
| 5 | 列表.pop(元素) | 删除列表指定下标的元素 |
| 6 | 列表.remove(元素) | 从前往后，删除此元素第一个匹配项 |
| 7 | 列表.clear(元素) | 清空列表 |
| 8 | 列表.count(元素) | 统计此元素在列表中出现的次数 |
| 9 | 列表.index(元素) | 查找指定元素在列表中的下标，找不到时报错ValueError |
| 10 | len(元素) | 统计容器内有多少个元素 |
下面代码为各种方法的具体使用。
mylist=["ityueliang","itheima","python"]
# 1.1 查找某元素在列表内的下标索引
index=mylist.index("itheima")
print(f"itheima在列表中的下标索引值是：{index}")
# 1.2如果被查找的元素不存在，会报错
# index=mylist.index("hello")
# print(f"hello在列表中的下标索引值是：{index}")
# 2.修改特定下标索引的值
mylist[0]="月亮程序员"
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.删除指定下标索引的元素（2种方式）
mylist=["ityueliang","itheima","python"]
# 6.1 方式1：del 列表[下标]
del mylist[2]
print(f"列表删除元素后，结果是：{mylist}")
# 6.2 方式2：列表.pop(下标)
mylist=["ityueliang","itheima","python"]
element=mylist.pop(2)
print(f"通过pop方法取出元素后列表内容：{mylist}，取出的元素是{element}")
# 7.删除某元素在列表中的第一个匹配项
mylist=["ityueliang","itheima","ityueliang","itheima","python"]
mylist.remove("itheima")
print(f"通过remove方法移除元素后，列表的结果是{mylist}")
# 8.清空列表
mylist.clear()
print(f"列表被清空了，结果是{mylist}")
# 9.统计列表内某元素的数量
mylist=["ityueliang","itheima","ityueliang","itheima","python"]
count=mylist.count("itheima")
print(f"列表中itheima的数量是:{count}")
# 10.统计列表中全部的元素数量
mylist=["ityueliang","itheima","ityueliang","itheima","python"]
count=len(mylist)
print(f"列表的元素数量总共有：{count}个")列表的特点
① 可以容纳多个元素（上限为2**63-1个）；
② 可以容纳不同类型的元素（混装）；
③ 数据是有序存储的（有下标序号）；
④ 允许重复数据存在；
⑤ 可以修改（增加、删除或清空元素等）。
列表的遍历-while和for循环
数据容器可以存储多个元素，从容器中依次将元素取出来进行处理的行为称为遍历、迭代。接下来就从while循环和for循环来分享。
列表的遍历-while循环
通过使用列表[下标]的方式，结合while循环，定义一个变量表示下标（从0 开始），定义循环条件为“下标值<列表的元素数量”，详细代码（含说明文档）如下。
def list_while_func():
"""
使用while循环遍历列表的演示函数
:return: None
"""
my_list=["月亮教育","月亮程序员","Python"]
# 循环控制变量通过下标索引来控制，默认为0
# 每次循环将下标索引变量+1
# 循环条件：下标索引变量<列表的元素数量
# 定义一个变量用来标记列表的下标
index=0
while index<len(my_list):
# 通过index变量取出对应下标的元素
element=my_list[index]
print(f"列表的元素:{element}")
# 至关重要：将循环变量每一次循环都+1
index+=1
list_while_func()列表的遍历-for循环
列表的遍历中for循环的语法大致为：
for 临时变量 in 数据容器:
对临时变量进行处理
详细代码（含说明文档）如下。
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_for_func()while循环和for循环的对比
while循环和for循环都是循环语句，但是也有区别。
① 循环控制上
① while循环可以自定义循环条件，并自行控制；
② for循环不可以自定义循环条件，只能从容器中依次取出数据。
② 无限循环上
① while循环可以通过条件控制做到无限循环；
② 在理论上，for循环不可以无限循环，因为被遍历的容器的容量不是无限的。
③ 应用场景上
① while循环适用于任何需要循环的场景；
② for循环适用于遍历数据容器或者简单的固定次数循环的场景。
总而言之，for循环更简单，while循环更灵活。
元组
关于元组，需要了解的一点是：元组一旦定义完成，就不能修改。因此，当需要在程序内封装数据，同时又不想封装的数据呗篡改，那么就可以选择元组。
元组的相关操作（方法）
| 序号 | 方法 | 作用 |
| 1 | index() | 查找某个数据，若数据存在则返回对应的下标，否则会报错 |
| 2 | count() | 统计某个数据在当前元组出现的次数 |
| 3 | len(元组) | 统计元组内的元素个数 |
相关操作的详细代码如下。
# 定义元组
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}")
# 定义单个元素的元组！！！注意要加上一个逗号，否则类型是“str"
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}")
# 元组的操作：len函数统计元组元素数量！！！注意：元组不能修改
# 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}个")
# 元组的遍历：while
index=0
while index<len(t8):
print(f"1元组的元素有：{t8[index]}")
# 至关重要
index+=1
# 元组的遍历：for
for element in t8:
print(f"2元组的元素有：{element}")
# 修改元组内容不可以！！
# t8[0]="itcast"
# 定义一个元组，元组中的list中的内容可以修改
t9=(1,2,["itheima","ityueliang"])
print(f"t9的内容是{t9}")
t9[2][0]="月亮程序员"
t9[2][1]="月亮教育"
print(f"t9的内容是{t9}")
元组的特点
同list基本相同，相似的特点为：有序、任意数量元素、允许重复元素，唯一不同的是元组不可修改，即不可以修改元组内的元素，同时元组也支持for循环。
字符串
字符串是字符的容器，一个字符串可以存储任意数量的字符。例如字符串'yueliang'，
字符串的下标（索引）
字符串是无法修改的容器，如果必须修改，则会得到一个新的字符串，旧的字符串是无法修改的。同其他数据容器一样，字符串也可以通过下标访问。
① 从前往后，下标从0开始；
② 从后往前，下标从-1开始。
字符串的相关操作（方法）
| 序号 | 操作 | 说明 |
| 1 | 字符串[下标] | 根据下标索引去除特定位置的字符 |
| 2 | 字符串.index(字符串) | 查找给定字符的第一个匹配项的下标 |
| 3 | 字符串.replace(字符串1,字符串2) | 将字符串内的全部字符串1替换成字符串2，得到一个新的字符串 |
| 4 | 字符串.split(字符串) | 按照给定的字符串，对字符串进行分隔，得到一个新的字符串 |
| 5 | 字符串.strip() 字符串.strip(字符串) | 移除首尾的空格和换行符或指定字符串 |
| 6 | 字符串.count(字符串) | 统计字符串内某字符串出现的次数 |
| 7 | len(字符串) | 统计字符串的字符个数 |
相关操作的详细代码如下。
# 字符串不可以修改
my_str="itheima and ityueliang"
# 通过下标索引取值
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 ityueliang"
my_str_list=my_str.split(" ")
print(f"将字符串{my_str}进行split切分后得到：{my_str_list},它的类型是：{type(my_str_list)}")
# strip方法
my_str=" itheima and ityueliang "
new_my_str=my_str.strip() # 不传入参数，去除首尾空格
print(f"字符串{my_str}被strip后，结果是：{new_my_str}")
my_str="12itheima and ityueliang21"
new_my_str=my_str.strip("12") # 相当于去除字符串1和字符串2
print(f"字符串{my_str}被strip后，结果是：{new_my_str}")
# 统计字符串中某字符串的出现次数，count
my_str="itheima and ityueliang"
count=my_str.count("it")
print(f"字符串{my_str}中it出现的次数是：{count}")
# 统计字符串的长度，len()
num=len(my_str)
print(f"字符串{my_str}的长度是；{num}")字符串的遍历也有while和for两种循环，具体代码如下。
# 字符串的遍历:while
my_str="月亮程序员"
index=0
while index<len(my_str):
print(my_str[index])
index+=1
# 字符串的遍历：for
my_str="月亮程序员"
for element in my_str:
print(element)字符串的特点
① 只可以存储字符串；
② 长度是任意的（取决于内存大小）；
③ 支持下标索引；
④ 允许重复字符串存在；
⑤ 不可以修改（增加或删除元素等）；
⑥ 支持while和for循环。
序列
在数据容器中，列表、元组和字符串可以视为序列。序列指的是内容连续、有序，且支持下标索引的一类数据容器。序列有一种常用操作，即序列的切片。切片指的是从一个序列中取出一个子序列。其语法大致为：
序列[起始下标:结束下标:步长]
其含义是：从从序列中，从指定的起始位置开始，按照步长，依次取出元素，直至到指定位置结束，得到一个新的序列，具体规定如下。
① 起始下标表示从何处开始，若起始下标为空白，代表从头开始；
② 结束下标（不被包含）表示从何处结束，可以留空，代表到结尾结束；
③ 步长表示依次取元素的间隔：
① 步长为1代表一个个地取元素；
② 步长为2代表每次跳过1个元素取后面的那个元素；
③ 步长为n代表每次跳过（n-1）个元素取后面的那个元素；
④ 步长为复数时代表反向取元素；
⑤ 步长省略时，代表默认为1。
下面举一个例子，希望方便大家理解。
# 对list进行切片，从1开始，4结束，步长1
my_list=[0,1,2,3,4,5,6]
result_1=my_list[1:4:1] # 注意不包括4，步长默认为1，所以可以省略不写，改为my_list[1:4]
print(f"结果1为：{result_1}")
# 1.对tuple进行切片，从头开始，到最后结束，步长1
my_tuple=(0,1,2,3,4,5,6)
result_2=my_tuple[:] # 起始和结束可以不写，表示从头到尾，步长为1可以省略不写
print(f"结果2为：{result_2}")
# 2.对str进行切片，从头开始，到最后结束，步长2
my_str="01234567"
result_3=my_str[::2]
print(f"结果3为：{result_3}")
# 3.对str进行切片，从头开始，到最后结束，步长-1
my_str="01234567"
result_4=my_str[::-1] # 等同于将序列反转了
print(f"结果4为：{result_4}")
# 4.对list进行切片，从3开始，到1结束，步长-1
my_list=[0,1,2,3,4,5,6]
result_5=my_list[3:1:-1]
print(f"结果5为：{result_5}")
# 5.对tuple进行切片，从头开始，到最后结束，步长-2
my_tuple=(0,1,2,3,4,5,6)
result_6=my_tuple[::-2]
print(f"结果6为：{result_6}")集合
集合的定义为：{元素，元素，元素，······}
集合不支持元素的重复（自带去重功能）且内容无序（就不能通过下标取出特定元素）。
集合的相关操作（方法）
| 序号 | 操作 | 说明 |
| 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) | 得到一个新集合，内含2个集合的全部元素，原有的2个集合的内容不变 |
| 8 | len(集合) | 得到一个整数，记录了集合的元素数量 |
相关操作的详细代码如下。
# 1.定义集合，注意集合不可以重复，内容无序，故不支持下标索引
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)}")
# 2.添加新元素
my_set.add("Python")
my_set.add("月亮教育")
print(f"my_set添加元素后的结果是{my_set}")
# 3.移除元素
my_set.remove("黑马程序员")
print(f"my_set移除黑马程序员后的结果是{my_set}")
# 4.随机取出一个元素,取出后集合中不再有pop的元素
my_set={"月亮教育","黑马程序员","itheima"}
element=my_set.pop()
print(f"集合被取出元素是：{element},取出元素后：{my_set}")
# 5.清空集合
my_set.clear()
print(f"集合被清空了，结果是：{my_set}")
# 6.取两个集合的差集
set1={1,2,3}
set2={1,5,6}
set3=set1.difference(set2)
print(f"取出差集后的结果是：{set3}")
print(f"取差集后，原有set1的内容：{set1}")
print(f"取差集后，原有set2的内容：{set2}")
# 7.消除2个集合的差集，在集合1内，删除和集合2相同的元素，结果为：集合1被修改，集合2不变
set1={1,2,3}
set2={1,5,6}
set1.difference_update(set2)
print(f"消除差集后，集合1结果是：{set1}")
print(f"消除差集后，集合2结果是：{set2}")
# 8.合并两个结合
set1={1,2,3}
set2={1,5,6}
set3=set1.union(set2)
print(f"两集合合并结果是：{set3}")
print(f"合并后集合1：{set1}")
print(f"合并后集合2：{set2}")
# 9.统计集合元素数量len()
set1={1,2,3,4,5,1,2,3,4,5}
num=len(set1)
print(f"集合内的元素数量有{num}个")
# 10.集合的遍历
# 集合不支持下标索引，不能用while循环
# 集合可以用for循环
set1={1,2,3,4,5}
for element in set1:
print(f"集合的元素有；{element}")集合的特点
① 可以容纳多个数据；
② 可以容纳不同类型的数据（混装）；
③ 数据是无序存储的（不支持下标索引）；
④ 不允许重复数据的存在；
⑤ 可以修改（增加、删除或清空元素等）；
⑥ 支持for循环，不支持while循环（由于不支持下标索引）。
字典
字典中的元素不是一个个的，而是一对键值对，像查字典一样。字典也不能使用下标索引，但是字典可以通过key值来取得对应的value，字典内的key不允许重复，重复添加等同于覆盖原有的数据，可见下面的例子。
my_dict1={"王力":99,"周杰":88,"林俊":77,"王力":66}
print(f"王力的成绩为{my_dict1['王力']}")字典的定义为：
{key:value,key:value,key:value,······}
下面举一个例子，希望方便大家理解。
# 从字典中基于key获取value
my_dict1={"王力":99,"周杰":88,"林俊":77}
score=my_dict1["王力"]
print(f"王力的考试分数是：{score}")
score=my_dict1["周杰"]
print(f"周杰的考试分数是：{score}")字典的嵌套
字典中的key和value可以是任意的数据类型（key不可以为字典），这就表明，字典是可以嵌套的。下面举一个例子，希望方便大家理解。大家敲代码的时候如果报错了，请记得检查逗号是否都写了，注意要写英文的。
# 字典的嵌套
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 | 字典[key] | 获取指定key对应的value值 |
| 2 | 字典[key]=value | 添加或更新键值对 |
| 3 | 字典.pop(key) | 取出key对应的value并在字典内删除此key的键值对 |
| 4 | 字典.clear() | 清空字典 |
| 5 | 字典.keys() | 获取字典的全部key，可用于for循环遍历字典 |
| 6 | len(字典) | 计算字典内的的元素数量 |
相关操作的详细代码如下。
my_dict={"周杰":99,"林俊":88,"张学":77}
# 1.新增元素（不在字典中）
my_dict["张信"]=66
print(f"字典经过新增元素后，结果：{my_dict}")
# 2.更新元素（在字典中）
my_dict["周杰"]=33
print(f"字典经过更新后，结果：{my_dict}")
# 3.删除元素
score=my_dict.pop("周杰")
print(f"字典中被移除了一个元素，结果：{my_dict},周杰的考试分数是：{score}")
# 4.清空元素
my_dict.clear()
print(f"字典被清空了，内容是：{my_dict}")
# 5.获取全部key
my_dict={"周杰":99,"林俊":88,"张学":77}
keys=my_dict.keys()
print(f"字典的全部key是：{keys}")
# 6.遍历字典(字典不支持下标索引，所以不能用while循环来遍历）
# 方式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]}")
# 7.统计字典内的元素数量
num=len(my_dict)
print(f"字典中的元素数量有：{num}个")字典的特点
① 可以容纳多个数据；
② 可以容纳不同类型的数据；
③ 每一份数据是key-value键值对；
④ 可以通过key获取到value，key不可重复（重复的key对应的value会被最新的value值覆盖）；
⑤ 不支持下标索引；
⑥ 可以修改（增加、删除或更新元素等）；
⑦ 支持for循环，不支持while循环。
数据容器分类
从不同的角度分析，数据容器有很多的分类。
| 分类依据 | 类别 |
| 是否支持下标索引 | 支持：列表、元组、字符串——序列类型 |
| 不支持：集合、字典——非序列类型 | |
| 是否支持重复元素 | 支持：列表、元组、字符串——序列类型 |
| 不支持：集合、字典——非序列类型 | |
| 是否可以修改 | 支持：列表、集合、字典 |
| 不支持：元组、字符串 |
数据容器特点对比
| 依据 | 列表 | 元组 | 字符串 | 集合 | 字典 |
| 元素数量 | 支持多个 | 支持多个 | 支持多个 | 支持多个 | 支持多个 |
| 元素类型 | 任意 | 任意 | 仅字符 | 任意 | key:value key:除字典外的任意类型 value:任意类型 |
| 下标索引 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
| 重复元素 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
| 可修改性 | 支持 | 不支持 | 不支持 | 支持 | 支持 |
| 数据有序 | 是 | 是 | 是 | 否 | 否 |
| 使用场景 | 可修改、可重复的一批数据记录的场景 | 不可修改、可重复的一批数据记录的场景 | 一串字符的记录的场景 | 不可重复的数据记录的场景 | 以key检索value的数据记录的场景 |
数据容器的通用操作
| 功能 | 说明 |
| 通用for循环 | 遍历容器（字典是遍历key） |
| max() | 容器内最大元素 |
| min() | 容器内最小元素 |
| len() | 容器元素个数 |
| list() | 转换为列表 |
| tuple() | 转换为元组 |
| str() | 转换为字符串 |
| set() | 转换为集合 |
| 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}
# 1.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)}")
# 2.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)}")
# 3.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)}")
# 4.1-类型转换：容器转列表
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)}")
# 4.2-类型转换：容器转元组
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)}")
# 4.3-类型转换：容器转字符串
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)}")
# 4.4-类型转换：容器转集合
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)}") # value丢失，变无序
# 5.进行容器的排序sorted,都会变成列表对象，同时字典的value值会丢失
my_list=[3,1,2,5,4]
my_tuple=(3,1,2,5,4)
my_str="becdfga"
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)}")字符串的大小比较
在程序中，字符串所用的字符串有：① 大小写英文字母（以下图片）；② 数字；③ 特殊符号（!、\、|、@、#等）。
以下图片详见链接：https://www.runoob.com/w3cnote/ascii.html
字符串是按位比较，即一位位进行对比，只要一个字符串中有一位比另外一个字符串大，那么整体就大。详细可见以下代码。
# abc比较abd
print(f"abd大于abc，结果：{'abd'>'abc'}")
# a比较ab
print(f"ab大于a，结果：{'ab'>'a'}")
# a大于A
print(f"a大于A，结果：{'a'>'A'}")
# key2大于key1
print(f"key2大于key1，结果：{'key2'>'key1'}")以上是自己学习过程中总结和练习的内容，如有错误请谅解，定会修改哈，希望能够帮助小伙伴哦！！参考黑马程序员，如有侵权定会删除~谢谢观看啦！本期内容很多，感兴趣的友友可以继续看我的更新哦~
更多推荐
16
0- 0
已为社区贡献1条内容
所有评论(0)