Python数据容器(组合数据类型)

Python数据容器

数据容器(组合数据类型)可以一次性存放多个数据，方便数据存储，提高效率

当需要批量存储或批量使用数据的时候，根据不同场景选用不同的组合数据类型

存储在该数据类型中的数据称为元素，每一个元素可以是任意类型数据

列表(list)

列表是一组有序项目的数据结构

列表的定义

基本语法：

• 以 [ ] 作为标识
• 列表内每一个元素之间用","（逗号）隔开

# 字面量
[元素1,元素2,元素3,...]

# 定义变量
变量名称 = [元素1,元素2,元素3,...]

# 定义空列表
变量名称 = []
变量名称 = list()

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

例子

name_list = ['Zhang3','Li4',['Zhang3','Li4'],6,True]
print(name_list)
print(type(name_list))

输出结果

['Zhang3', 'Li4', ['Zhang3', 'Li4'], 6, True]
<class 'list'>

列表的索引

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

语法：列表[下标索引]

例子

name_list = ['Zhang3','Li4',['Zhang3','Li4']]
print(name_list[0])	# 结果为 Zhang3
print(name_list[1]) # 结果为 Li4
print(name_list[2]) # 结果为 ['Zhang3','Li4']
print(name_list[2][0]) # 结果为 Zhang3

除了正向索引，Python还支持反向索引，也就是从后向前，从-1开始，依次递减

例子

print(name_list[-1]) # 结果为 Zhang3
print(name_list[-2]) # 结果为 Li4
print(name_list[-3]) # 结果为 ['Zhang3','Li4']
print(name_list[-3][-2]) # 结果为 Zhang3
# 也可以花哨点，一个正向一个反向
print(name_list[-3][0]) # 结果为 Zhang3

在使用下标索引的时候，要注意不要超出范围，超出范围会报错

列表的方法

方法概述

编号	使用方法	作用
1	列表.index(元素)	查询某元素下标
2	列表[下标]=值	修改特定位置(索引)的元素值
3	列表.insert(下标,元素)	在指定的下标位置，插入指定的元素
4	列表.append(元素)	将指定元素，追加到列表的尾部
5	列表.extend(其他数据容器)	将其他数据容器的内容取出，依次追加到列表尾部
6	del 列表[下标]/列表.pop(下标)	删除指定下标的元素，pop()有返回值，可用变量接受
7	列表.remove(元素)	删除某元素在列表中的第一个匹配项
8	列表.clear()	清空列表内容
9	列表.count(元素)	统计某元素在列表中的数量
10	len(列表)	统计列表中全部元素的功能

查询

查找某元素的下标

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

语法：列表.index(元素)

例子

my_list = ['nb','家人们谁懂啊','Nb']
index = my_list.index('nb')
print(f"nb在列表中的索引值是：{index}")  # 结果为 nb在列表中的索引值是：0

修改

修改特定位置(索引)的元素值

语法：列表[下标]=值

例子

my_list[1] = '111'	# 在Python中单引号和双引号都可以表示字符串，不过编译器输出默认是单引号
print(my_list)  # 结果为 ['nb','111','Nb']

插入元素

在指定的下标位置，插入指定的元素

语法：列表.insert(下标,元素)

例子

my_list.insert(1,666)
print(my_list)  # 结果为 ['nb',666,'111','Nb']

追加单个元素

将指定元素，追加到列表的尾部

语法：列表.append(元素)

例子

my_list.append("Hello")
print(my_list)  # 结果为 ['nb',666,'111','Nb','Hello']

追加一批元素

将其他数据容器的内容取出，依次追加到列表尾部

语法：列表.extend(其他数据容器)

例子

my_list2 = [1,2,3]
my_list.extend(my_list2)
print(my_list)	# 结果为 ['nb',666,'111','Nb','Hello',1,2,3]

删除元素(按下标删除)

删除指定下标的元素

语法1：del 列表[下标]

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

例子

my_list3 = ['a','b','c','d']
del my_list3[1]
print(my_list3)	# 结果为 ['a','c','d']
res = my_list3.pop(1)	# 结果为 ['a','d']
print(res)	# 结果为 c

删除元素(指定元素内容)

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

语法：列表.remove(元素)

my_list4 = ['a','b','c','a','a','b']
my_list4.remove('a')
print(my_list4)	# 结果为 ['b','c','a','a','b']

清空列表

清空列表内容

语法：列表.clear()

例子

my_list4.clear
print(my_list4)	# 结果为 []

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

语法：列表.count(元素)

例子

my_list5 = [1,1,1,2,3,'1']
c = my_list5.count(1)
print(c)	# 结果为 3

统计列表中全部元素的功能

语法：len(列表)

例子

c = len(my_list5)
print(c)	# 结果为 6

列表的遍历

将容器内的元素依次取出进行处理的行为，称之为：遍历、迭代

while循环

利用列表的index(下标)作为循环条件

例子

index = 0
while index < len(列表):
    元素 = 列表[index]
    对元素进行处理
    index += 1

for循环

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

语法：

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

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

在每一次循环中，我们可以对临时变量(元素)进行处理

while循环和for循环的对比

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

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

元组(tuple)

元组最主要的特征就是——不可修改

可以看作一个只读的list列表

元组的定义

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

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

例子

t1 = (1,2,3,4,5,6,7,8)
t2 = ()
t3 = tuple()
print(f"t1的数据类型是：{type(t1)}")	# 结果为 t1的数据类型是：<class 'tuple'>

print(f"t2的数据类型是：{type(t2)}")	# 结果为 t2的数据类型是：<class 'tuple'>

print(f"t3的数据类型是：{type(t3)}")	# 结果为 t3的数据类型是：<class 'tuple'>

注意：定义1个元素的元组，这个数据后面要加逗号，不然就不是元组类型了

例子

t0 = ("hello")     
print(f"t0的数据类型是：{type(t0)}")	# 结果为 t0的数据类型是：<class 'str'>
t4 = ("hello",)     
print(f"t4的数据类型是：{type(t4)}")	# 结果为 t4的数据类型是：<class 'tuple'>

元组也可以嵌套，跟list列表嵌套方式一致

元组的操作

因为元组不可修改的特性，所以比列表操作少了很多，剩下的操作也与列表差不多

编号	方法	作用
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,'hello')
print(len(t1))	# 结果为 4

元组的遍历

与list列表的操作一致，此处就不做详细说明

例子

# 元组的遍历
m = (1,2,3,4,5,6,7,8)
i = 0
print("while遍历")
while i < len(m):
    print(f"{m[i]}\t",end='')
    i += 1
print()
print("for遍历")
for i in m:
    print(f"{i}\t",end='')
print()

元组的注意事项

元组内的元素是不可以修改的，如果修改，会直接报错

但是如果元组里面嵌套了一个列表，这个列表是可以修改的

例子

my_tuple = (1,[1,2,3,4],6,7)
my_tuple[1][3]=999
print(my_tuple)		# 结果为 (1, [1, 2, 3, 999], 6, 7)

字符串(str)

字符串是字符的容器，一个字符串可以存放任意数量的字符

字符串的下标(索引)

和其它容器一样，字符串也可以通过下标进行访问

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

例子

hobby = "唱跳rap篮球"
print(hobby[1])		# 结果为 跳
print(hobby[-3])	# 结果为 p

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

字符串的常用操作

编号	操作	说明
1	字符串[下标]	取出指定下标的字符
2	字符串.index(字符串)	查找指定字符串的下标
3	字符串.replace(字符串1，字符串2)	将字符串内的全部字符串1换成字符串2
4	字符串.split(字符串)	按照指定字符串，对字符串进行切割
5	字符串.strip()	移除首尾的空格
6	字符串.strip(字符串)	移除首尾的指定字符
7	字符串.count(字符串)	统计某字符串出现的次数
8	len(字符串)	统计字符串长度

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

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

例子

my_str = "hello world,my friend"
print(my_str.index("my"))	# 结果为 12

字符串的替换

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

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

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

例子

my_str = "hello world,my friend and my dear"
new_str = my_str.replace("my","your")
print(my_str)		# 结果为 hello world,my friend and my dear
print(new_str)		# 结果为 hello world,your friend and your dear

字符串的切割

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

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

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

例子

my_str = "hello world hello China"
res = my_str.split(" ")		# 以空格作为分隔符，进行切割
print(my_str)	# 结果为 hello world hello China
print(res)		# 结果为 ['hello','world','hello','China']	编译器一般输出的是单引号

字符串规整(去前后空格)

语法：字符串.strip()

例子

my_str = "   hello world  "
print(my_str.strip())		# 结果为 hello world

字符串规整(去前后字符串)

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

my_str = "12hello 12world211212"
print(my_str.strip('12'))	# 结果为 hello 12world

注意：传入的**‘12’字符串，其实是’1’和’2’**，会将这两个字符都删除，但是只会删除前后的，遇到这两个之外的，就会停止匹配删除

统计某字符串出现的次数

语法：字符串.count(需要统计的字符串)

与列表、元组的count使用一致

例子

my_str = "hello hello world my hello"
c = my_str.count('hello')
print(c)		# 结果为 3

注意：统计过的字符串不会重复计算

例子

str = "aaaaaaaaa"	# 9个a
print(str.count("aa"))	# 结果为 4

统计字符串的长度

语法：len(字符串)

与列表、元组的len()使用一致

例子

my_str = "hello hello world my hello"
print(len(my_str))		# 结果为 26

集合(set)

自带去重功能，且内容无序

集合的定义

基本语法：

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

例子

my_set = {"hello","hello","a","b","c","d","hello"}
print(my_set)	# 结果为 {'d', 'b', 'c', 'a', 'hello'}，去重，顺序打乱，元素是无序的

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

集合的常用操作

添加新元素

将指定元素，添加到集合内

语法：集合.add(元素)

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

例子

my_set = {"a","b","c","d","e"}
my_set.add("f")
print(my_set)		# 结果为 {'a', 'c', 'b', 'f', 'd', 'e'}

移除元素

将指定元素，从集合内移除

语法：集合.remove(元素)

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

例子

my_set.remove("c")
print(my_set)		# 结果为 {'f', 'b', 'a', 'e', 'd'}

随机取出元素

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

语法：集合.pop()

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

my_set = {"a","b","c","d","e"}
my_set.pop()
print(my_set)		# 结果为 {'e', 'c', 'a', 'b'}

清空集合

语法：集合.clear()

结果：集合本身被清空

my_set = {1,2,3,4,5}
my_set.clear()
print(my_set)		# 结果为 set()

集合的运算

直接使用运算符运算

运算符	说明
s1 | s2 | s3 | …	返回s1,s2,s3…的并集
s1 & s2 & s3 & …	返回s1,s2,s3…的交集
s1 - s2 - s3 - …	返回s1,s2,s3…的差集
s1 ^ s2	返回s1,s2的对称差集
s1 == s2	s1和s2的元素相同
s1 != s2	s1和s2的元素不完全相同
s1 < s2	s1是s2的真子集
s1 <= s2	s1是s2的子集
s1 >= s2	s1是s2的超集
s1 > s2	s1是s2的纯超集

使用集合的方法进行运算

方法	说明
s1.isdisjoint(s2)	如果集合s1和s2没有共同元素，返回True，否则返回False
s1.issubset(s2)	如果集合s1是s2的子集，返回True，否则返回False
s1.issuperset(s2)	如果集合s1是s2的超集，返回True，否则返回False
s1.union(s2,…)	返回s1,s2,…的并集
s1.intersection(s2,…)	返回s1,s2,…的交集
s1.difference(s2,…)	返回s1,s2,…的差集
s1.symmetric_difference(s2)	返回s1和s2的对称差集

统计集合元素个数

语法：len(集合)

集合的遍历

因为集合不支持下标索引，所以不支持while循环遍历

for循环语法与前面的一致，都是for 临时变量 in 集合:

字典(dict)

字典最典型的特征就是：键值对

也就是：key ：value

字典的定义

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

语法：

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

字典数据的获取

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

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

所以Key值不可以重复，如果重复，会覆盖之前的Value

语法：

stu_score = {"张三": 100,"李四": 97,"王五": 99}
print(stu_score["张三"])		# 结果为 100
print(stu_score["李四"])		# 结果为 97
print(stu_score["王五"])		# 结果为 99

字典的嵌套

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

stu_score = {
    "张三": {
        "语文": 97,
        "数学": 96,
        "英语": 100},
    "李四": {
        "语文": 87,
        "数学": 86,
        "英语": 92},
    "王五": {
        "语文": 97,
        "数学": 96,
        "英语": 100}
}
print(stu_score)
# 结果为 {'张三': {'语文': 97, '数学': 96, '英语': 100}, '李四': {'语文': 87, '数学': 86, '英语': 92}, '王五': {'语文': 97, '数学': 96, '英语': 100}}

查找张三的语文成绩

print(stu_score["张三"]["语文"])	# 结果为 97

字典的常用操作

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

新增元素/更新元素

注意：因为字典的Key值不能重复，所以对已经存在的Key值进行新增操作，会覆盖原先的Value值，从而实现更新操作

语法：字典[Key] = Value

例子

my_dict = {'a': 1, 'b': 2, 'c': 3}
my_dict['d'] = 4
print(my_dict)		# 结果为 {'a': 1, 'b': 2, 'c': 3, 'd': 4}
my_dict['d'] = 999
print(my_dict)		# 结果为 {'a': 1, 'b': 2, 'c': 3, 'd': 999}

删除元素

获得指定Key的Value，同时字典被修改，指定Key的数据被删除

语法：变量 = 字典.pop(Key)

例子

my_dict = {'a': 1, 'b': 2, 'c': 3}
v = my_dict.pop('a')
print(my_dict)			# 结果为 {'b': 2, 'c': 3}
print(v)				# 结果为 1

清空元素

语法：字典.clear()

例子

my_dict = {'a': 1, 'b': 2, 'c': 3}
my_dict.clear()
print(my_dict)			# 结果为 {}

获取字典全部的Key

语法：字典.keys()

例子

my_dict = {'a': 1, 'b': 2, 'c': 3}
keys = my_dict.keys()
print(keys)				# 结果为 dict_keys(['a', 'b', 'c'])

字典的遍历

方式1：

通过keys()方法我们可以得到所有的Key值

于是我们可以通过遍历这些Key值，取出对应的Value

例子

for key in keys:
    print(key,end=' ')		# 加上end='空格'可以实现不换行输出	
    print(my_dict[key])
# 结果为 a 1
#		b 2
#		c 3

方式2：

直接对字典进行for循环，每一次循环都是直接得到Key

例子

for key in my_dict:
    print(key,end=' ')
    print(my_dict[key])
# 结果为 a 1
#		b 2
#		c 3

统计字典元素个数

语法：len(字典)

例子

my_dict = {'a': 1, 'b': 2, 'c': 3}
print(len(my_dict))			# 结果为 3

数据容器的通用操作

功能	说明
通用for循环	遍历容器(字典是遍历Key)
max()	容器内元素最大值
min()	容器内元素最小值
len()	统计容器元素个数
list()	转换为列表
tuple()	转换为元组
str()	转换为字符串
set()	转换为集合
sorted(序列,[reverse=True])	排序，如果reverse=False，表示升序

本次的Python数据容器就说到这啦，希望对大家有所帮助，数据容器的方法较多，记住常用的就好