【Python入门】第5节 数据容器

学习数据容器，就是为了批量存储或批量使用多份数据。

1.什么是数据容器？

• 一种可以存储多个元素的Python数据类型

2.Python有哪些数据容器？

• list(列表)、tuple(元组)、str(字符串)、set(集合)、dict(字典)

它们各有特点，但都满足可容纳多个元素的特性。

✅数据容器：list(列表)

• 列表的定义
• 列表的下标索引
• 列表的常用操作

🧊列表的定义：

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

• 以 [] 作为标识

• 列表内每一个元素之间用, 逗号隔开

#定义列表
变量名称 = [元素1，元素2，元素3，...]#定义空列表
变量名称 = []
变量名称 = list()

🧊列表的下标索引:

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

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

如图，从后向前，下标索引为：-1、-2、-3，依次递减。

#语法：列表[标号]
name_list ['Tom','Lily','Rose']
print(name_list[-1])	#结果：Rose
print(name_list[-2])	#结果：LiTy
print(name_list[-3])		#结果：Tom

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

#2层嵌套list
my_list=[[1,2,3],[4,5,6]]
#获取内层第一个1ist
print(my_list[0])		#结果：[1,2,3]#获取内层第一个1ist的第一个元素
print(my_list[0][0])	#结果：1

下标索引的注意事项：

• 要注意下标索引的取值范围，超出范围无法取出元素，并且会报错

🧊列表的常用操作（方法）

列表除了可以：

• 定义
• 使用下标索引获取值

以外，列表也提供了一系列功能：

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

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

查找某元素的下标：列表.index(元素)

my_list ["itheima","itcast","python"]
print(my_list.index("itcast"))		#结果：1

修改特定位置（索引）的元素值：列表[下标] = 值

#正向下标
my_list=[1,2,3]
my_list[0]=5
print(my_list)		#结果：[5,2,3]#反向下标
my_list=[1,2,3]
my_list[-3]=5
print(my_list)#结果：[5,2,3]

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

my_list=[1,2,3]
my_list.insert(1,"itheima")
print(my_list)		#结果：[1，"itheima",3,4]

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

my_list=[1,2,3]
my_list.append(4)
print(my_list)		#结果：[1,2,3,4]my_1ist=[1,2,3]
my_list.append([4,5,6])
print(my_list)		#结果：[1,2,3，[4,5,6]]

追加元素方式2：列表.extend(其它数据容器)，将其它数据容器的内容取出，依次追加到列表尾部

my_list=[1,2,3]
my_list.extend([4,5,6])
print(my_list)
#结果：[1,2,3,4,5,6]

删除元素：

• del 列表[下标]
• 列表.pop(下标)
• 删除某元素在列表中的第一个匹配项:列表.remove(元素)
• 清空列表内容，语法：列表.clear()

my_list=[1,2,3]#方式1
del my_list[0]
print(my_1ist)	#结果：[2,3]#方式2
my_list.pop(0)
print(my_1ist)	#结果：[2,3]

my_list=[1,2,3,2,3]
my_list.remove(2)
print(my_list)#结果：[1,3,2,3]

my_list=[1,2,3]
my_list.clear()
print(my_list)		#结果：[]

统计某元素在列表内的数量:列表.count(元素)

my_list=[1,1,1,2,3]
print(my_list.count(1))	 	#结果：3

🧊list（列表）的遍历

• while循环：循环条件为 下标值 < 列表的元素数量

• for循环

✅数据容器：tuple(元组)

🧊元组的定义

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

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

注意事项:

• 元组只有一个数据，这个数据后面要添加逗号
• 元组也支持嵌套

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

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

🧊元组的操作

注意事项:

• 元组由于不可修改的特性，所以其操作方法非常少。

• 可以修改元组内的list的内容（修改元素、增加、删除、反转等）

• 不可以替换list为其它list或其它类型

#尝试修改元组内容
t1=(1,2,3)
t1[0] = 5 #直接报错！！！

#尝试修改元组内容
t1 (1,2,['itheima','itcast'])
t1[2][1]='best'
print(tl)	#结果：(1,2，['itheima','best'])

#尝试修改元组内容
t1 (1,2,['itheima','itcast'])
t1[2]=[1,2,3]
print(t1) #直接报错！！！

🧊元组的遍历

同列表一样，元组也可以被遍历，可以使用while循环和for循环遍历它。

🧊元组的特点

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

多数特性和list一致，不同点在于不可修改的特性。

✅数据容器：str(字符串)

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

如，字符串：“itheima”

🧊字符串的下标（索引）

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

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

同元组一样，字符串是一个：无法修改的数据容器。
所以下面操作均无法完成。如果必须要做，只能得到一个新的字符串，旧的字符串是无法修改：

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

🧊字符串的常用操作

🧊字符串的遍历

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

🧊字符串的特点

• 作为数据容器，字符串有如下特点：
• 只可以存储字符串
• 长度任意（取决于内存大小）
• 支持下标索引
• 允许重复字符串存在
• 不可以修改（增加或删除元素等）
• 支持for循环

✅数据容器的切片

1.了解什么是序列

2.掌握序列的切片操作

🧊序列

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

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

🧊切片

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

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

• 起始下标表示从何处开始，可以留空，留空视作从头开始

• 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾

• 步长表示，依次取元素的间隔

  • 步长1表示，一个个取元素
  • 步长2表示，每次跳过1个元素取
  • 步长N表示，每次跳过N-1个元素取
  • 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）

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

序列的切片演示：

my_list = [1, 2, 3, 4, 5]
new_list = my_list[1:4]	# 下标1开始，下标4（不含）结束，步长1
print(new_list)				# 结果：[2, 3, 4]

my_tuple = (1, 2, 3, 4, 5)
new_tuple = my_tuple[:]	 # 从头开始，到最后结束，步长1
print(new_tuple)			 # 结果：(1, 2, 3, 4, 5)

my_list = [1, 2, 3, 4, 5]
new_list = my_list[::2]		# 从头开始，到最后结束，步长2
print(new_list)				   # 结果：[1, 3, 5]

my_str = "12345"
new_str = my_str[:4:2]	# 从头开始，到下标4（不含）结束，步长2
print(new_str)				# 结果："13"

my_list = [1, 2, 3, 4, 5]
new_list = my_list[3:1:-1]	# 从下标3开始，到下标1（不含）结束，步长-1（倒序）
print(new_list)				     # 结果：[4, 3]

• 起始可以省略，省略从头开始
• 结束可以省略，省略到尾结束
• 步长可以省略，省略步长为1（可以为负数，表示倒序执行）

✅数据容器：set(集合)

1.掌握集合的定义格式

2.掌握集合的特点

3.掌握集合的常见操作

🧊集合的定义

基本语法：

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

🧊集合的特点

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

可以总结出集合有如下特点：

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

🧊集合的常用操作

集合1.difference(集合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}不变

集合1.difference_update(集合2):

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

集合1.union(集合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不变

🧊集合的常用操作

只支持for循环遍历,集合不支持下标索引，所以也就不支持使用while循环。

set1={1,2,3}
for i in set1:
print(i)
#结果
1
2
3

✅数据容器：dict(字典、映射)

为什么需要字典？Python中字典和生活中字典十分相像，因为可以使用字典，实现用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可以是任意类型的数据（key不可为字典）
• Key不可重复，重复会对原有数据覆盖

字典数据的获取:

字典同集合一样，不可以使用下标索引,但是字典可以通过Key值来取得对应的Value

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

字典的嵌套:

字典的嵌套有点像json数据结构，注意字典的Key和Value可以是任意数据类型（Key不可为字典）

stu_score = {
"王力鸿"：{"语文"：77，"数学"：66，"英语"：33}，
"周杰轮"：{"语文"：88，"数学"：86，"英语"：55}，
"林俊节"：{"语文"：99，"数学"：96，"英语"：66}
}print(stu_score["王力鸿"])				  #结果：{"语文"：77，"数学"：66，"英语"：33]
prnt(stu_score["王力鸿"]["语文"])	#结果：77
print(stu_score["周杰轮"]["数学"])	#结果：86

字典的注意事项:

• 键值对的Key和Value可以是任意类型（Key不可为字典）
• 字典内Key不允许重复，重复添加等同于覆盖原有数据
• 字典不可用下标索引，而是通过Key检索Value

🧊字典的常用操作

1.掌握字典的常用操作

2.掌握字典的特点

新增元素：语法：字典[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
}
Va1ue=stW_score.pop("王力鸿")
print(value)			#结果：77
print(stu_score)	#结果：{"周杰轮"：88，"林俊节"：99}

清空字典：

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

获取全部的key:

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

遍历字典：

stu_score = {
"王力鸿"：77，
"周杰轮"：88，
"林俊节"：99
}
keys stu_score.keys()
for key in keys:
print(f"学生：{key}，分数：{stu_score[key]}")

✅数据容器对比总结

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

• 是否支持下标索引

  • 支持：列表、元组、字符串 - 序列类型
  • 不支持：集合、字典 - 非序列类型

• 是否支持重复元素：

  • 支持：列表、元组、字符串 - 序列类型

  • 不支持：集合、字典 - 非序列类型

• 是否可以修改

  • 支持：列表、集合、字典

  • 不支持：元组、字符串

数据容器特点对比:

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

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

✅数据容器的通用操作

​

📖入门思维导图