Python数据容器
Python数据容器
数据容器介绍
一种可以存储多个元素的Python数据类型,数据容器种类:list(列表)、tuple(元组)、str(字符串)、set(集合)、dict(字典)
List列表
List列表定义
语法:[元素1, 元素2, 元素3, ......]
元素:数据容器内的每一份数据,都称之为元素
限制: 元素的数据类型没有任何限制,甚至元素也可以是列表,这样就定义了嵌套列表
# 定义一个列表list
my_list = ["python", "java", "mysql"]
print(my_list)
print(type(my_list))
my_list = ["python", 11, True]
print(my_list)
print(type(my_list))
# 定义一个嵌套列表
my_list = [[1, 2], [3, 4]]
print(my_list)
print(type(my_list))
# 结果
['python', 'java', 'mysql']
<class 'list'>
['python', 11, True]
<class 'list'>
[[1, 2], [3, 4]]
<class 'list'>
List列表下标索引
语法:列表[下标索引]
下标:列表的每一个元素,都有编号称之为下标索引。从前向后的方向,编号从0开始递增,从后向前的方向,编号从-1开始递减。
注意:下标索引的取值范围,超出范围无法取出元素,并且会报错
# 通过下标索引取出对应位置的数据
my_list = ["python", "java", "mysql"]
# 列表[下标索引],从前向后从0开始,每次+1, 从后向前从-1开始,每次-1
print(my_list[0])
print(my_list[1])
print(my_list[2])
# 错误案例,超出范围报错:list index out of range
# print(my_list[3])
# 通过下标索引倒序取出
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])
# 取出嵌套列表的元素
my_list = [[1, 2], [3, 4]]
print(my_list[1][1])
# 结果
python
java
mysql
mysql
java
python
4
列表的常用操作
- 列表的常见方法:
编号 | 使用方式 | 作用 |
---|---|---|
1 | 列表.append(元素) | 向列表中追加一个元素 |
2 | 列表.extend(容器) | 将数据容器的内容依次取出,追加到列表尾部 |
3 | 列表.insert(下标, 元素) | 在指定下标处,插入指定的元素 |
4 | del 列表[下标] | 删除列表指定下标元素 |
5 | 列表.pop(下标) | 删除列表指定下标元素 |
6 | 列表.remove(元素) | 从前向后,删除此元素第一个匹配项 |
7 | 列表.clear() | 清空列表 |
8 | 列表.count(元素) | 统计此元素在列表中出现的次数 |
9 | 列表.index(元素) | 查找指定元素在列表的下标,找不到报错ValueError |
10 | len(列表) | 统计容器内有多少元素 |
- 列表特点:
- 可容纳多个元素
- 可容纳不同元素类型
- 数据有序存储的
- 允许重复数据存在
- 可以增删改元素
my_list = ["python", "java", "mysql"]
# 1.1 查找元素在列表内的下标索引
index = my_list.index("python")
print(f"python的索引值:{index}")
# 1.2 如果查找的不存在,会报错 '123123' is not in list
# index = my_list.index("123123")
# print(f"不存在的索引值:{index}")
# 2 修改特定下标的值
my_list[0] = "linux"
print(f"列表元素修改后的结果:{my_list}")
# 3 在指定下标位置插入元素
my_list.insert(1, "docker")
print(f"列表插入元素后的结果:{my_list}")
# 4 在列表尾部追加单个元素
my_list.append("html")
print(f"列表追加元素后的结果:{my_list}")
# 5 在列表尾部追加一批元素
my_list2 = [1, 2, 3]
my_list.extend(my_list2)
print(f"列表追加了新的列表后的结果:{my_list}")
# 6 删除指定下标元素 del(2种方式)
my_list = ["python", "java", "mysql"]
del my_list[0]
print(f"列表删除元素后的结果:{my_list}")
# 6.2 方式2 pop方法
my_list = ["python", "java", "mysql"]
element = my_list.pop(0)
print(f"通过pop方法取出元素后的列表内容:{my_list},取出的元素是:{element}")
# 7 删除某元素在列表中的第一个匹配项
my_list = ["python", "java", "mysql", "linux", "docker"]
my_list.remove("linux")
print(f"通过remove方法移除元素后的结果:{my_list}")
# 8 清空列表
my_list.clear()
print(f"列表被清空了,结果是:{my_list}")
# 9 统计列表内某元素的数量
my_list = ["python", "java", "mysql", "linux", "java"]
count = my_list.count("java")
print(f"列表中java的数量有:{count}个")
# 10 统计列表的元素数量
my_list = ["python", "java", "mysql", "linux", "java"]
count = len(my_list)
print(f"列表的元素数量有:{count}个")
# 结果
python的索引值:0
列表元素修改后的结果:['linux', 'java', 'mysql']
列表插入元素后的结果:['linux', 'docker', 'java', 'mysql']
列表追加元素后的结果:['linux', 'docker', 'java', 'mysql', 'html']
列表追加了新的列表后的结果:['linux', 'docker', 'java', 'mysql', 'html', 1, 2, 3]
列表删除元素后的结果:['java', 'mysql']
通过pop方法取出元素后的列表内容:['java', 'mysql'],取出的元素是:python
通过remove方法移除元素后的结果:['python', 'java', 'mysql', 'docker']
列表被清空了,结果是:[]
列表中java的数量有:2个
列表的元素数量有:5个
列表的循环遍历
while与for对比:
- while循环可以自定循环条件,并自行控制,for循环不可以自定循环条件,只可以一个个从容器内取出数据
- while循环可以通过条件控制做到无限循环,for循环理论上不可以,因为被遍历的容器容量不是无限的
- while循环适用于任何想要循环的场景,for循环适用于,遍历数据容器的场景或简单的固定次数循环场景
- while更灵活,for循环更简单
def list_while_func():
"""
使用while循环便利列表的函数
:return:
"""
my_list = ["python", "java", "mysql"]
i = 0
while i < len(my_list):
print(my_list[i])
i += 1
list_while_func()
def list_for_func():
"""
使用for循环便利列表的函数
:return:
"""
my_list = ["python", "java", "mysql"]
for x in range(0, len(my_list)):
print(my_list[x])
list_for_func()
# 结果
python
java
mysql
python
java
mysql
元组的定义和操作
定义方式:
- 多个元素定义:(元素, 元素, 元素, ......)
- 单个元素定义:(元素, )
单个元素必须加个逗号后面跟个空格,否则类型就不是tuple
操作方法:
方法 | 作用 |
---|---|
index() | 查找某个数据,如果数据存在返回对应的下标,否则报错 |
count() | 统计某个数据在当前元组出现的次数 |
len(元组) | 统计元组内的元素个数 |
注意事项:不可修改内容(可以修改内部list的内部元素
)例子:t9 = (1, 2, [3, 4]) 3和4是可以修改的
元组特点:和list基本相同(有序、任意数量元素、允许重复元素),唯一不同在于不可修改。支持for循环
# 定义元组
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 = ("java","python","mysql")
index = t6.index("java")
print(f"在元组t6中查找java的下标是:{index}")
# 元组的操作:count方法
t7 = ("java","python","mysql","java")
count = t7.count("java")
print(f"在元组t7中java元素数量是:{count}")
# 元租的操作:len函数
t8 = ("java","python","mysql","linux","docker")
num = len(t8)
print(f"元组t8的元素数量是:{num}")
# 元组遍历:while
index = 0
while index < len(t8):
print(f"while循环元组的元素有:{t8[index]}")
index += 1
# 元组遍历:for
for element in t8:
print(f"for循环元组的元素有:{element}")
# 错误案例:修改元组内容! 元组内容是不可更改的
# t8[0] = "vue"
# 可以修改元组中list列表
t9 = (1, 2, [1, 2])
print(f"t9的内容是:{t9}")
t9[2][0] = 3
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中查找java的下标是:0
在元组t7中java元素数量是:2
元组t8的元素数量是:5
while循环元组的元素有:java
while循环元组的元素有:python
while循环元组的元素有:mysql
while循环元组的元素有:linux
while循环元组的元素有:docker
for循环元组的元素有:java
for循环元组的元素有:python
for循环元组的元素有:mysql
for循环元组的元素有:linux
for循环元组的元素有:docker
t9的内容是:(1, 2, [1, 2])
t9的内容是:(1, 2, [3, 2])
字符串的定义和操作
操作方法:
编号 | 方法 | 描述 |
---|---|---|
1 | 字符串[下标] | 根据下标索引取出特定位置字符 |
2 | 字符串.index(字符串) | 查找给定字符的第一个匹配项的下标 |
3 | 字符串.replace(字符串1, 字符串2) | 将字符串内的全部字符串1,替换为字符串2不会修改原字符串,而是得到一个新的 |
4 | 字符串.split(字符串) | 按照给定字符串,对字符串进行分隔不会修改原字符串,而是得到一个新的列表 |
5 | 字符串.strip()、字符串.strip(字符串) | 移除首尾的空格和换行符或指定字符串 |
6 | 字符串.count(字符串) | 统计字符串内某字符串的出现次数 |
7 | len(字符串) | 统计字符串的字符个数 |
字符串特点:
- 只可以存储字符串
- 长度任意
- 支持下标索引
- 允许重复字符存在
- 不可以增删改元素
- 支持for循环
my_str = "java and python"
# 通过下标索引取值
value = my_str[2]
value2 = my_str[-13]
print(f"从字符串{my_str}取下标为2的值是:{value},取下标为-13的值是:{value2}")
# my_str[2] = "H"
# index方法
value = my_str.index("and")
print(f"在字符串{my_str}中查找and,起始下标为:{value}")
# replace方法
new_str = my_str.replace("java", "linux")
print(f"子啊字符串{my_str}替换后,字符串值为:{new_str}")
# split方法
my_str = "mysql java python docker"
my_str_list = my_str.split(" ")
print(f"字符串{my_str}进行split切分后得到:{my_str_list}")
# strip方法
my_str = " java and python "
new_str = my_str.strip()
print(f"字符串{my_str}被strip后为:{new_str}")
my_str = "12java and python21"
new_str = my_str.strip('12')
print(f"字符串{my_str}被strip('12')后为:{new_str}")
# 统计字符串中某个字符串的出现次数
my_str = "java and python"
count = my_str.count("a")
print(f"字符串{my_str}中a的出现次数:{count}")
# 统计字符串的长度
my_str = "java and python"
num = len(my_str)
print(f"字符串{my_str}长度:{num}")
# 结果
从字符串java and python取下标为2的值是:v,取下标为-13的值是:v
在字符串java and python中查找and,起始下标为:5
子啊字符串java and python替换后,字符串值为:linux and python
字符串mysql java python docker进行split切分后得到:['mysql', 'java', 'python', 'docker']
字符串 java and python 被strip后为:java and python
字符串12java and python21被strip('12')后为:java and python
字符串java and python中a的出现次数:3
字符串java and python长度:15
数据容器的(序列)的切片
序列:内容连续、有序,可使用下标索引的一类数据容器。列表、元组、字符串,均可以可以视为序列。序列支持切片,即:列表、元组、字符串,均支持进行切片操作
切片:从一个序列中,取出一个子序列
语法:序列[起始下标:结束下标:步长]
:从指定位置开始,依次取出元素,到指定位置结束,得到一个新序列
- 从指定位置开始,依次取出元素,到指定位置结束,得到一个新序列
- 结束下标(不含)表示何处结束,可以留空,留空视作截取到结尾
- 步长表示,依次取元素的间隔 (
可以为负数,表示倒序执行
)- 步长1表示,一个个取元素
- 步长2表示,每次跳过1个元素取
- 步长N表示,每次跳过N-1个元素取
- 步长为负数表示,反向取(注意,起始下标和结束下标也要反向标记)
- 起始、结束、步长均可省略,起始为从头开始可省略,结束为最后结束可以省略,步长为1可以省略
注意:切片不会影响序列本身,而是会得到一个新的序列(列表、元组、字符串)
# 对list进行切片,从1开始,4结束,步长1
my_list = [1,2,3,4,5,6]
result = my_list[1:4] # 步长默认是1,可以不写
print(f"结果1:{result}")
# 对tuple进行切片,从头开始,到最后结束,步长1
my_tuple = (1,2,3,4,5,6)
result = my_tuple[:] # 起始和结束不写表示从头到尾,步长默认为1
print(f"结果2:{result}")
# 对字符串进行切片,从头开始,到最后结束,步长2
my_str = "0123456"
result = my_str[::2]
print(f"结果3:{result}")
# 对字符串进行切片,从头开始,到最后结束,步长-1
my_str = "0123456"
result = my_str[::-1] # 等同于将序列反转
print(f"结果4:{result}")
# 对列表进行切片,从3开始,到1结束,步长-1
my_list = [1,2,3,4,5,6]
result = my_list[3:1:-1]
print(f"结果5:{result}")
# 对元组进行切片,从头开始,到最后结束,步长-2
my_tuple = (1,2,3,4,5,6)
result = my_tuple[::-2]
print(f"结果6:{result}")
# 结果
结果1:[2, 3, 4]
结果2:(1, 2, 3, 4, 5, 6)
结果3:0246
结果4:6543210
结果5:[4, 3]
结果6:(6, 4, 2)
集合的定义和操作
语法:{元素, 元素, ......, 元素}
特点:
- 集合内不允许重复元素(去重)
- 集合内元素是无序的(不支持下标索引)
- 可以增删改
- 支持for循环
- 可以容纳不同数据类型的数据
操作方法:
编号 | 方法 | 描述 |
---|---|---|
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(集合) | 得到一个整数,记录了集合的元素数量 |
# 定义集合
my_set = {"java", "python", "mysql", "java", "python", "mysql", "java", "python", "mysql"}
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)}")
# 添加新元素
my_set.add("redis")
my_set.add("java")
print(f"my_set添加新元素结果是:{my_set}")
# 移除元素
my_set.remove("java")
print(f"my_set移除java元素结果是:{my_set}")
# 随机取一个元素
my_set = {"java", "python", "mysql"}
element = my_set.pop()
print(f"随机取出的元素是:{element},my_set结果是:{my_set}")
# 清空集合
my_set.clear()
print(f"执行clear后结果为:{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.difference_update(set2)
print(f"消除差集的结果是:{set3}")
print(f"消除差集后,set1内容是:{set1}")
print(f"消除差集后,set2内容是:{set2}")
# 2个集合合并
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.union(set2)
print(f"合并后的结果是:{set3}")
print(f"合并后,set1内容是:{set1}")
print(f"合并后,set2内容是:{set2}")
# 统计集合元素数量len()
set1 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
num = len(set1)
print(f"集合内的元素数量是:{num}")
# 集合的遍历
# 集合不支持下标索引,所以不支持wile
for element in set1:
print(f"集合的元素有:{element}")
# 结果
my_set的内容是:{'mysql', 'java', 'python'},类型是:<class 'set'>
my_set_empty的内容是:set(),类型是:<class 'set'>
my_set添加新元素结果是:{'mysql', 'java', 'python', 'redis'}
my_set移除java元素结果是:{'mysql', 'python', 'redis'}
随机取出的元素是:mysql,my_set结果是:{'java', 'python'}
执行clear后结果为:set()
取出差集的结果是:{2, 3}
取差集后,set1内容是:{1, 2, 3}
取差集后,set2内容是:{1, 5, 6}
消除差集的结果是:{2, 3}
消除差集后,set1内容是:{2, 3}
消除差集后,set2内容是:{1, 5, 6}
合并后的结果是:{1, 2, 3, 5, 6}
合并后,set1内容是:{1, 2, 3}
合并后,set2内容是:{1, 5, 6}
集合内的元素数量是:5
集合的元素有:1
集合的元素有:2
集合的元素有:3
集合的元素有:4
集合的元素有:5
字典的定义
字典:字典可以提供基于Key检索Value的场景实现
语法:{key:value,key:value,.....}
注意事项:
- 键值对的Key和Value可以是任意类型(Key不可为字典)
- 字典内Key不允许重复,重复添加等同于覆盖原有数据
- 字典不可用下标索引,而是通过Key检索Value
# 定义字典
my_dict1 = {"蟹老板":"80", "章鱼哥":"70", "派大星":"75"}
# 空字典
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 = {"蟹老板":"80", "蟹老板":"70", "派大星":"75"}
print(f"重复key的字典内容是:{my_dict1}")
# 从字典中基于key获取value
my_dict1 = {"蟹老板":"80", "章鱼哥":"70", "派大星":"75"}
score = my_dict1["蟹老板"]
print(f"根据key:java获取的value值是:{score}")
# 定义嵌套字典
stu_score_dict = {
"蟹老板": {
"语文": 80,
"数学": 80,
"英语": 80
},
"章鱼哥": {
"语文": 70,
"数学": 75,
"英语": 60
},
"派大星": {
"语文": 74,
"数学": 79,
"英语": 78
}
}
print(f"学生的考试信息是:{stu_score_dict}")
print(f"蟹老板语文成绩是:{stu_score_dict['蟹老板']['语文']}")
# 结果
字典1的内容是:{'蟹老板': '80', '章鱼哥': '70', '派大星': '75'},类型是:<class 'dict'>
字典2的内容是:{},类型是:<class 'dict'>
字典3的内容是:{},类型是:<class 'dict'>
重复key的字典内容是:{'蟹老板': '70', '派大星': '75'}
根据key:java获取的value值是:80
学生的考试信息是:{'蟹老板': {'语文': 80, '数学': 80, '英语': 80}, '章鱼哥': {'语文': 70, '数学': 75, '英语': 60}, '派大星': {'语文': 74, '数学': 79, '英语': 78}}
蟹老板语文成绩是:80
字典的操作
注意事项:新增和更新元素的语法一致,如果Key不存在即新增,如果Key存在即更新(Key不可重复)
字典特点:
- 可以容纳多个数据
- 可以容纳不同类型的数据
- 每一份数据是Key:Value键值对
- 可以通过Key获取到Value,Key不可重复(重复会覆盖)
- 不支持下标索引
- 可以修改(增加或删除更新元素等)
- 支持for循环,不支持while循环
操作方法:
编号 | 方法 | 描述 |
---|---|---|
1 | 字典[Key] | 获取指定Key对应的Value值 |
2 | 字典[Key] = Value | 添加或更新键值对 |
3 | 字典.pop(Key) | 取出Key对应的Value并在字典内删除此Key的键值对 |
4 | 字典.clear() | 清空字典 |
5 | 字典.keys() | 获取字典的全部Key,可用于for循环遍历字典 |
6 | 字典.keys() | 计算字典内的元素数量 |
# 定义字典
my_dict = {"蟹老板": 80, "章鱼哥": 70, "派大星": 75}
# 新增元素
my_dict["海绵宝宝"] = 77
print(f"添加元素,结果:{my_dict}")
# 更新元素
my_dict["蟹老板"] = 90
print(f"修改元素,结果:{my_dict}")
# 删除元素
score = my_dict.pop("海绵宝宝")
print(f"删除海绵宝宝,分数为:{score},字典内容:{my_dict}")
# 清空字典
my_dict.clear()
print(f"字典被清空了,结果:{my_dict}")
# 获取全部key
my_dict = {"蟹老板": 80, "章鱼哥": 70, "派大星": 75}
keys = my_dict.keys()
print(f"字典的全部key是:{keys}")
# 遍历字典
# 方式一:通过获取全部key完成遍历
for key in keys:
print(f"字典1的key是:{key}")
print(f"字典1的value是:{my_dict[key]}")
# 方式二:直接对字典for循环,每一次循环都是得到的key
for key in my_dict:
print(f"字典2的key是:{key}")
print(f"字典2的value是:{my_dict[key]}")
# 统计字典的元素数量
num = len(my_dict)
print(f"字典的元素数量是:{num}")
# 结果
添加元素,结果:{'蟹老板': 80, '章鱼哥': 70, '派大星': 75, '海绵宝宝': 77}
修改元素,结果:{'蟹老板': 90, '章鱼哥': 70, '派大星': 75, '海绵宝宝': 77}
删除海绵宝宝,分数为:77,字典内容:{'蟹老板': 90, '章鱼哥': 70, '派大星': 75}
字典被清空了,结果:{}
字典的全部key是:dict_keys(['蟹老板', '章鱼哥', '派大星'])
字典1的key是:蟹老板
字典1的value是:80
字典1的key是:章鱼哥
字典1的value是:70
字典1的key是:派大星
字典1的value是:75
字典2的key是:蟹老板
字典2的value是:80
字典2的key是:章鱼哥
字典2的value是:70
字典2的key是:派大星
字典2的value是:75
字典的元素数量是:3
数据容器对比
列表 | 元组 | 字符串 | 集合 | 字典 | |
---|---|---|---|---|---|
元素数量 | 支持多个 | 支持多个 | 支持多个 | 支持多个 | 支持多个 |
元素类型 | 任意 | 任意 | 仅字符 | 任意 | Key:Value,Key:除字典外任意类型;Value:任意类型 |
下标索引 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
重复元素 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
可修改性 | 支持 | 不支持 | 不支持 | 支持 | 支持 |
数据有序 | 是 | 是 | 是 | 否 | 否 |
使用场景 | 可修改、可重复的一批数据记录场景 | 不可修改、可重复的一批数据记录场景 | 一串字符的记录场景 | 不可重复的数据记录场景 | 以Key检索Value的数据记录场景 |
数据容器通用操作
操作方法:
编号 | 方法 | 描述 |
---|---|---|
1 | 通用for循环 | 遍历容器(字典是遍历key) |
2 | max() | 容器内最大元素 |
3 | min() | 容器内最小元素 |
4 | len() | 容器元素个数 |
5 | list() | 转换为列表 |
6 | tuple() | 转换为元组 |
7 | str() | 转换为字符串 |
8 | set() | 转换为集合 |
9 | 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}
# 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("-----------------------------最大元素-----------------------------")
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("-----------------------------最小元素-----------------------------")
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("-----------------------------容器转列表-----------------------------")
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("-----------------------------容器转元组-----------------------------")
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("-----------------------------容器转字符串-----------------------------")
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("-----------------------------容器转集合-----------------------------")
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 = [5, 3, 1, 4, 2]
my_tuple = (3, 2, 1, 4, 5)
my_str = "abcdefg"
my_set = {3, 4, 5, 2, 1}
my_dict = {"key3": 1, "key5": 2, "key1": 3, "key2": 4, "key4": 5}
# 进行容器的排序
print("-----------------------------容器的排序-----------------------------")
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("---------------------------容器的反向排序----------------------------")
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': 3, 'key4': 4, 'key5': 5}
-----------------------------容器转集合-----------------------------
列表转集合的结果:{1, 2, 3, 4, 5}
元组转集合的结果:{1, 2, 3, 4, 5}
字符串转集合结果:{'a', 'd', 'e', 'f', 'c', 'g', 'b'}
集合转集合的结果:{1, 2, 3, 4, 5}
字典转集合的结果:{'key3', 'key2', 'key4', 'key1', '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']
列表对象的反向排序结果:[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']
拓展-字符串大小比较
ASCII码表,在程序中,字符串都有其对应的ASCII码表值,所用的所有字符如:
- 大小写英文单词
- 数字
- 特殊符号(!、\、|、@、#、空格等)
字符串是按位比较,也就是一位位进行对比,只要有一位大,那么整体就大。
# abd 比较 abc
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
- 字符串如何比较?:从头到尾,一位位进行比较,其中一位大,后面就无需比较了。
- 单个字符之间如何确定大小?:通过ASCII码表,确定字符对应的码值数字来确定大小