一、数据容器定义
一种可以容纳多份数据的数据类型，每份数据称为一个元素，元素可以是字符串、数字、布尔等任意类型，分为5类：
- 列表（可修改、有序）
- 元组（不可修改、有序）
- 字符串（不可修改、有序字符容器）
- 集合（不可重复、无序）
- 字典（键值对存储）
二、列表（list）
1. 定义与索引
存储需求: 当需要存储单个数据（如姓名”TOM”）时可以使用字符串变量，但当需要存储大量相关数据（如100位学生姓名）时，使用100个单独变量效率低下。
解决方案: 列表作为数据容器可以一次性存储多个数据，解决批量数据存储问题。
- 定义语法
字面量定义: 使用中括号[]作为标识，内部元素用逗号分隔，格式为[元素1, 元素2, 元素3,…]
变量定义: 变量名称 = [元素1, 元素2, 元素3,…]
空列表定义: 变量名称 = [] 或 变量名称 = list()
元素概念: 列表中的每一份数据称为元素，元素之间必须用逗号分隔
- 下标索引
基本概念：列表中每个元素都有编号称为下标索引，从前向后从0开始递增，从后向前从-1开始递减
正向索引：第一个元素索引为0，第二个为1，依次类推（如：[“Tom”,”Lily”,”Rose”]中Tom索引0，Lily索引1）
反向索引：最后一个元素索引为-1，倒数第二个为-2（如：Rose索引-1，Lily索引-2）
嵌套取值方法：先取外层索引再取内层索引
# 示例
my_list = ["教育", 666, True, ["嵌套列表"]]
print(my_list[0]) # 输出：教育（正向索引）
print(my_list[-1][0]) # 输出：嵌套列表（嵌套索引）
2. 核心操作方法
my_list = ["教育", 666, True, ["嵌套列表"]]
# 1. 查找元素下标
index = my_list.index("教育") # 返回0
# 2. 修改元素
my_list[1] = 888 # 列表变为[“教育”,888,True,[“嵌套列表”]]
# 3. 插入元素
my_list.insert(1, "程序员") # 在索引1插入元素
# 4. 追加元素
my_list.append("黑马") # 末尾追加单个元素
my_list.extend([1,2,3]) # 末尾追加多个元素 #
#5. 删除元素
del my_list[2] # 删除索引2元素
val = my_list.pop(3) # 删除并返回索引3元素
my_list.remove(888) # 删除首个匹配元素
演示案例：删除mylist=['itcast','itheima','python']中的”python”
del mylist[2] del方式结果：['itcast','itheima']
element=mylist.pop(2) 结果['itcast','itheima']且返回”python”
3. 遍历与统计
# while循环遍历
index = 0
while index < len(my_list):
print(my_list[index])
index += 1
# for循环遍历（更简洁）
for element in my_list:
print(element)
控制方式：
while：可自定义任意循环条件
for：仅支持容器元素顺序取出
无限循环：
while：通过条件控制可实现（如while True）
for：理论上不可实现（受限于容器有限容量）
适用场景：
while：通用循环场景（如条件循环、未知次数的循环）
for：容器遍历场景（处理80%以上的循环需求）
# 统计元素数量
count = my_list.count("教育")
length = len(my_list) # 获取列表长度
4.清空列表内容
语法：列表.clear()
示例：
my_list = ["教育", 666, True, ["嵌套列表"]]
my_list.clear()
效果：列表变为空列表[]
三、元组（tuple）
1. 定义与特性
- 不可变性：定义后元素不可修改（但嵌套列表可修改内部元素）。
- 使用场景：当需要确保数据不被篡改时使用元组，如配置信息、常量集合等
- 语法：
t1 = (1, "教育", True)# 标准定义
t2 = ("单元素元组",) # 单元素需加逗号
t3 = ((1,2), [3,4]) # 嵌套元组
2. 核心操作
# 1. 取值与查找
通过t1[索引]形式访问元素
print(t1[1]) # 输出：教育（正向索引）
根据index找出特定元素的第一个匹配项
print(t1.index("教育")) # 返回1
# 2. 统计与长度
count = t1.count(1) # 统计元素出现次数
length = len(t1) # 返回元组长度（3）
# 3. 遍历（与列表相同）
for循环
for element in t1:
print(element)
while循环
index = 0
while index < len(t1):
print(my_list[index])
index += 1
3. 注意事项
尝试修改会报错！ # t1[0] = 2 # TypeError #
嵌套列表可修改 t3[1][0] = 99 # 元组变为 ((1,2), [99,4])
四、字符串（str）
1. 容器特性
- 只读性：任何修改操作会生成新字符串。
禁止操作：
修改指定下标字符：如字符串[0] = ‘a’
移除特定下标字符：如del 字符串[0]或字符串.remove()
追加字符：如字符串.append()
- 索引支持：
name = "itheima"
print(name[0]) # 输出i（正向索引）
print(name[-1]) # 输出a（反向索引）
2. 常用操作
# 1. 查找与替换
index = name.index("thei") # 返回1
new_str = name.replace("i", "I") # 生成新字符串”ItheIma”
# 2. 分割与规整
my_str = "hello,python,itheima"
按照指定分隔符将字符串划分为多个子串并存入列表
split_list = my_str.split(",") # 输出[“hello”, “python”, “itheima”]
my_str = " itheima "
stripped = my_str.strip() # 去除首尾空格 → “itheima” #
3. 统计与长度
count = name.count("i") # 统计’i’出现次数（2次）
length = len(name) # 长度7
3. 遍历与不可变性
# for循环遍历字符
for char in name:
print(char)
while循环：通过索引变量和len()函数配合实现遍历
# 不可修改性验证
# name[0] = "I" # 报错！
五、序列切片
序列的定义:连续、有序，支持下标索引的一类数据容器
1. 切片规则
- 语法：
序列[起始:结束:步长]（含起始，不含结束）。 - 适用类型：列表、元组、字符串。
- 参数说明：
起始下标：留空表示从头开始
结束下标：留空表示截取到结尾（不含结束位置本身）
步长：默认1（可省略），负数表示反向取值
- 特性：
切片操作会生成新序列，不影响原序列
反向切片时需注意起始/结束下标也要反向标记
2. 示例代码
my_list = [1, 2, 3, 4, 5, 6]
# 1. 正向切片
print(my_list[1:4]) # 输出[2, 3, 4]
# 2. 反向切片
print(my_list[-3:-1]) # 输出[4, 5]
# 3. 步长控制
print(my_list[::2]) # 步长2 → [1, 3, 5]
print(my_list[::-1]) # 反向全取 → [6, 5, 4, 3, 2, 1] #
4. 字符串切片
text = "abcdef" print(text[2:5]) # 输出”cde”
六、集合（set）
1. 定义与特性
- 自动去重：重复元素自动过滤（不支持元素重复）。
- 无序存储：元素顺序不固定。
- 基本语法：
s1 = {1, 2, 2, 3} # 实际存储 {1, 2, 3}
s2 = set() # 空集合（不可用s2 = {}，这是字典）
2. 核心操作
# 1. 添加/删除/清空元素
s1.add(4) # 添加元素 → {1,2,3,4}
s1.remove(3) # 删除元素 → {1,2,4}
s1.pop()无参数，随机取出并返回一个元素，同时从原集合中移除该元素
s1..clear()将集合清空为空状态
# 2. 集合运算
s1={1,2,4}
s2 = {2, 3, 5}
print(s1.difference(s2)) # 差集 → {1,4} 返回集合1有而集合2没有的元素组成的新集合,原集合不会被修改
s1.difference_update(s2) # 消除差集 → s1变为{1,4} ,在集合1中删除与集合2相同的元素,直接修改集合1，集合2保持不变
print(s1.union(s2)) # 并集 → {1,2,3,4,5} 返回包含两个集合所有元素的新集合（自动去重)原集合不会被修改
# 3. 遍历与统计 限制：不支持while循环遍历（因为无下标索引）
for num in s1: # 顺序不确定
print(num)
print(len(s1)) # 统计元素数量
七、字典（dict）
1. 定义与嵌套
- 键值对结构：Key不可重复，Value可任意类型。
- 应用场景：需要建立两个信息间映射关系的场景
#空字典定义：
方式1：my_dict = {}
方式2：my_dict = dict()
# 基础定义
dict1 = {"name": "张三", "age": 18}
# 嵌套字典
stu_scores = {
"王力宏": {"语文": 90, "数学": 85},
"周杰伦": {"语文": 88, "数学": 92}
}
print(stu_scores["王力宏"]["数学"]) # 输出85,字典同集合一样不可以使用下标索引，只能通过Key值来取得对应的Value
2. 核心操作
# 1. 增删改查
dict1["gender"] = "男" # 新增键值对 ,
dict1["age"] = 20 # 修改已有Key的Value ,与新增语法相同，Key存在时更新对应value值
val = dict1.pop("name") # 删除并返回”张三”
# 2.获取全部的key
key=dict1.key()
# 3. 遍历与统计
for key in dict1.keys(): # 遍历所有Key
print(f"{key}: {dict1[key]}")
字典遍历方式一:通过获取全部key完成遍历，使用for循环逐个取出key并通过key获取value
字典遍历方式二:直接对字典对象进行for循环，每次循环自动获取key
while循环限制:字典不支持下标索引，因此不能使用while循环进行遍历
print(len(dict1)) # 统计键值对数量
3. 特点总结
- 键唯一性：Key不可重复，后定义的覆盖先定义的。
- 无序性：遍历顺序与定义顺序无关（Python 3.7+ 默认保留插入顺序）。
八、数据容器对比总结
1. 特性对比表
| 容器类型 | 下标索引 | 元素重复 | 可修改性 | 有序性 | 适用场景 |
|---|---|---|---|---|---|
| 列表 | ✔️ | ✔️ | ✔️ | ✔️ | 动态数据集合 |
| 元组 | ✔️ | ✔️ | ❌ | ✔️ | 不可变配置 |
| 字符串 | ✔️ | ✔️ | ❌ | ✔️ | 文本处理 |
| 集合 | ❌ | ❌ | ✔️ | ❌ | 去重、集合运算 |
| 字典 | ❌ | Key不可重复 | ✔️ | ❌ | 键值映射 |
2. 通用操作
# 1. 类型转换
转换函数：
list(容器)：将给定容器转换为列表
str(容器)：将给定容器转换为字符串
tuple(容器)：将给定容器转换为元组
set(容器)：将给定容器转换为集合
list("abc") # → ['a','b','c']
tuple({1,2,3}) # → (1,2,3) #
#2. 统计
len(容器)：统计容器元素个数
max(容器)：找出容器最大元素
min(容器)：找出容器最小元素
#3. 排序
sorted函数：
语法：sorted(容器, [reverse=True])
参数：reverse=True表示降序排序
返回值：总是返回列表对象
注意事项：
会打乱原容器的顺序（如集合的无序性）
字典排序同样会丢失value值
排序结果会转换为列表类型
特殊说明：
字符串比较大小按ASCII码顺序（如’a'<‘g’）
字典默认比较key的大小（忽略value值）
集合/字典不支持while循环（无下标索引）
print(max("abcde")) # 输出 ‘e’（ASCII码最大）
print(sorted([3,1,2])) # → [1,2,3]（返回列表）
九、拓展：字符串大小比较
- ASCII码规则：字符按ASCII值比较（如
'a' > 'A'）。 - 逐位比较：
按位比较: 从前向后逐位比较，只要有一位大，整体就大
终止条件: 当某一位比较出结果后，后续位不再比较
空位处理: 有内容的字符串 > 无内容的空位(如”ab” > “a”)
print("apple" > "app") # True（第4位'l'存在 > 空）
print("abc" > "abd") # False（前两位相同，第三位c < d）
总结
Python的五大数据容器各具特色：
- 列表适合动态修改的序列数据
- 元组保护数据不被篡改
- 字符串专注文本处理
- 集合解决去重和集合运算
- 字典高效管理键值映射