---

前言

提示：这里可以添加本文要记录的大概内容：

今天系统学习 Python 数据容器，数据容器可以批量存储多份数据，分为列表 list、元组 tuple、字符串 str、集合 set、字典 dict五大类。本文整理全部基础语法、常用方法、实战练习与容器对比总结，零基础可直接上手。

---

一、数据容器基础概念

数据容器是能够存放多组数据的类型，内部每一份数据称为元素，元素支持数字、字符串、布尔值等任意类型。
五类容器区分：

1. 列表 []、元组 ()、字符串 ""：有序、支持下标索引，属于序列
2. 集合 {}、字典 {key:value}：无序，不支持下标索引

二、列表 List

2.1 列表定义

# 字面量
[1, 2, "python", True]
# 定义变量
my_list = ["a", "b", 666]
# 空列表两种写法
list1 = []
list2 = list()
# 嵌套列表
nest_list = [[1,2], ["a","b"]]

特点：有序、可修改、允许重复、支持正反下标。

2.2 下标索引取值

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

my_list = ["python", "linux", "mysql"]
print(my_list[0])    # python
print(my_list[-1])   # mysql
# 嵌套取值
print(my_list [0][0]) # p

2.3 列表常用操作

my_list = ["python","linux","python","mysql"]
# 1. 查询元素下标: index()
print(my_list.index("python"))
# 2. 修改指定下标元素
my_list[1] = "pandas"
# 3. 指定位置插入 insert(下标,值)
my_list.insert(2, "spark")
# 4. 末尾追加单个元素 append()
my_list.append("flink")
# 5. 批量追加容器 extend()
my_list.extend([1,2,3])
# 6. 删除指定下标 del
del my_list[0]
# 7. pop弹出元素（返回被删除的值），原列表被修改
val = my_list.pop(1)
# 8. 删除第一个匹配元素 remove()
my_list.remove("mysql")
# 9. 清空列表 clear()
my_list.clear()
# 10. 统计长度 len()
print(len(my_list))

2.4 列表遍历（while /for）

# while遍历
def list_while():
    data = ["python","pandas","requests"]
    index = 0
    while index < len(data):
        print(data[index])
        index += 1

# for遍历（推荐）
def list_for():
    data = ["python","pandas","requests"]
    for item in data:
        print(item)

2.5 练习：提取列表偶数

nums = [1,2,3,4,5,6,7,8,9,10]
even = []
i = 0
while i < len(nums):
    if nums[i] % 2 == 0:
        even.append(nums[i])
    i += 1
print("列表偶数：", even)

三、元组 Tuple

3.1 元组定义

元组不可修改，适合存放不希望被篡改的数据

# 元组变量
t = (1, "python", False)
# 定义空元组
t1 = ()
t2 = tuple()
# 嵌套元组（内部列表可修改）
stu = ("张三", 2.5, ["篮球", "music"])

3.2 元组常用方法

my_tuple = ("a","b","c","b")
# index 查询下标
print(my_tuple.index("b"))
# count 统计元素数量
print(my_tuple.count("b"))
# len 获取长度
print(len(my_tuple))
# 正反索引
print(my_tuple[0]) # a
print(my_tuple[-1]) # b 

注意：不能直接修改元组元素 my_tuple[0] = "A" 会直接报错

3.3 练习：元组内嵌列表修改

t = ("张三",2.5,["music","football"])
# 获取年龄下标
print(t.index(2.5)) # 1
# 删除爱好football
del t[2][1]
# 新增爱好
t[2].append("basketball")
print(t) # ('张三', 2.5, ['music', 'basketball'])

四、字符串 str

字符串是字符容器，不可修改，属于序列。

4.1 下标索引

s = "hello python"
print(s[0]) # h
print(s[-1]) # n
# s[0] = "H" 报错，字符串无法修改

4.2 字符串常用操作

my_str = "hello,python,linux,mysql"
# 1. index 查找子串下标
print(my_str.index("python")) # 6

# 2. replace 替换（返回新字符串，原串不变）
new_str = my_str.replace("python", "Python")
print("原字符串：", my_str) # 原字符串： hello,python,linux,mysql
print("替换后：", new_str) # 替换后： hello,Python,linux,mysql

# 3. split 分割字符串，返回列表
str_list = my_str.split(",")
print(str_list, type(str_list))
 # ['hello', 'python', 'linux', 'mysql'] <class 'list'>

# 4. strip 去除首尾空格/指定字符
s1 = "  python  "
print(s1.strip()) # python
s2 = "111python111"
print(s2.strip("1")) # python

# 5. count 统计字符/子串数量
print(s2.count("1")) # 6

# 6. len 获取字符串长度
print(len(my_str)) # 24

4.3 字符串遍历

text = "python hello"
for char in text:
    print(char,end = '') # python hello

4.4 练习 1：统计指定词语数量

content = "橙子和苹果 苹果和香蕉 香蕉和橙子"
cnt = content.count("苹果")
print(f"苹果出现次数：{cnt}") # 苹果出现次数：2
# 替换空格为|，再分割
new_s = content.replace(" ","|")
res_list = new_s.split("|")
for word in res_list:
    print(word) # 橙子和苹果
                # 苹果和香蕉
                # 香蕉和橙子

说明：
使用字符串内置方法 count() 快速统计子串出现次数；replace() 替换文本内指定字符；split() 根据分隔符切割字符串，生成列表，最后用 for 循环遍历列表所有元素。

4.5 练习 2：统计字符串字母 a 数量

count = 0
name = "I eat an apple and a banana every day"
for x in name:
    if x == 'a':
        count += 1
print(f"字符串中一共有{count}个字母a") # 9

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

序列：有序、支持下标容器（list/tuple/str）
切片语法：序列[起始下标:结束下标:步长]

• 起始：默认从头；结束：默认到末尾（不含结束下标）
• 步长正数：从左往右；步长负数：从右往左

# 列表切片
lst = [1,2,3,4,5,6,7]
print(lst[1:4]) # [2, 3, 4]
# 字符串反转
s = "pythonlinux"
print(s[::-1]) # xunilnohtyp
# 间隔取值，步长2
print(s[::2]) # ptolnx
# 反向截取
print(lst[3:1:-1]) # [4, 3]

六、集合 Set

集合无序、元素自动去重、不支持下标索引、可修改

6.1 集合定义

# 集合字面量
s = {1,2,"python"}
# 空集合只能用set()，{}是空字典
empty_set = set()

6.2 集合常用操作

my_set = {"Python","linux","mysql"}
# add 添加元素（自动去重）
my_set.add("spark")
my_set.add("Python")
# remove 删除指定元素
my_set.remove("linux")
# pop 随机取出一个元素，原集合被修改
pop_val = my_set.pop()
# clear 清空集合
my_set.clear()

# 差集、合并
set1 = {1,2,3}
set2 = {1,4,5}
print(set1.difference(set2)) # set1独有元素  {2, 3}
print(set1.union(set2))     # 合并去重  {1, 2, 3, 4, 5}
print(len(set1)) # 3
# for循环遍历
for i in set1:
    print(i)

6.3 练习：列表去重

raw_list = ['Python','pandas','Python','linux','mysql']
res_set = set()
for item in raw_list:
    res_set.add(item)
print("去重后集合：", res_set) # {'pandas', 'mysql', 'Python', 'linux'}

七、字典 dict

存储键值对 key:value，无序、key 不可重复、key 不能为字典

7.1 字典定义

# 普通字典
stu = {"name":"张三", "age":22, "sex":"男"}
# 空字典
d1 = {}
d2 = dict()
# 嵌套字典（学生成绩）
score = {
    "张三":{"语文":77,"数学":100,"英语":22},
    "李四":{"语文":88,"数学":95,"英语":33}
}
# 取值：李四的英语成绩
print(score["李四"]["英语"]) # 33

7.2 字典常用操作

my_dict = {"name":"zhangsan","age":22}
# 新增/更新元素：key存在则更新，不存在则新增
my_dict["id"] = "2026001"
my_dict["age"] = 23
# pop 删除key，返回value
name = my_dict.pop("name")
# clear 清空字典
my_dict.clear()

# 获取全部key
keys = my_dict.keys()
# 遍历字典
for key in keys:
    print(my_dict[key])
# len 统计键值对数量
print(len(my_dict))

特点：key 重复会覆盖原有数据；不支持下标索引，只能通过 key 取值。

八、五大容器通用操作

8.1 通用统计

lst = [1,2,3]
tup = (1,2,3)
s = "1234"
se = {1,2,3}
d = {"k1":1,"k2":2}

len(lst)    # 元素数量
max(lst)    # 最大值
min(lst)    # 最小值

8.2 容器互相转换

# 转列表
list(tup)
list(s)
# 转元组
tuple(lst)
# 转集合（自动去重）
set(lst)
# 转字符串（整体转为字符串文本）
str(lst)

8.3 排序 sorted ()

sorted(容器, reverse=True)，排序后统一返回列表

data = [3,1,5,2]
print(sorted(data))        # 升序   [1, 2, 3, 5]
print(sorted(data,reverse=True)) # 降序   [5, 3, 2, 1]

---

总结

1. 序列（列表 / 元组 / 字符串）支持下标、切片；集合、字典无序无下标。
2. 不可变容器：元组、字符串，修改只能生成新对象；列表、集合、字典可原地修改。
3. 集合核心作用：快速去重；字典适合存储一一对应的映射关系。
4. for 循环适合遍历所有容器；while 循环仅适合带下标索引的序列。