一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素
每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。
数据容器根据特点的不同，如：
是否支持重复元素
是否可以修改
是否有序，等
分为5类，分别是：
列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）
1.list列表
列表内的每一个数据，称之为元素
以 [ ] 作为标识
列表内每一个元素之间用, 逗号隔开
1.1 列表的定义
基本语法
# 定义变量
变量名称 = [元素1,元素2,元素3,....]
# 空列表
变量名称 = []
变量名称 = list()
元素的数据类型没有任何限制，甚至元素也可以是列表，这样就定义了嵌套列表
my_list = [[1,2,3], [4,5,6]]
print(f"列表为：{
my_list},数据类型为：{
type(my_list)}")
注意：列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套
1.2 列表的下标索引
从前向后的方向，从0开始，依次递增
我们只需要按照下标索引，即可取得对应位置的元素。
列表的每一个元素，都有编号称之为下标索引
从前向后的方向，编号从0开始递增
从后向前的方向，编号从-1开始递减
my_list = [[1, 2, 3], [4, 5, 6]]
# 索引
print(f"内层第一个元素为：{
my_list[0][0]}")
1.3 常用操作方法总结
列表也提供了一系列功能：
插入元素
删除元素
清空列表
修改元素
统计元素个数
等等功能，这些功能我们都称之为：列表的方法
| 编号 | 使用方式 | 作用 |
|---|---|---|
| 1 | 列表.append(元素) | 向列表中追加一个元素（尾部） |
| 2 | 列表.extend(容器) | 将数据容器的内容依次取出，追加到列表尾部 |
| 3 | 列表.insert(下标, 元素) | 在指定下标处，插入指定的元素 |
| 4 | del 列表[下标] | 删除列表指定下标元素 |
| 5 | 列表.pop(下标) | 删除列表指定下标元素 |
| 6 | 列表.remove(元素) | 从前向后，删除此元素第一个匹配项 |
| 7 | 列表.clear() | 清空列表 |
| 8 | 列表.count(元素) | 统计此元素在列表中出现的次数 |
| 9 | 列表.index(元素) | 查找指定元素在列表的下标找不到报错ValueError |
| 10 | len(列表) | 统计容器内有多少元素 |
列表有如下特点：
可以容纳多个元素（上限为2**63-1、9223372036854775807个）
可以容纳不同类型的元素（混装）
数据是有序存储的（有下标序号）
允许重复数据存在
可以修改（增加或删除元素等）
案例
有一个列表，内容是：[21, 25, 21, 23, 22, 20]，记录的是一批学生的年龄
请通过列表的功能（方法），对其进行
定义这个列表，并用变量接收它
追加一个数字31，到列表的尾部
追加一个新列表[29, 33, 30]，到列表的尾部
取出第一个元素（应是：21）
取出最后一个元素（应是：30）
查找元素31，在列表中的下标位置
# 案例
age = [21, 25, 21, 23, 22, 20]
# 追加31到尾部
age.append(31)
print(age)
# 追加一个新列表到尾部
age.extend([29,33,30])
print(age)
# 取出第一个元素
print(f"取出的第一个元素是：{
age[0]}")
# 取最后一个元素
print(f"最后一个元素：{
age[-1]}")
# 查找元素31
print(f"元素31的下标：{
age.index(31)}")
1.4 列表的遍历for/while
既然数据容器可以存储多个元素，那么，就会有需求从容器内依次取出元素进行操作。
将容器内的元素依次取出进行处理的行为，称之为：遍历、迭代。
while循环
index = 0
while index < len(列表):
元素 = 列表[index]
方法
index += 1
for循环
for 临时变量 in 数据容器:
处理操作
对比
while循环和for循环，都是循环语句，但细节不同：
在循环控制上：
while循环可以自定循环条件，并自行控制
for循环不可以自定循环条件，只可以一个个从容器内取出数据
在无限循环上：
while循环可以通过条件控制做到无限循环
for循环理论上不可以，因为被遍历的容器容量不是无限的
在使用场景上：
while循环适用于任何想要循环的场景
for循环适用于，遍历数据容器的场景或简单的固定次数循环场景
案例
定义一个列表，内容是：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
遍历列表，取出列表内的偶数，并存入一个新的列表对象中
使用while循环和for循环各操作一次
# 练习案例
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# while 循环
new_list = []
index = 0
while index < len(my_list):
if my_list[index] % 2 == 0:
new_list.append(my_list[index])
index += 1
print(new_list)
# for 循环
new_list = []
for i in my_list:
if i % 2 == 0:
new_list.append(i)
print(new_list)
2. tuple元组
元组同列表一样，都是可以封装多个、不同类型的元素在内。
但最大的不同点在于：
元组一旦定义完成，就不可修改
2.1 定义元组
定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。
变量名称 = (元素1,元素2,...)
# 定义口元组
变量名称 = ()
变量名称 = tuple()
注意：元组只有一个数据，这个数据后面要添加逗号
2.2 相关操作总结
| 编号 | 方法 | 作用 |
|---|---|---|
| 1 | index() | 查找某个数据，如果数据存在返回对应的下标，否则报错 |
| 2 | count() | 统计某个数据在当前元组出现的次数 |
| 3 | len(元组) | 统计元组内的元素个数 |
元组由于不可修改的特性，所以其操作方法非常少。
特点：
经过上述对元组的学习，可以总结出列表有如下特点：
可以容纳多个数据
可以容纳不同类型的数据（混装）
数据是有序存储的（下标索引）
允许重复数据存在
不可以修改（增加或删除元素等）
支持for循环
多数特性和list一致，不同点在于不可修改的特性。
案例
定义一个元组，内容是：（‘cxk’, 2.5, [‘football’, ‘music’]），记录的是（姓名、年龄、爱好）
请通过元组的功能（方法），对其进行
查询其年龄所在的下标位置
查询姓名
删除爱好中的football
增加爱好：coding到爱好list内
# 案例
my_tuple = ("cxk",11,["football","music"])
print(f"年龄的位置为：{
my_tuple.index(11)}")
print(f"姓名：{
my_tuple[0]}")
del my_tuple[2][0]
print(f"删除football后：{
my_tuple}")
my_tuple[2].append("coding")
print(f"增加coding到list：{
my_tuple}")
3. str字符串
尽管字符串看起来并不像：列表、元组那样，一看就是存放了许多数据的容器。
但不可否认的是，字符串同样也是数据容器的一员。
字符串是字符的容器，一个字符串可以存放任意数量的字符。
3.1 下标索引
和其它容器如：列表、元组一样，字符串也可以通过下标进行访问
从前向后，下标从0开始
从后向前，下标从-1开始
同元组一样，字符串是一个：无法修改的数据容器。
所以：
修改指定下标的字符 （如：字符串[0] = “a”）
移除特定下标的字符 （如：del 字符串[0]、字符串.remove()、字符串.pop()等）
追加字符等 （如：字符串.append()）
均无法完成。如果必须要做，只能得到一个新的字符串，旧的字符串是无法修改
3.2 常用操作总结
| 编号 | 操作 | 说明 |
|---|---|---|
| 1 | 字符串[下标] | 根据下标索引取出特定位置字符 |
| 2 | 字符串.index(字符串） | 查找给定字符的第一个匹配项的下标 |
| 3 | 字符串.replace(字符串1, 字符串2) | 将字符串内的全部字符串1，替换为字符串2不会修改原字符串，而是得到一个新的 |
| 4 | 字符串.split(字符串) | 按照给定字符串，对字符串进行分隔不会修改原字符串，而是得到一个新的列表 |
| 5 | 字符串.strip()字符串.strip(字符串) | 移除首尾的空格和换行符或指定字符串 |
| 6 | 字符串.count(字符串) | 统计字符串内某字符串的出现次数 |
| 7 | len(字符串) | 统计字符串的字符个数 |
查找特定字符串的下标索引值
语法：字符串.index(字符串)
字符串的替换
语法：字符串.replace(字符串1，字符串2）
功能：将字符串内的全部：字符串1，替换为字符串2
注意：不是修改字符串本身，而是得到了一个新字符串
字符串的分割
语法：字符串.split(分隔符字符串）
功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
注意：字符串本身不变，而是得到了一个列表对象
字符串去除空格
语法：字符串.strip() #去除两端空格
统计字符串中某字符串的出现次数count
统计字符串的长度len
字符串的遍历
同列表、元组一样，字符串也支持while循环和for循环进行遍历
3.3 字符串的特点
作为数据容器，字符串有如下特点：
只可以存储字符串
长度任意（取决于内存大小）
支持下标索引
允许重复字符串存在
不可以修改（增加或删除元素等）
支持for循环
基本和列表、元组相同
不同与列表和元组的在于：字符串容器可以容纳的类型是单一的，只能是字符串类型。
不同于列表，相同于元组的在于：字符串不可修改
案例
给定一个字符串：“itcsdn itcast sb”
统计字符串内有多少个"it"字符
将字符串内的空格，全部替换为字符：“|”
并按照"|"进行字符串分割
my_list = "itcsdn itcast sb"
print(f"有{
my_list.count('it')}个it字符")
new_list = my_list.replace(" ", "|")
print(f"替换|后的字符串为：{
new_list}")
new1_list = my_list.split("|")
print(f"按|分割字符串为：{
new1_list}")
4. 序列的切片
序列是指：内容连续、有序，可使用下标索引的一类数据容器
列表、元组、字符串，均可以可以视为序列。
序列的典型特征就是：有序并可用下标索引，字符串、元组、列表均满足这个要求
切片：从一个序列中，取出一个子序列
序列[起始下标:结束下标:步长]
# 表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列
起始下标表示从何处开始，可以留空，留空视作从头开始
结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
步长表示，依次取元素的间隔
步长1表示，一个个取元素
步长2表示，每次跳过1个元素取
步长N表示，每次跳过N-1个元素取
步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）
注意，此操作不会影响序列本身，而是会得到一个新的序列（列表、元组、字符串）
序列的切片实战
有字符串：“作工的误错做合适不，短太命生”
使用切片得到"生命太短"
my_str1 = "作工的误错做合适不，短太命生"
new_str1 = my_str1[-1:-5:-1]
print(f"切片字符串为：{
new_str1}")
5. set集合
集合，最主要的特点就是：不支持元素的重复（自带去重功能）、并且内容无序
# 定义集合变量
定义集合变量 = {
元素,元素,....,元素}
# 定义空集合
变量名称 = set()
和列表、元组、字符串等定义基本相同
列表使用：[]
元组使用：()
字符串使用：“”
集合使用：{}
5.1 集合的常用操作 - 修改
首先，因为集合是无序的，所以集合不支持：下标索引访问
但是集合和列表一样，是允许修改的
添加新元素
# 语法
集合.add(元素) #将指定元素，添加到集合内
# 结果：集合本身被修改，添加了新元素
移除元素
# 语法
集合.remove(元素) # 将指定元素，从集合内移除
# 结果：集合本身被修改，移除了元素
从集合中随机取出元素
# 语法
集合.pop() #功能，从集合中随机取出一个元素
# 结果：会得到一个元素的结果。同时集合本身被修改，元素被移除
清空集合
# 语法
集合.clear() # 功能，清空集合
# 结果：集合本身被清空
5.3 集合的常用操作 - 两个集合
取出2个集合的差集
# 语法
集合1.difference(集合2) # 功能：取出集合1和集合2的差集（集合1有而集合2没有的）
# 结果：得到一个新集合，集合1和集合2不变
eg
# 取两个集合的差集difference
set1 = {
1,3,5,7,9}
set2 = {
2, 4, 5, 7, 9}
set3 = set1.difference(set2)
print(f"两个集合的差集为：{
set3}")
print(f"原集合set1：{
set1}")
print(f"原集合set2：{
set2}")
消除2个集合的差集
# 语法
集合1.difference_update(集合2) #功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素。
# 结果：集合1被修改，集合2不变
set1 = {
1,3,5,7,9}
set2 = {
2, 4, 5, 7, 9}
set1.difference_update(set2)
print(f"消除两个集合的差集为：{
set1}")
print(f"原集合set2：{
set2}")
2个集合合并
语法：集合1.union(集合2)
功能：将集合1和集合2组合成新集合
结果：得到新集合，集合1和集合2不变
set1 = {
1,3,5,7,9}
set2 = {
2, 4, 5, 7, 9}
set3 = set1.union(set2)
print(f"两个集合为：{
set3}")
print(f"原集合set1：{
set1}")
print(f"原集合set2：{
set2}")
5.2 集合的常用操作 - 集合长度
# 查看集合的元素数量
语法：len(集合)
功能：统计集合内有多少元素
结果：得到一个整数结果
5.3 集合的常用操作 - for循环遍历
集合同样支持使用for循环遍历（语法同上）
集合是无序的
要注意：集合不支持下标索引，所以也就不支持使用while循环。
5.4 集合常用功能总结
| 编号 | 操作 | 说明 |
|---|---|---|
| 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循环
案例
有如下列表对象：
my_list = [‘我’, ‘是’, ‘小趴菜’, ‘小趴菜’, ‘cai’, ‘cai’, ‘da’, ‘sa’, ‘bi’]
请：
定义一个空集合
通过for循环遍历列表
在for循环中将列表的元素添加至集合
最终得到元素去重后的集合对象，并打印输出
## 案例
my_set = set()
my_list = ['我', '是', '小趴菜', '小趴菜', 'cai', 'cai', 'da', 'sa', 'bi']
for i in my_list:
my_set.add(i)
print(my_set)
6. dict字典
为什么使用字典？
因为可以使用字典，实现用key取出Value的操作
6.1 字典的定义
字典的定义，同样使用{}，不过存储的元素是一个个的：键值对，如下语法：
# 定义字典变量
my_dict = {
key: value}
# 定义空字典
my_dict = {
}
my_dict = dict()
- 使用{}存储原始，每一个元素是一个键值对
- 每一个键值对包含Key和Value（用冒号分隔）
- 键值对之间使用逗号分隔
- Key和Value可以是任意类型的数据（key不可为字典）
- Key不可重复，重复会对原有数据覆盖
6.2 字典的嵌套及获取
获取
字典同集合一样，不可以使用下标索引
但是字典可以通过Key值来取得对应的Value
嵌套
字典的Key和Value可以是任意数据类型（Key不可为字典）
那么，就表明，字典是可以嵌套的
需求如下：记录学生各科的考试信息
| 姓名 | 语文 | 数学 | 英语 |
|---|---|---|---|
| 小王 | 60 | 70 | 80 |
| 小趴 | 78 | 80 | 90 |
| 小菜 | 66 | 77 | 88 |
## 记录学生成绩
stu_score = {
"小王": {
'语文':60, "数学":70, "英语":80},
"小趴": {
'语文':78, "数学":80, "英语":90},
"小菜": {
'语文': 66, "数学": 77, "英语": 88}
}
# 获取值
print(f"小王的成绩为：{
stu_score['小王']}")
print(f"小趴的语文成绩为：{
stu_score['小趴']['语文']}")
6.3 字典的常用操作
- 新增元素
语法：字典[Key] = Value
结果：字典被修改，新增了元素
stu_score = {
"小王": {
'语文':60, "数学":70, "英语":80},
"小趴": {
'语文':78, "数学":80, "英语":90},
"小菜": {
'语文': 66, "数学": 77, "英语": 88}
}
# 新增
stu_score["大菜"] = {
'语文': 66, "数学": 77, "英语": 88}
print(f"新增后：{
stu_score}")
- 更新元素
语法：字典[Key] = Value，结果：字典被修改，元素被更新
注意：字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值
stu_score = {
"小王": {
'语文':60, "数学":70, "英语":80},
"小趴": {
'语文':78, "数学":80, "英语":90},
"小菜": {
'语文': 66, "数学": 77, "英语": 88}
}
# 更新
stu_score["小菜"] = {
'语文': 67, "数学": 78, "英语": 89}
print(f"更新后：{
stu_score}")
- 删除元素
语法：字典.pop(Key)
结果：获得指定Key的Value，同时字典被修改，指定Key的数据被删除
stu_score = {
"小王": {
'语文':60, "数学":70, "英语":80},
"小趴": {
'语文':78, "数学":80, "英语":90},
"小菜": {
'语文': 66, "数学": 77, "英语": 88}
}
# 删除pop
value = stu_score.pop("小王")
print(f"删除的值：{
value}")
print(f"删除后的原数据：{
stu_score}")
- 清空字典
语法：字典.clear()
结果：字典被修改，元素被清空
stu_score = {
"小王": {
'语文':60, "数学":70, "英语":80},
"小趴": {
'语文':78, "数学":80, "英语":90},
"小菜": {
'语文': 66, "数学": 77, "英语": 88}
}
# 清除字典
stu_score.clear()
print(f"清除后：{
stu_score}")
- 获取全部的key
语法：字典.keys()
结果：得到字典中的全部Key
stu_score = {
"小王": {
'语文':60, "数学":70, "英语":80},
"小趴": {
'语文':78, "数学":80, "英语":90},
"小菜": {
'语文': 66, "数学": 77, "英语": 88}
}
keys = stu_score.keys()
print(f"所有的键为：{
keys}")
- 遍历字典
语法：for key in 字典.keys()
stu_score = {
"小王": {
'语文':60, "数学":70, "英语":80},
"小趴": {
'语文':78, "数学":80, "英语":90},
"小菜": {
'语文': 66, "数学": 77, "英语": 88}
}
keys = stu_score.keys()
for key in keys:
print(f"学生：{
key}, 分数：{
stu_score[key]}")
注意：字典不支持下标索引，所以同样不可以用while循环遍历
- 计算字典内的全部元素（键值对）数量
语法：len(字典)
结果：得到一个整数，表示字典内元素（键值对）的数量
6.4 字典的常用操作总结
| 编号 | 操作 | 说明 |
|---|---|---|
| 1 | 字典[Key] | 获取指定Key对应的Value值 |
| 2 | 字典[Key] = Value | 添加或更新键值对 |
| 3 | 字典.pop(Key) | 取出Key对应的Value并在字典内删除此Key的键值对 |
| 4 | 字典.clear() | 清空字典 |
| 5 | 字典.keys() | 获取字典的全部Key，可用于for循环遍历字典 |
| 6 | len(字典) | 计算字典内的元素数量 |
案例
有如下员工信息，请使用字典完成数据的记录。
并通过for循环，对所有级别为1级的员工，级别上升1级，薪水增加1000元
| 姓名 | 部门 | 工资 | 级别 |
|---|---|---|---|
| 小王 | 科技部 | 8000 | 1 |
| 小趴 | 市场部 | 6000 | 2 |
| 小菜 | 人事部 | 7000 | 1 |
| 大趴 | 市场部 | 4000 | 3 |
| 大菜 | 科技部 | 5000 | 2 |
# 组织字典记录数据
info_dict = {
"小王": {
"部门": "科技部","工资": 8000,"级别": 1
},
"小趴": {
"部门": "市场部","工资": 6000,"级别": 2
},
"小菜": {
"部门": "人事部","工资": 7000,"级别": 1
},
"大趴": {
"部门": "市场部","工资": 4000,"级别": 3
},
"大菜": {
"部门": "科技部","工资": 5000,"级别": 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["级别"] = 2 # 级别+1
employee_info_dict["工资"] += 1000 # 工资+1000
# 将员工的信息更新回info_dict
info_dict[name] = employee_info_dict
# 输出结果
print(f"对员工进行升级加薪后的结果是：{
info_dict}")
7. 总结
7.1 数据容器分类
数据容器可以从以下视角进行简单的分类：
是否支持下标索引
- 支持：列表、元组、字符串 - 序列类型
- 不支持：集合、字典 - 非序列类型
是否支持重复元素
- 支持：列表、元组、字符串 - 序列类型
- 不支持：集合、字典 - 非序列类型
是否可以修改
- 支持：列表、集合、字典
- 不支持：元组、字符串
| 列表 | 元组 | 字符串 | 集合 | 字典 | |
|---|---|---|---|---|---|
| 元素数量 | 支持多个 | 支持多个 | 支持多个 | 支持多个 | 支持多个 |
| 元素类型 | 任意 | 任意 | 仅字符 | 任意 | Key：ValueKey：除字典外任意类型Value：任意类型 |
| 下标索引 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
| 重复元素 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
| 可修改性 | 支持 | 不支持 | 不支持 | 支持 | 支持 |
| 数据有序 | 是 | 是 | 是 | 否 | 否 |
| 使用场景 | 可修改、可重复的一批数据记录场景 | 不可修改、可重复的一批数据记录场景 | 一串字符的记录场景 | 不可重复的数据记录场景 | 以Key检索Value的数据记录场景 |
7.2 容器通用功能
| 功能 | 描述 |
|---|---|
| 通用for循环 | 遍历容器（字典是遍历key） |
| max | 容器内最大元素 |
| min() | 容器内最小元素 |
| len() | 容器元素个数 |
| list() | 转换为列表 |
| tuple() | 转换为元组 |
| str() | 转换为字符串 |
| set() | 转换为集合 |
| sorted(序列, [reverse=True]) | 排序，reverse=True表示降序得到一个排好序的列表 |