数据容器

• 每一个元素，可以是任意类型的数据，如字符串、数字、布尔等

• 根据特点的不同可分为 5 类：列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

二、列表（list）

# 定义列表
变量名称 = [元素1, 元素2, 元素3, 元素4, 元素5]
定义空列表
变量名称 = []
变量名称 = list()
使用举例
my_list_1 = ["一木", 20, True, ["onewood", 20]]
my_list_2 = ["一木", 20, True]
print(my_list_2)
print(type(my_list_1))
输出
['一木', 20, True]
<class 'list'>

• 以中括号 [] 作为标识

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

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

（2.2）支持反向索引

my_list = ["李白", "章北海", "杜甫"]
print(my_list[-1])  # 打印 杜甫
print(my_list[-2])  # 打印 章北海
print(my_list[-3])  # 打印 李白

（3）列表的常用操作

列表提供了一系列方法：如果将函数定义为 class（类）的成员，那么函数称之为：方法

（4.3）for 与 while 对比

在循环控制上：

while 循环可以自定循环条件，并自行控制

for 循环不可以自定循环条件，只可以一个个从容器内取出数据

在无限循环上：

while 循环可以通过条件控制做到无限循环

for 循环理论上不可以，因为被遍历的容器容量不是无限的

在使用场景上：

while 循环适用于任何想要循环的场景

for 循环适用于遍历数据容器的场景或简单的固定次数循环场景

（5）列表小结

• 列表特点：

  • 可以容纳多个元素（上限为 2**63-1、9223372036854775807 个）

  • 可以容纳不同类型的元素（混装）

  • 数据是有序存储的（有下标序号）

  • 允许重复数据存在

  • 可以修改（增加或删除元素等）

三、元组（tuple）

元组同列表一样，但一旦定义完成，就不可修改

# 定义元组
变量名称 = (元素1, 元素2, 元素3, 元素4, 元素5)
# 定义只有一个元素的元组
变量名称 = (元素1,)
# 定义空元组
变量名称 = ()
变量名称 = tuple()
my_tuple_1 = ("一木", 20, True, ("onewood", 20))
my_tuple_2 = ("一木", 20, True)
print(my_tuple_2)
print(type(my_tuple_1))
# 输出
# ('一木', 20, True)
# <class 'tuple'>
# 元组只有一个数据时，这个数据要加逗号，否则元组定义不成立
my_tuple = ("一木")
print(type(my_tuple))  # 打印 <class 'str'>
my_tuple = ("一木",)
print(type(my_tuple))  # 打印 <class 'tuple'>

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

my_tuple = (1, True, [2, 3, 4])
my_tuple[2][0] = 5
print(my_tuple)  # 打印 (1, True, [5, 3, 4])

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

my_tuple = (1, True, [2, 3, 4])
my_tuple[2] = [1, 2, 3]  # 报错

（3）元组小结

• 可以与列表一样使用 for 与 while 循环遍历

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

• 可以容纳多个数据

• 可以容纳不同类型的数据（混装）

• 数据是有序存储的（下标索引）

• 允许重复数据存在

• 不可以修改（增加或删除元素等）

四、字符串（str）

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

（2.2）替换元素

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

• 语法：字符串.replace（字符串 1，字符串 2）

name = "onewood"
new_name = name.replace("onew", "study")
print(name)  # 打印 onewood
print(new_name)  # 打印 studyood

（2.3）分割元素

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

• 语法：字符串.split（分隔符字符串）

name = "onewood,study,20"
new_list = name.split(",")
print(name)  # 打印 onewood,study,20
print(new_list)  # 打印 ['onewood', 'study', '20']
print(type(new_list))  # 打印 <class 'list'>
# 字符串按照给定的 , 进行了分割，变成多个子字符串，并存入一个列表对象中

（3）字符串小结

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

特点：

只可以存储字符串

长度任意（取决于内存大小）

支持下标索引

允许重复字符串存在

不可以修改（增加或删除元素等）

基本和列表、元组相同

不同于列表和元组的在于：字符串容器可以容纳的类型是单一的，只能是字符串类型。

不同于列表，相同于元组的在于：字符串不可修改

---

五、数据容器（序列）的切片

序列：内容连续、有序，可使用下标索引的一类数据容器

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

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

• 序列支持切片，即：列表、元组、字符串，均支持进行切片操作

（2）基本用法

用法

• 起始下标可以省略，省略从头开始

• 结束下标可以省略，省略到尾结束

• 步长可以省略，省略步长为 1（可以为负数，表示倒序执行）

• 注：

  • 这个操作对列表、元组、字符串是通用的

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

  • 起始位置、结束位置、步长（正反序）都是可以自行控制的

六、集合（set）

不支持元素的重复（自带去重功能）、并且内容无序

• 以大括号 {} 作为标识

• 集合内每一个元素之间用逗号隔开

（2）集合的遍历

集合不支持下标索引，所以也就不支持使用 while。

my_set = {"一木", True, "一木"}
for i in my_set:
    print(i)
# 打印
# True
# 一木

（4）集合小结

• 特点：

  • 可以容纳多个数据

  • 可以容纳不同类型的数据（混装）

  • 数据是无序存储的（不支持下标索引）

  • 不允许重复数据存在

  • 可以修改（增加或删除元素等）

七、字典、映射（dict）

# 定义字典
变量名称 = {key:value, key:value, key:value}
# 定义空字典
变量名称 = {}
变量名称 = dict()

• 使用 {} 存储原始，每一个元素是一个键值对

• 每一个键值对包含 Key 和 Value（用冒号分隔）

• 键值对之间使用逗号分隔

• Key 和 Value 可以是任意类型的数据（Key 不可为字典）

• Key 不可重复，重复会对原有数据覆盖

my_dict = {"一木": 99, "李白": 120, "一木": 110}
print(my_dict)  # 打印 {'一木': 110, '李白': 120}
print(type(my_dict))  # 打印 <class 'dict'>
# 获取数据
my_dict = {"李白": 120, "一木": 110}
print(my_dict["李白"])  # 打印 120

（2）数据的获取

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

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

如上，如下

# 新增元素
my_dict = {"李白": 120, "一木": 110}
my_dict["罗辑"] = 115
print(my_dict)  # 打印 {'李白': 120, '一木': 110, '罗辑': 115}
# 更新元素
my_dict = {"李白": 120, "一木": 110}
my_dict["李白"] = 115
print(my_dict)  # 打印 {'李白': 115, '一木': 110}
# 删除元素
my_dict = {"李白": 120, "一木": 110}
name = my_dict.pop("李白")
print(name)  # 打印 120
print(my_dict)  # 打印 {'一木': 110}
# 清空字典
my_dict = {"李白": 120, "一木": 110}
my_dict.clear()
print(my_dict)  # 打印 {}
# 获取全部的 Key
my_dict = {"李白": 120, "一木": 110}
my_keys = my_dict.keys()
print(my_keys)  # 打印 dict_keys(['李白', '一木'])
# 计算字典内键值对数量
my_dict = {"李白": 120, "一木": 110}
print(len(my_dict))  # 打印 2

（4）字典小结

• 特点：

  • 可以容纳多个数据

  • 可以容纳不同类型的数据

  • 每一份数据是 Key-Value 键值对

  • 可以通过 Key 获取到 Value，Key 不可重复（重复会覆盖）

  • 不支持下标索引

  • 可以修改（增加或删除更新元素等）

八、数据容器对比总结

（1）简单分类

• 是否支持下标索引

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

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

• 是否支持重复元素：

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

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

• 是否可以修改

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

  • 不支持：元组、字符串

（4）通用操作——遍历（遍历，统计，排序，转换）

• 5 类数据容器都支持 for 循环遍历

• 列表、元组、字符串支持 while 循环，集合、字典不支持（无法下标索引）

（6）通用操作——排序

• 将给定容器进行排序，排序后都会得到列表（list）对象。

• 语法：sorted（容器，[reverse=True]）

my_list = [1, 4, 2]
my_list_asc = sorted(my_list)
print(my_list_asc)  # 结果 [1, 2, 4]
my_list_des = sorted(my_list, reverse=True)
print(my_list_des)  # 结果 [4, 2, 1]

案例：学生管理系统

假设需要管理学生的基本信息、课程列表和各科成绩：

• 学号：一旦分配不可更改 → 使用 Tuple 存储：student_id = (2023001, "张三")。
• 课程列表：可能动态增减（如新增选修课） → 使用 List 存储：courses = ["数学", "物理", "化学"]。
• 成绩记录：需通过科目名称快速查询分数 → 使用 Dict 存储：scores = {"数学": 90, "物理": 85}。