数据容器

数据容器是一类可以一次性存放多份数据的数据类型，存放的每一份数据称为元素。
元素的类型可以是任意 Python 数据类型（数字、字符串、布尔值、甚至其他容器）。

根据特性不同，Python 的数据容器分为五类：

列表（list）
元组（tuple）
字符串（str）
集合（set）
字典（dict）

示意图（页面 1 图片内容文字化）：

容器中每个格子表示一个元素，可容纳任意类型的数据，例如：

[ 元素, 元素, 元素, 元素, 元素 ]

五大容器特点总结：

都可存放多个值
类型可混合（除了字符串）
有的可修改、有的不可修改
有的支持下标、有的不支持

列表（list）

列表是 Python 中使用最频繁的数据容器之一，可修改、可存放任意类型、可重复、可嵌套。

基本格式

列表使用 中括号 [] 表示，元素之间使用 逗号 , 分隔。

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

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

示例（来自 PDF page 1）：

my_list_1 = ["观止", 20, True, ["guanzhi", 20]]
my_list_2 = ["观止", 20, True]
print(my_list_2)
print(type(my_list_1))

输出：

['观止', 20, True]
<class 'list'>

下标（索引）访问

列表中的每个元素都有对应的下标索引。
访问格式：

变量 = 列表[下标]

正向索引（0 开始）

my_list = ["李白", "章北海", "杜甫"]
print(my_list[0])  # 李白
print(my_list[1])  # 章北海
print(my_list[2])  # 杜甫

反向索引（-1 开始）

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

嵌套列表索引

my_list = [["李白", "章北海"], ["罗辑", "杜甫"]]
print(my_list[0][0])  # 李白
print(my_list[0][1])  # 章北海
print(my_list[1][0])  # 罗辑
print(my_list[1][1])  # 杜甫

列表的常用操作

列表提供了一系列“方法”（methods），用于对元素进行 增、删、改、查、统计、清空、遍历 等常见操作。

以下方法不需要死记，只需知道有这些能力、需要时再查阅即可。

查询操作

index(元素) —— 查找元素下标

查找某元素在列表中的 第一个匹配项 的下标。

my_list = ["李白", "章北海", "罗辑", "杜甫"]
print(my_list.index("罗辑"))  
# 输出 2

print(my_list.index("观止"))
# 报错 ValueError: '观止' is not in list

修改元素

直接使用下标赋值即可修改指定位置的元素：

my_list = ["李白", "章北海", "罗辑", "杜甫"]
my_list[0] = "观止"
my_list[-1] = "study"
print(my_list)
# 输出 ['观止', '章北海', '罗辑', 'study']

插入元素

insert(下标, 元素)：在指定位置插入新元素。

my_list = ["李白", "章北海", "罗辑"]
my_list.insert(1, "观止")
print(my_list)
# 输出 ['李白', '观止', '章北海', '罗辑']

追加元素

append(元素) —— 追加单个元素到尾部

my_list = ["李白", "章北海", "罗辑"]
my_list.append("观止")
print(my_list)
# 输出 ['李白', '章北海', '罗辑', '观止']

extend(容器) —— 追加另一个容器的所有元素

my_list_1 = ["李白", "章北海"]
my_list_2 = ["罗辑", "观止"]
my_list_1.extend(my_list_2)
print(my_list_1)
# 输出 ['李白', '章北海', '罗辑', '观止']

删除元素

方式 1：del 列表[下标]

my_list = ["李白", "章北海", "罗辑"]
del my_list[0]
print(my_list)
# 输出 ['章北海', '罗辑']

方式 2：pop(下标) —— 删除并返回该元素

my_list = ["李白", "章北海", "罗辑"]
my_list.pop(0)
print(my_list)
# 输出 ['章北海', '罗辑']

方式 3：remove(元素) —— 删除第一个匹配项

my_list = ["李白", "章北海", "罗辑", "李白"]
my_list.remove("李白")
print(my_list)
# 输出 ['章北海', '罗辑', '李白']

清空列表

my_list = ["李白", "章北海", "罗辑"]
my_list.clear()
print(my_list)
# 输出 []

统计操作

count(元素) —— 统计出现次数

my_list = ["李白", "章北海", "罗辑", "李白"]
print(my_list.count("李白"))
# 输出 2

len(列表) —— 统计元素数量

my_list = ["李白", "章北海", "罗辑", "李白"]
print(len(my_list))
# 输出 4

遍历列表

遍历即“将容器内的元素依次取出处理”。

while 循环遍历

my_list = [1, 2, 3, 4]
index = 0

while index < len(my_list):
    num = my_list[index]
    print(num)
    index += 1

输出：

for 循环遍历

my_list = [1, 2, 3, 4]

for x in my_list:
    print(x)

输出：

for 与 while 对比（总结）

对比点	while	for
循环控制方式	条件控制	从容器逐个取值
无限循环	可以	理论上不行（容器有限）
常用场景	任意循环逻辑	遍历容器、固定循环次数

列表小结

列表的特点：

可存储多个元素（上限为 2^63−1）
可混装不同类型
有序，可下标访问
可重复
可修改（增删改查都可以）

元组（tuple）

元组与列表类似，也可以存放多个数据，但最大的区别是：

🔒 元组一旦定义完成，就不可修改。

元组常用于“数据不允许被更改”的场景，例如配置、固定参数等。

基本格式

元组使用 小括号 () 表示，元素之间用逗号分隔：

变量 = (元素1, 元素2, 元素3)

定义空元组

变量 = ()
变量 = tuple()

元组只有一个元素时的特殊写法

单元素元组必须加 逗号 ,：

t = ("观止")     # 这是字符串
t = ("观止", )  # 这是元组

嵌套元组

元组可以嵌套其他容器，包括列表、字典、元组等。

my_tuple = ((1, 2, 3), (4, 5, 6))
print(my_tuple[0][0])  # 输出 1

元组的常用操作

由于元组 不可修改，所以可用的方法非常少。

下面整理 PDF 中所有适用于元组的操作：

方法	功能说明
tuple.index(元素)	查找指定元素的第一个匹配项
tuple.count(元素)	统计元素出现次数
len(元组)	统计元组内元素数量

查询操作

按下标取值

与列表相同：

my_tuple = ("观止", True, 20)
print(my_tuple[0])  # 观止

index() 查找下标

my_tuple = ("观止", True, "观止")
print(my_tuple.index("观止"))  
# 输出 0（只返回第一个匹配项）

count() 统计数量

my_tuple = ("观止", True, "观止")
print(my_tuple.count("观止"))
# 输出 2

len() 统计长度

my_tuple = ("观止", True, "观止")
print(len(my_tuple))  
# 输出 3

注意事项（非常重要）

❌ 元组本身不可修改

例如：

my_tuple = (1, True, "观止")
my_tuple[0] = 5  
# 报错：tuple object does not support item assignment

✅ 元组内部若包含列表，则列表是可修改的

因为 列表是可变类型：

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

❌ 但元组内的列表不能被整体替换

my_tuple[2] = [1, 2, 3]  
# 报错，同样因为元组本身不可修改

元组小结

元组的特点：

可以容纳多个数据
可以混装不同类型
有序，可下标访问
允许重复
🔒 不可修改（核心特性）
可使用 for / while 遍历

与列表几乎一致，但无法进行增删改等修改操作。

字符串（str）

字符串是由字符组成的序列容器，可以存放任意数量的字符。
与元组一样，字符串是 不可修改类型（不可增删改），但可以进行查询、替换、分割等操作。

页面 9 图示（文字化）：

i  t  h  e  i  m  a
0  1  2  3  4  5  6

字符按序排列，支持下标访问。

索引取值

字符串与列表、元组一样，可以通过下标访问字符：

正向索引从 0 开始
反向索引从 -1 开始

name = "guanzhi"
print(name[0])   # g
print(name[-1])  # i

字符串的常用操作

PDF 中总结了以下操作：

操作	说明
字符串[下标]	按索引取字符
字符串.index(子串)	查找子串第一次出现的位置
字符串.replace(A, B)	将全部 A 替换为 B，生成新字符串
字符串.split(分隔符)	根据分隔符拆分成列表
字符串.strip()	去除首尾空格或指定字符
字符串.count(子串)	统计子串出现次数
len(字符串)	获取字符个数

查找元素：index()

name = "guanzhi"
print(name.index("a"))  
# 输出 2

找不到会报错。

替换元素：replace()

替换后会返回新的字符串，原字符串不变。

name = "guanzhi"
new_name = name.replace("guan", "study")
print(name)      # guanzhi
print(new_name)  # studyzhi

分割字符串：split()

根据指定字符对字符串拆分成多个部分，生成列表。

name = "guanzhi,study,20"
new_list = name.split(",")
print(new_list)
# 输出 ['guanzhi', 'study', '20']

规整操作：strip()

去首尾空格或指定字符。

name = " guanzhi "
print(name.strip())  
# 输出 guanzhi

去除指定字符：

name = "20guanzhi20"
new_name = name.strip("20")
print(new_name)
# 输出 guanzhi

统计操作

name = "20guanzhi20"

print(name.count("20"))  # 2
print(len(name))         # 12

字符串小结

字符串的特点：

只能存储字符（且属于不可修改类型）
长度不受限
支持下标访问
允许重复字符
不可修改（与元组相同）
支持 while 和 for 遍历

和列表、元组类似，但容纳的数据类型只能是字符。

序列切片（列表 / 元组 / 字符串通用）

序列（Sequence）指 内容连续、有序、可使用下标索引 的数据容器。
因此以下三种都支持切片操作：

列表（list）

元组（tuple）

字符串（str）

切片用于 从一个序列中，截取出一个子序列。

切片的基本语法
序列[起始下标 : 结束下标 : 步长]
含义说明：

起始下标：从哪里开始（可以省略，默认从头开始）

结束下标：在哪里结束（不包含该位置，可省略，默认到末尾）

步长：取元素的间隔

步长 1：一个一个取

步长 2：每隔一个取一个

步长 N：每次跳过 N-1 个元素

步长为负：反向取（下标也必须反向写）

切片不会修改原序列，而是产生一个新序列。

基本用法示例

指定开始与结束
my_list = [1, 2, 3, 4, 5]
new_list = my_list[1:4]  # 从下标 1 到 4（不含）
print(new_list)
# 输出 [2, 3, 4]
起始下标省略（从头开始）
my_tuple = (1, 2, 3, 4, 5)
new_tuple = my_tuple[:]  
print(new_tuple)
# 输出 (1, 2, 3, 4, 5)
指定步长
my_list = [1, 2, 3, 4, 5]
new_list = my_list[::2]
print(new_list)
# 输出 [1, 3, 5]
反向切片（步长为负）
my_list = [1, 2, 3, 4, 5]
new_list = my_list[3:1:-1]  # 从 3 到 1（不含 1），步长 -1
print(new_list)
# 输出 [4, 3]
字符串切片示例
my_str = "12345"
new_str = my_str[:4:2]
print(new_str)
# 输出 "13"
切片注意事项

对列表、元组、字符串 完全通用

不影响原序列，只会生成新序列

下标可正可负，步长可正可负

步长为 0 不合法（会报错）

切片总结

切片是 Python 中非常强大且高频的序列处理技能：

取子序列

反向序列处理

步长筛选

适用于所有序列类数据结构

集合（set）

集合是一种无序、不允许重复元素 的数据容器，具有天然的“去重”功能。
适合用于去重、成员判断、数学集合运算（交并差等）场景。

基本格式

集合使用大括号 {} 来表示，元素之间用逗号分隔：

变量 = {元素1, 元素2, 元素3}

定义空集合必须使用：

变量 = set()   # {} 代表空字典，不是空集合

示例：

my_set = {"观止", True, "观止"}
print(my_set)
# 输出 {True, '观止'}   # 自动去重

集合是无序结构，因此元素的输出顺序不保证固定。

集合的遍历

集合不支持下标访问（因为无序），因此：

❌ 不支持 while 循环（依赖下标）
✔ 支持 for 循环遍历

my_set = {"观止", True, "观止"}

for item in my_set:
    print(item)

输出（顺序不固定）：

True
观止

集合的常用操作

以下是 PDF 中所有集合可用的方法汇总：

操作	说明
set.add(元素)	添加元素
set.remove(元素)	移除指定元素
set.pop()	随机删除并返回一个元素
set.clear()	清空集合
A.difference(B)	取差集，得到新集合
A.difference_update(B)	差集并更新，修改集合 A
A.union(B)	取并集，得到新集合（去重）
len(set)	获取集合元素数量

增加元素：add()

my_set = {"观止", True}
my_set.add("study")
print(my_set)
# 输出 {'观止', True, 'study'}

移除元素

remove(元素)

my_set = {"观止", True}
my_set.remove("观止")
print(my_set)
# 输出 {True}

pop() —— 随机删除一个元素

my_set = {"观止", True}
num = my_set.pop()
print(my_set)
print(num)

可能输出：

{'观止'}
True

清空集合：clear()

my_set = {"观止", True}
my_set.clear()
print(my_set)
# 输出 set()

集合的数学运算

差集：difference()

取 A 中有、B 中没有的元素：

my_set_1 = {1, 2}
my_set_2 = {1, 3}

result = my_set_1.difference(my_set_2)
print(result)
# 输出 {2}

A 和 B 不发生改变。

差集更新：difference_update()

修改 A，使其变成差集结果：

my_set_1 = {1, 2}
my_set_2 = {1, 3}

my_set_1.difference_update(my_set_2)
print(my_set_1)
# 输出 {2}

并集：union()

返回 A 和 B 所有元素组成的新集合（自动去重）：

my_set_1 = {1, 2}
my_set_2 = {1, 3}

result = my_set_1.union(my_set_2)
print(result)
# 输出 {1, 2, 3}

集合长度

my_set = {1, 3}
print(len(my_set))
# 输出 2

集合小结

集合的主要特点：

元素唯一（自动去重）
无序
可存放多种数据类型
不支持下标访问
支持修改（增删）
常用于去重、集合运算、快速成员测试

字典（dict）

字典是一种以 Key（键） → Value（值） 形式存储数据的容器，与现实中的“字典查词”类似，通过键快速查找对应的值。

字典适用于需要通过“名称、标签、标识”查找数据的场景，如用户信息、成绩单、配置项等。

基本格式

字典使用大括号 {} 声明，每个元素都是 “键值对”：

变量 = {key: value, key: value}

定义空字典：

变量 = {}
变量 = dict()

示例（PDF page 15）：

my_dict = {"观止": 99, "李白": 120, "观止": 110}
print(my_dict)

输出：

{'观止': 110, '李白': 120}

说明：

键（Key）不可重复，重复时会覆盖旧值
键和值可以是任意类型（但 key 不能是字典）

字典的取值方式

字典不支持下标访问，只能通过 Key 获取对应的 Value：

my_dict = {"李白": 120, "观止": 110}
print(my_dict["李白"]) 
# 输出 120

字典支持嵌套结构：

my_dict = {
    "李白": {"语文": 110, "数学": 100},
    "观止": {"语文": 90, "数学": 120}
}

print(my_dict["李白"]["语文"])  
# 输出 110

字典的遍历

字典本质是 Key 的集合。
for 循环遍历字典时，默认遍历 Key：

my_dict = {"李白": 120, "观止": 110}

for name in my_dict:
    print(f"key为：{name}, value为：{my_dict[name]}")

输出：

key为：李白, value为：120
key为：观止, value为：110

字典的常用操作

PDF 中列出的所有字典操作如下：

操作	说明
字典[key]	通过 key 获取 value
字典[key] = value	添加或更新键值对
字典.pop(key)	删除 key 对应的键值对并返回对应的 value
字典.clear()	清空字典
字典.keys()	获取全部 key（用于遍历）
len(字典)	获取字典中键值对数量

新增元素

如果 key 不存在，就是新增：

my_dict = {"李白": 120, "观止": 110}
my_dict["罗辑"] = 115

print(my_dict)
# 输出 {'李白': 120, '观止': 110, '罗辑': 115}

更新元素

如果 key 已存在，则修改对应的 value：

my_dict = {"李白": 120, "观止": 110}
my_dict["李白"] = 115
print(my_dict)

输出：

{'李白': 115, '观止': 110}

删除元素：pop()

my_dict = {"李白": 120, "观止": 110}

value = my_dict.pop("李白")
print(value)    # 120
print(my_dict)  # {'观止': 110}

清空字典：clear()

my_dict = {"李白": 120, "观止": 110}
my_dict.clear()
print(my_dict)
# 输出 {}

获取全部 Key：keys()

my_dict = {"李白": 120, "观止": 110}
keys = my_dict.keys()
print(keys)

输出：

dict_keys(['李白', '观止'])

字典长度：len()

my_dict = {"李白": 120, "观止": 110}
print(len(my_dict))
# 输出 2

字典小结

字典的特点：

可以容纳大量数据
键值对结构清晰明了
Key 不可重复
可通过 Key 快速取 Value
数据无序，不支持下标
可修改（增删改皆可）
常用于对象信息、配置、索引关系等结构化数据场景

五大数据容器对比总结

Python 的数据容器包括：

列表 list
元组 tuple
字符串 str
集合 set
字典 dict

这五类容器在结构、可变性、是否有序、是否可重复等方面有显著区别。
以下是 PDF 最后图示内容的完整文字化说明。

可变与不可变类型

类型	是否可修改	示例说明
列表 list	✔ 可修改	可增删改查
集合 set	✔ 可修改	可增删，但无序
字典 dict	✔ 可修改	可增删改查（键唯一）
元组 tuple	✖ 不可修改	只能查不能改
字符串 str	✖ 不可修改	替换会生成新字符串

是否可存放多个数据

类型	说明
列表 list	✔ 可存多个值
元组 tuple	✔ 可存多个值
字符串 str	✔ 多个字符组成的序列
集合 set	✔ 可存多个值
字典 dict	✔ 可存多个键值对

是否可重复

类型	可否重复	说明
列表 list	✔ 可以重复	[1, 1, 1] 合法
元组 tuple	✔ 可以重复	(1, 1, 1) 合法
字符串 str	✔ 可以重复字符	“aaa” 合法
集合 set	✖ 不可重复	自动去重
字典 dict	✖ key 不可重复，但 value 可重复	后写覆盖前写

是否有序（是否支持下标）

类型	有序？	是否支持下标
列表 list	✔ 有序	✔ 支持
元组 tuple	✔ 有序	✔ 支持
字符串 str	✔ 有序	✔ 支持
集合 set	✖ 无序	✖ 不支持
字典 dict	Python3.7+ 保证插入顺序	✔ 可通过 key 获取（非下标）

总结图

能否修改内容？
    ✔ list（可）  
    ✔ set（可）  
    ✔ dict（可）  
    ✖ tuple（不可）  
    ✖ str（不可）

能否存放多个数据？
    ✔ 全部都可以（list / tuple / str / set / dict）

能否存放重复数据？
    ✔ list / tuple / str  
    ✖ set  
    ✖ dict 的 key 不能重复（value 可以）

能否使用下标？
    ✔ list / tuple / str  
    ✖ set  
    ✖ dict（只能 key 取值，非真正下标）

一句话总览五大容器

列表 list：可变、有序、可重复、支持下标（最常用）
元组 tuple：不可变、有序、可重复、支持下标（偏向固定数据）
字符串 str：不可变、有序、字符序列
集合 set：可变、无序、不重复，用于去重和集合运算
字典 dict：可变、键值对结构，Key 查 Value（结构化数据首选）