一篇文章吃透Python五大数据容器（附新手友好案例）

A5139211

839人浏览 · 2026-07-24 18:20:23

A5139211 · 2026-07-24 18:20:23 发布

你是否也曾经为"变量太多记不住名字"而头疼？别急，数据容器就是为你量身打造的"收纳神器"。本文将用最贴近生活的案例，带你一次搞懂列表、字符串、元组、字典、集合这五大金刚，顺便把推导式这个"一行代码神器"也收入囊中。

一、为什么需要数据容器？

先来看一个扎心的场景。

你想跟朋友斗嘴，Python里需要存储这几句对话：

msg1 = "你好"
msg2 = "哎呀，你终于来啦，想我没"
msg3 = "没"
msg4 = "你可真行！晚上锅包肉没你的份"
msg5 = "我不吃"

才五句话就要定义五个变量，如果是一百句呢？变量名从 msg1 编到 msg100，光是起名字就能让人崩溃。

这时候，数据容器就像一个大背包，帮我们把一堆数据"打包"装在一起：

dialogue = [
    "你好",
    "哎呀，你终于来啦，想我没",
    "没",
    "你可真行！晚上锅包肉没你的份",
    "我不吃",
    "那更好，我自己吃，馋死你！"
]

一份数据，一个变量名，干净利落。

什么是数据容器？

数据容器，就是可以一次性容纳多份数据的数据类型。里面的每一份数据叫做一个元素，元素可以是任意类型：字符串、数字、布尔值，甚至混合着放也没问题。

Python里最常用的数据容器有五种：列表、字符串、元组、字典、集合。它们各有各的脾气和用途，下面逐一拆解。

二、列表（list）—— 啥都能装的"万能背包"

2.1 列表长什么样？

列表用方括号 [] 定义，元素之间用逗号隔开：

# 一个典型的列表
shopping_cart = ["苹果", "香蕉", "牛奶", 3, 2.5, True]
#                字符串  字符串  字符串  数字  浮点  布尔

特点就三句话：

可以装不同类型的元素（字符串和数字混着放没问题）
有序 —— 元素有固定的先后顺序
可以修改 —— 随时增删改

2.2 如何访问列表中的元素？

既然列表是有序的，每个元素都有自己的"座位号"，也就是索引（下标）。

💡 记住这组数字：正索引从 0 开始，反索引从 -1 开始。

s = ["苹果", "香蕉", "牛奶", "面包", "鸡蛋"]

# 正索引：从0开始
print(s[0])   # 苹果
print(s[3])   # 面包

# 反索引：从-1开始（从末尾往前数）
print(s[-1])  # 鸡蛋
print(s[-3])  # 牛奶

增删改查操作一览：

cart = ["苹果", "香蕉", "牛奶"]

# 查（访问）
print(cart[0])          # 苹果

# 改
cart[1] = "芒果"         # 把香蕉换成芒果
print(cart)             # ['苹果', '芒果', '牛奶']

# 增
cart.append("火龙果")    # 尾部追加
cart.insert(1, "草莓")   # 在索引1的位置插入
print(cart)             # ['苹果', '草莓', '芒果', '牛奶', '火龙果']

# 删
del cart[0]             # 删除索引0的元素
cart.remove("芒果")      # 删除第一个匹配到的"芒果"
last = cart.pop()       # 删除最后一个元素并返回它
print(cart)

⚠️ 新手易错点：访问不存在的索引会报错 IndexError。比如列表长度是5，你访问 s[10]，程序当场崩溃。

2.3 切片 —— 截取列表的一部分

切片就像用刀切面包，切出你想要的中间那一块。

s = ["A", "B", "C", "D", "E", "F", "G"]

# 语法：s[开始索引 : 结束索引 : 步长]
# 注意：包含开始，不包含结束

print(s[0:4])      # ['A', 'B', 'C', 'D']（索引0到3）
print(s[2:5])      # ['C', 'D', 'E']
print(s[:4])       # ['A', 'B', 'C', 'D']（省略开始，默认0）
print(s[2:])       # ['C', 'D', 'E', 'F', 'G']（省略结束，直到末尾）

# 步长：每隔几个取一个
print(s[0:6:2])    # ['A', 'C', 'E']（步长为2，隔一个取一个）

# 步长为负数：从后往前取
print(s[::-1])     # ['G', 'F', 'E', 'D', 'C', 'B', 'A']（反转！）

💡 小贴士：s[::-1] 是反转列表的经典写法，记得收藏。

2.4 列表常用方法速查表

方法	作用	示例
`append(元素)`	在尾部追加一个元素	`s.append(99)`
`insert(索引, 元素)`	在指定位置插入元素	`s.insert(0, 88)`
`remove(元素)`	删除第一个匹配的元素	`s.remove(75)`
`pop(索引)`	删除并返回指定位置元素（默认末尾）	`s.pop(2)` 或 `s.pop()`
`sort()`	从小到大排序（元素类型需一致）	`s.sort()`
`reverse()`	反转列表顺序	`s.reverse()`

2.5 ✨ 生活案例：管理你的月度开销

场景：用列表记录每天的开销，计算总支出、最高单日消费，看看有没有超预算的日子。

# 某月前10天的开销（单位：元）
daily_expenses = [35, 68, 120, 45, 200, 78, 150, 32, 95, 210]

# 1. 总开销
total = sum(daily_expenses)
print(f"10天总开销：{total}元")

# 2. 最高单日消费
max_expense = max(daily_expenses)
print(f"最高单日消费：{max_expense}元")

# 3. 消费超过100元的日子（用列表推导式，后面会细讲）
high_days = [i+1 for i, v in enumerate(daily_expenses) if v > 100]
print(f"超预算（>100元）的日子：第{high_days}天")

# 4. 月末复盘：找出花钱最多的前三名（排序后取后三个）
sorted_expenses = sorted(daily_expenses)  # 从小到大
top3 = sorted_expenses[-3:]               # 切片取最后三个
print(f"开销最高的三天：{top3}")

运行结果示例：

10天总开销：1033元
最高单日消费：210元
超预算（>100元）的日子：第[3, 5, 7, 10]天
开销最高的三天：[150, 200, 210]

三、字符串（str）—— 字符们排成的"方阵"

3.1 字符串也是数据容器？

没错！字符串本质上是一个字符的序列。你可以把字符串 "Python" 看成是 'P'、'y'、't'、'h'、'o'、'n' 这六个字符排成一队。

有序：每个字符有自己的索引位置
可遍历：可以用 for 循环一个一个取出字符
不可修改：这是和列表最大的区别！你没法改字符串里的某个字符

s = "Hello-Python"

# 通过索引访问字符（和列表一样）
print(s[0])   # H
print(s[-1])  # n

# 遍历每个字符
for ch in s:
    print(ch)

# 切片也完全一样
print(s[0:5])    # Hello
print(s[6:])     # Python
print(s[::-1])   # nohtyP-olleH（反转字符串）

3.2 字符串的不可变性

字符串一旦创建，就无法修改其中的某个字符：

s = "Hello"
# s[0] = "h"   # 这行会报错！TypeError

如果想得到修改后的新字符串，只能创建一个新的：

s = "Hello"
new_s = "h" + s[1:]   # 用"h"替换掉"H"
print(new_s)           # hello

3.3 字符串常用方法速查表

方法	作用	示例
`find(子串)`	查找子串第一次出现的位置（找不到返回-1）	`s.find("Py")`
`count(子串)`	统计子串出现的次数	`s.count("l")`
`upper()`	全部转大写（返回新字符串）	`s.upper()`
`lower()`	全部转小写（返回新字符串）	`s.lower()`
`split(分隔符)`	按分隔符切分成列表	`s.split("-")`
`strip()`	去掉两端的空白字符	`s.strip()`
`replace(旧, 新)`	替换子串（返回新字符串）	`s.replace("H","C")`
`startswith(子串)`	是否以某子串开头（返回True/False）	`s.startswith("H")`

⚠️ 新手注意：upper()、lower()、replace() 等方法不会修改原字符串，而是返回一个新的字符串。原字符串纹丝不动。

s = "  Hello-Python-Hello  "

print(s.find("Python"))   # 8
print(s.count("l"))       # 2
print(s.upper())          # "  HELLO-PYTHON-HELLO  "
print(s.split("-"))       # ['  Hello', 'Python', 'Hello  ']
print(s.strip())          # "Hello-Python-Hello"
print(s.replace("H", "C")) # "  Cello-Python-Cello  "

# 原字符串没变！
print(s)                  # "  Hello-Python-Hello  "

3.4 ✨ 生活案例：整理通讯录

场景：你从各种渠道收集了一批手机号，格式乱七八糟（有空格、有横杠、有中文括号），需要统一格式并验证合法性。

# 原始数据（来自不同渠道）
raw_phones = [
    " 138-1234-5678 ",
    "15987654321",
    " 139 1234 5678",
    "137-1234-5678",
    "13612345678",
    " 188-8888-8888  ",
]

# 清洗并格式化手机号
clean_phones = []
for phone in raw_phones:
    # 1. 去掉首尾空格
    p = phone.strip()
    # 2. 去掉所有横杠和空格
    p = p.replace("-", "").replace(" ", "")
    # 3. 检查长度是否为11位（简单验证）
    if len(p) == 11 and p.isdigit():
        # 格式化为：前3位-中间4位-后4位
        formatted = f"{p[:3]}-{p[3:7]}-{p[7:]}"
        clean_phones.append(formatted)

print("清洗后的手机号列表：")
for p in clean_phones:
    print(p)

运行结果：

清洗后的手机号列表：
138-1234-5678
159-8765-4321
139-1234-5678
137-1234-5678
136-1234-5678
188-8888-8888

四、元组（tuple）—— 定好就不能改的"密封档案袋"

4.1 元组和列表有什么不同？

列表啥都能改，灵活是优点，但有些场景下数据一旦定了就不能变，比如：身份证号、考试成绩单、一年的12个月份。

这时候就用元组——它和列表长得几乎一样，唯一的区别是：元组一旦创建，不能增、删、改。

形象点说：列表是个可以随意涂改的草稿本，元组是个盖了章的法律文件。

4.2 元组的定义和基本操作

# 定义元组用圆括号 ()
scores = (85, 92, 78, 65, 90)
print(type(scores))  # <class 'tuple'>

# 索引、切片、遍历，和列表完全一样
print(scores[0])      # 85
print(scores[-1])     # 90
print(scores[1:4])    # (92, 78, 65)

for score in scores:
    print(score)

# 统计和查找
print(scores.count(90))   # 90出现了1次
print(scores.index(78))   # 78在索引2的位置

4.3 ⚠️ 定义单元素元组——最容易踩的坑

# 这是元组吗？
t1 = (100)
print(type(t1))   # <class 'int'> ！是个整数！

# 这才是真正的单元素元组
t2 = (100,)
print(type(t2))   # <class 'tuple'>

# 更简洁的写法（不加括号）
t3 = 100,
print(type(t3))   # <class 'tuple'>

🔑 记住这句口诀：逗号是元组的灵魂，括号只是礼貌的装饰。

4.4 组包与解包

组包（Packing）：把多个值打包成一个元组。
解包（Unpacking）：把元组拆开，分别赋值给多个变量。

# 组包
t = 5, 7, 9, 1   # 等价于 (5, 7, 9, 1)
print(t)         # (5, 7, 9, 1)

# 基础解包（变量数量必须和元素数量一致）
a, b, c, d = t
print(a, b, c, d)   # 5 7 9 1

# 扩展解包：用 * 收集剩余元素（收集成列表）
first, *middle, last = (5, 7, 9, 1, 2, 3)
print(first)    # 5
print(middle)   # [7, 9, 1, 2]
print(last)     # 3

# 解包在循环中特别好用
students = [("王林", 85), ("李慕婉", 92), ("十三", 78)]
for name, score in students:
    print(f"{name}：{score}分")

4.5 ✨ 生活案例：统计班级成绩单

场景：班主任手里有一份学生成绩单（学号、姓名、语文、数学、英语），需要完成三项统计。

# 数据用元组嵌套——每条学生记录是一个元组，所有记录组成一个大元组
students = (
    ("S001", "王林", 85, 92, 78),
    ("S002", "李慕婉", 92, 88, 95),
    ("S003", "十三", 78, 85, 82),
    ("S004", "曾牛", 88, 79, 91),
    ("S005", "周轶", 95, 96, 89),
    ("S006", "王卓", 76, 82, 77),
    ("S007", "红蝶", 89, 91, 94),
    ("S008", "徐立国", 75, 69, 82),
    ("S009", "许木", 86, 89, 98),
    ("S010", "遁天", 66, 59, 72)
)

print("=" * 60)
print("学号\t姓名\t语文\t数学\t英语\t总分\t平均分")
print("-" * 60)

# 1. 计算每个学生的总分和平均分
for stu_id, name, chinese, math, english in students:
    total = chinese + math + english
    avg = total / 3
    print(f"{stu_id}\t{name}\t{chinese}\t{math}\t{english}\t{total}\t{avg:.1f}")

print("-" * 60)

# 2. 统计各科的最高分、最低分、平均分
# 用列表推导式提取各科成绩（后面会详细讲）
chinese_scores = [s[2] for s in students]
math_scores = [s[3] for s in students]
english_scores = [s[4] for s in students]

print(f"语文：最高{max(chinese_scores)}，最低{min(chinese_scores)}，平均{sum(chinese_scores)/len(chinese_scores):.1f}")
print(f"数学：最高{max(math_scores)}，最低{min(math_scores)}，平均{sum(math_scores)/len(math_scores):.1f}")
print(f"英语：最高{max(english_scores)}，最低{min(english_scores)}，平均{sum(english_scores)/len(english_scores):.1f}")

print("-" * 60)

# 3. 找出平均分大于90的优秀学生
print("🌟 优秀学生名单（平均分>90）：")
for stu_id, name, chinese, math, english in students:
    avg = (chinese + math + english) / 3
    if avg > 90:
        print(f"  {name}（{stu_id}），平均分{avg:.1f}")

五、字典（dict）—— 带标签的"智能储物柜"

5.1 为什么需要字典？

列表和元组虽然能装东西，但查找某个特定元素时，你得知道它的位置（索引）。如果我要找"张三的成绩"，用列表的话得一个个遍历，效率很低。

字典解决了这个问题——它用 “键（key）” 来存取 “值（value）” ，就像用名字来找人，而不是用座位号。

现实中的字典：通过"字"查"释义"。Python字典：通过"键"查"值"。

5.2 字典的定义和基本操作

# 用花括号 {} 定义，键值对用冒号分隔
student = {
    "name": "李慕婉",
    "age": 20,
    "score": 92,
    "is_graduated": False
}

print(student["name"])    # 李慕婉（通过键访问值）
print(student["age"])     # 20

# 增：添加新的键值对
student["major"] = "计算机科学"
print(student)

# 改：修改已有的值
student["score"] = 95
print(student["score"])

# 查：get()方法更安全（键不存在时返回None，不报错）
print(student.get("phone"))      # None
print(student.get("phone", "未提供"))  # 未提供（可指定默认值）

# 删：删除键值对
del student["is_graduated"]   # 方式一
major = student.pop("major")  # 方式二：删除并返回被删除的值
print(major)                  # 计算机科学

⚠️ 新手易错点：用 dict[键] 访问不存在的键会报 KeyError。建议用 get() 更安全。

5.3 字典的三大特点

键值对存储：每个元素由"键"和"值"两部分组成
键必须唯一且不可变：键可以是字符串、数字、元组，但不能是列表（列表可变）
Python 3.7+ 保持插入顺序：即按照你添加键值对的顺序存储

# 键必须唯一——后面的会覆盖前面的
d = {"a": 1, "a": 2}
print(d)   # {'a': 2}

# 键必须是不可变类型
d = {"name": "张三", 1: "数字键", (1,2): "元组键"}   # ✅ 合法
# d = {[1,2]: "列表键"}    # ❌ 报错！列表不能做键

5.4 遍历字典

student = {"name": "王林", "age": 21, "score": 88}

# 遍历所有的键
for key in student.keys():
    print(key)   # name, age, score

# 遍历所有的值
for value in student.values():
    print(value) # 王林, 21, 88

# 同时遍历键和值（最常用！）
for key, value in student.items():
    print(f"{key}：{value}")

5.5 字典常用方法速查表

方法	作用	示例
`keys()`	获取所有键	`d.keys()`
`values()`	获取所有值	`d.values()`
`items()`	获取所有键值对	`d.items()`
`get(键, 默认值)`	安全取值（不存在返回默认值）	`d.get("age", 0)`
`pop(键)`	删除并返回指定键的值	`d.pop("name")`
`update(字典)`	合并另一个字典（覆盖相同键）	`d.update({"age": 22})`

5.6 ✨ 生活案例：统计购物车商品数量

场景：你在超市买了一堆东西，收银小票上商品有重复的，需要统计每种商品买了多少件。

# 原始购物小票（商品列表，有重复）
cart_items = [
    "苹果", "香蕉", "苹果", "牛奶", "苹果",
    "香蕉", "面包", "牛奶", "牛奶", "牛奶",
    "鸡蛋", "鸡蛋", "苹果"
]

# 用字典统计每种商品的数量
cart_count = {}

for item in cart_items:
    # 如果商品已在字典中，数量+1；否则设置为1
    if item in cart_count:
        cart_count[item] += 1
    else:
        cart_count[item] = 1

print("购物统计：")
for item, count in cart_count.items():
    print(f"  {item}：{count}件")

# 找出购买最多的商品
max_item = max(cart_count, key=cart_count.get)  # key参数指定按什么比较
print(f"\n🏆 买得最多的是：{max_item}，买了{cart_count[max_item]}件")

运行结果：

购物统计：
  苹果：4件
  香蕉：2件
  牛奶：4件
  面包：1件
  鸡蛋：2件

🏆 买得最多的是：苹果，买了4件

💡 小拓展：max(cart_count, key=cart_count.get) 这一行是经典用法，意思是"找出字典中值最大的那个键"。

六、集合（set）—— 自动去重的"收纳盒"

6.1 集合是什么？为什么需要它？

前面学了列表、字符串、元组、字典。现在有个新需求：存储一批不能重复的数据，比如：某个活动的参与者名单（一个人不能重复报名）、网站的所有独立访客IP。

列表和元组允许重复，不合适。这时候就该集合上场了。

集合的三个关键词：无序、不可重复、可修改。

# 定义集合用花括号 {}（但没有冒号，和字典区分）
participants = {"张三", "李四", "王五", "张三"}  # 张三写了两次
print(participants)   # {'王五', '李四', '张三'} —— 自动去重，且顺序不定

6.2 集合的基本操作

s = {10, 20, 30, 40, 50}

# 增
s.add(60)
print(s)   # {40, 10, 50, 20, 60, 30}（顺序不定）

# 删（指定元素不存在会报错）
s.remove(30)
print(s)   # {40, 10, 50, 20, 60}

# 随机删一个并返回
e = s.pop()
print(f"被随机删除的是：{e}")
print(s)

# 清空
s.clear()
print(s)   # set()

# 注意：空集合不能用 {}，因为 {} 是空字典
empty_set = set()   # ✅ 正确
# empty_set = {}   # ❌ 这是空字典，不是空集合

⚠️ 新手易错点：集合不支持索引访问！因为它是无序的。s[0] 会报错。

6.3 集合的三大运算（核心技能）

集合最强大的功能是集合运算：交集、并集、差集。

运算	符号	方法	含义
交集	`&`	`intersection()`	两个集合都有的元素
并集	`\|`	`union()`	两个集合合并（自动去重）
差集	`-`	`difference()`	在前一个集合但不在后一个集合的元素

# 准备两组数据
group_a = {"张三", "李四", "王五", "赵六"}
group_b = {"王五", "赵六", "钱七", "孙八"}

# 交集：既在A组又在B组的人
print(group_a & group_b)                # {'王五', '赵六'}
print(group_a.intersection(group_b))    # 同上

# 并集：A组或B组的所有人（去重）
print(group_a | group_b)                # {'赵六', '王五', '张三', '李四', '孙八', '钱七'}

# 差集：在A组但不在B组的人
print(group_a - group_b)                # {'张三', '李四'}
print(group_a.difference(group_b))      # 同上

6.4 ✨ 生活案例：社团选课统计

场景：学校有四个社团（足球、篮球、法语、艺术），需要统计学生的选课情况。

# 各社团成员名单
football = {"王林", "曾牛", "徐立国", "遁天", "天运子", "韩立", "厉飞雨"}
basketball = {"张铁", "墨居仁", "王林", "姜老道", "曾牛", "韩立", "天运子", "厉飞雨"}
french = {"许木", "王卓", "十三", "虎咆", "姜老道", "天运子", "红蝶", "厉飞雨", "韩立", "曾牛"}
art = {"遁天", "天运子", "韩立", "虎咆", "姜老道"}

# 1. 同时选了法语和艺术的学生（交集）
french_and_art = french & art
print(f"同时选法语和艺术：{french_and_art}")

# 2. 四门课全选的学生（多个集合求交集）
all_four = football & basketball & french & art
print(f"四门全选：{all_four}")

# 3. 选了足球但没选篮球的学生（差集）
football_not_basketball = football - basketball
print(f"只选足球不选篮球：{football_not_basketball}")

# 4. 统计每个学生选了几门课
all_students = football | basketball | french | art  # 并集获取所有学生
all_lists = [*football, *basketball, *french, *art]  # 合并所有名单（保留重复）

print("\n选课数量统计：")
for student in all_students:
    count = all_lists.count(student)
    print(f"  {student}：选了{count}门课")

6.5 集合推导式

和列表推导式类似，集合也可以用一行代码生成：

# 快速生成一个平方数集合
squares = {i**2 for i in range(1, 6)}
print(squares)   # {1, 4, 9, 16, 25}

# 带条件的集合推导式
numbers = [12, 32, 45, 77, 80, 92, 33, 57, 98, 110]
even_squares = {i**2 for i in numbers if i % 2 == 0}
print(even_squares)   # {144, 1024, 6400, 8464, 9604, 12100}

注意集合是无序的，每次运行输出顺序可能不同。

七、推导式专项 —— "一行代码"的魔法

7.1 为什么要学推导式？

先看对比：

# 传统方式（3行）
squares = []
for i in range(1, 11):
    squares.append(i**2)
print(squares)

# 列表推导式（1行）
squares = [i**2 for i in range(1, 11)]
print(squares)   # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

推导式就是"按照规则快速生成容器"的语法糖。写起来更简洁、读起来更直观（习惯之后）。

7.2 列表推导式

基础语法：[表达式 for 变量 in 可迭代对象]

# 生成1-20的平方列表
squares = [i**2 for i in range(1, 21)]
print(squares)

带条件语法：[表达式 for 变量 in 可迭代对象 if 条件]

# 从列表中提取偶数并计算平方
numbers = [12, 32, 45, 77, 80, 92, 33, 57, 98, 110]
even_squares = [i**2 for i in numbers if i % 2 == 0]
print(even_squares)   # [144, 1024, 6400, 8464, 9604, 12100]

嵌套循环推导式：

# 生成二维坐标 (x, y)，x和y分别取1-3
coords = [(x, y) for x in range(1, 4) for y in range(1, 4)]
print(coords)   # [(1,1), (1,2), (1,3), (2,1), (2,2), (2,3), (3,1), (3,2), (3,3)]

7.3 字典推导式

语法：{键表达式: 值表达式 for 变量 in 可迭代对象}

# 将列表转换为字典（数字作为键，平方作为值）
nums = [1, 2, 3, 4, 5]
square_dict = {x: x**2 for x in nums}
print(square_dict)   # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# 带条件的字典推导式
names = ["王林", "李慕婉", "十三", "曾牛"]
# 只保留姓名长度大于等于2的（当然这里都>=2，仅做演示）
name_dict = {name: len(name) for name in names if len(name) >= 2}
print(name_dict)   # {'王林': 2, '李慕婉': 3, '十三': 2, '曾牛': 2}

7.4 集合推导式

语法：{表达式 for 变量 in 可迭代对象}

# 快速生成平方数集合
squares_set = {i**2 for i in range(1, 6)}
print(squares_set)   # {1, 4, 9, 16, 25}

7.5 ✨ 推导式实战对比

场景：有一个数字列表，需要提取所有能被3整除的数，并计算它们的立方。

numbers = [3, 5, 6, 9, 12, 15, 17, 18, 21, 24]

# 方式一：传统循环（5行）
result = []
for n in numbers:
    if n % 3 == 0:
        result.append(n**3)
print(result)

# 方式二：列表推导式（1行）
result = [n**3 for n in numbers if n % 3 == 0]
print(result)   # [27, 216, 729, 1728, 3375, 4913, 9261, 13824]

💡 使用建议：推导式虽好，但不要过度嵌套（比如两层以上条件或循环）。代码是给人读的，可读性永远是第一位的。

八、一张表看懂五大数据容器

特性	列表（list）	字符串（str）	元组（tuple）	字典（dict）	集合（set）
符号	`[]`	`""` 或 `''`	`()`	`{}`（带冒号）	`{}`（不带冒号）
是否有序	✅ 有序	✅ 有序	✅ 有序	✅ 有序（3.7+）	❌ 无序
是否可修改	✅ 可修改	❌ 不可修改	❌ 不可修改	✅ 可修改	✅ 可修改
是否允许重复	✅ 允许	✅ 允许	✅ 允许	❌ 键唯一	❌ 不允许
索引访问	✅ 支持	✅ 支持	✅ 支持	❌ 用键访问	❌ 不支持
使用场景	通用数据集合	文本处理	不可变数据	键值对映射	去重/集合运算