Python核心容器类型全解析：列表、元组、字典、集合的用法与实战

AI能力探索
149 阅读9分钟

Python的核心容器类型是数据处理的基础，也是新手入门必须掌握的核心知识点。列表（List）、元组（Tuple）、字典（Dictionary）、集合（Set）作为Python内置的四大容器，各自适配不同的数据存储和操作场景。本文从基础定义、核心用法、场景对比到实战案例，手把手教你吃透这四大容器，解决“该用哪种容器”“如何高效操作数据”等核心问题。

一、容器类型核心认知：为什么需要不同容器？

容器类型本质是“存储多个数据的集合”，不同容器的设计初衷对应不同的使用场景：

  • 有序/无序：列表、元组是有序容器（可通过索引访问），字典（3.7+有序）、集合是无序容器；
  • 可变/不可变：列表、字典、集合是可变容器（可修改元素），元组是不可变容器（一旦创建无法修改）；
  • 重复/唯一：列表、元组允许重复元素，集合、字典（键）要求元素唯一；
  • 索引/键值：列表、元组通过数字索引访问，字典通过键（Key）访问，集合无索引（需遍历）。

二、列表（List）：有序可变的“万能容器”

列表是Python最常用的容器，以[]定义，支持增删改查，适配绝大多数数据存储场景。

1. 基础定义与访问

# 定义空列表
empty_list = []
# 定义包含不同类型元素的列表（Python列表支持异构数据）
num_list = [1, 2, 3, 4, 5]
mix_list = [1, "Python", True, 3.14]

# 通过索引访问（索引从0开始，支持负数索引：-1表示最后一个元素）
print(num_list[0])  # 输出：1
print(mix_list[-2]) # 输出：True

# 切片访问（左闭右开）
print(num_list[1:3])  # 输出：[2, 3]
print(num_list[:3])   # 输出：[1, 2, 3]（从开头到索引2）
print(num_list[3:])   # 输出：[4, 5]（从索引3到结尾）

2. 核心操作：增删改查

（1）增加元素

fruits = ["apple", "banana"]
# append：末尾添加单个元素
fruits.append("orange")
print(fruits)  # 输出：['apple', 'banana', 'orange']

# extend：末尾添加多个元素（可迭代对象）
fruits.extend(["grape", "pear"])
print(fruits)  # 输出：['apple', 'banana', 'orange', 'grape', 'pear']

# insert：指定位置插入元素
fruits.insert(1, "mango")
print(fruits)  # 输出：['apple', 'mango', 'banana', 'orange', 'grape', 'pear']

（2）删除元素

# del：按索引删除
del fruits[1]
print(fruits)  # 输出：['apple', 'banana', 'orange', 'grape', 'pear']

# pop：删除并返回指定索引元素（默认最后一个）
pop_fruit = fruits.pop()
print(pop_fruit)  # 输出：pear
print(fruits)     # 输出：['apple', 'banana', 'orange', 'grape']

# remove：按元素值删除（删除第一个匹配项）
fruits.remove("banana")
print(fruits)  # 输出：['apple', 'orange', 'grape']

（3）修改元素

fruits[1] = "cherry"
print(fruits)  # 输出：['apple', 'cherry', 'grape']

（4）查找元素

# in：判断元素是否存在
print("apple" in fruits)  # 输出：True

# index：查找元素索引（无则报错）
print(fruits.index("cherry"))  # 输出：1

# count：统计元素出现次数
nums = [1, 2, 2, 3, 2]
print(nums.count(2))  # 输出：3

3. 常用内置方法

nums = [3, 1, 4, 2, 5]
# sort：原地排序（默认升序）
nums.sort()
print(nums)  # 输出：[1, 2, 3, 4, 5]

# sorted：返回新的排序列表（不修改原列表）
new_nums = sorted(nums, reverse=True)  # 降序
print(new_nums)  # 输出：[5, 4, 3, 2, 1]

# reverse：反转列表
nums.reverse()
print(nums)  # 输出：[5, 4, 3, 2, 1]

# len：获取列表长度
print(len(nums))  # 输出：5

4. 适用场景

  • 存储有序、可修改的数据集（如用户列表、商品列表）；
  • 需要频繁增删元素的场景（如动态添加任务、统计数据）；
  • 临时存储异构数据（如混合数字、字符串、布尔值）。

三、元组（Tuple）：有序不可变的“只读容器”

元组以()定义，不可修改的特性使其更安全、占用内存更少，适合存储固定数据。

1. 基础定义与访问

# 定义元组（小括号可省略，单个元素需加逗号）
empty_tuple = ()
single_tuple = (1,)  # 注意：(1)是数字，(1,)才是元组
num_tuple = (1, 2, 3, 4, 5)
mix_tuple = (1, "Python", True)

# 访问方式与列表一致（索引、切片）
print(num_tuple[2])     # 输出：3
print(mix_tuple[1:])    # 输出：('Python', True)

2. 核心特性：不可变性

num_tuple = (1, 2, 3)
# 尝试修改元素（报错：TypeError: 'tuple' object does not support item assignment）
# num_tuple[1] = 10

# 若元组包含可变元素（如列表），该元素可修改
mix_tuple = (1, [2, 3], 4)
mix_tuple[1][0] = 20
print(mix_tuple)  # 输出：(1, [20, 3], 4)

3. 常用操作

# 拼接元组
t1 = (1, 2)
t2 = (3, 4)
t3 = t1 + t2
print(t3)  # 输出：(1, 2, 3, 4)

# 重复元素
t4 = t1 * 3
print(t4)  # 输出：(1, 2, 1, 2, 1, 2)

# 解包（常用）
a, b, c = (10, 20, 30)
print(a, b, c)  # 输出：10 20 30

# len/count/index：用法与列表一致
nums = (1, 2, 2, 3)
print(len(nums))      # 输出：4
print(nums.count(2))  # 输出：2
print(nums.index(3))  # 输出：3

4. 适用场景

  • 存储固定不变的数据（如坐标：(x, y)、配置参数）；
  • 函数返回多个值（本质是元组）；
  • 作为字典的键（列表不可作为字典键，元组可以）；
  • 数据传输/存储时保证数据不被篡改。

四、字典（Dictionary）：键值对的“映射容器”

字典以{key: value}定义，通过唯一的键访问值，是处理结构化数据的核心容器（3.7+版本字典有序）。

1. 基础定义与访问

# 定义空字典
empty_dict = {}
# 定义键值对字典（键必须是不可变类型：字符串、数字、元组；值可任意）
user = {
    "name": "张三",
    "age": 20,
    "gender": "男",
    "hobbies": ["编程", "阅读"]
}

# 按键访问值
print(user["name"])  # 输出：张三
print(user["hobbies"][0])  # 输出：编程

# get方法：访问键（不存在时返回默认值，避免报错）
print(user.get("phone", "未填写"))  # 输出：未填写

2. 核心操作：增删改查

（1）增加/修改键值对

# 新增键值对
user["phone"] = "13800138000"
print(user)  # 新增phone键

# 修改已有键值对
user["age"] = 21
print(user)  # age变为21

# update：批量添加/修改
user.update({"city": "北京", "email": "zhangsan@test.com"})
print(user)  # 新增city、email键

（2）删除键值对

# del：按键删除
del user["gender"]
print(user)  # 无gender键

# pop：删除并返回指定键的值
phone = user.pop("phone")
print(phone)  # 输出：13800138000

# clear：清空字典
# user.clear()
# print(user)  # 输出：{}

（3）查找操作

# in：判断键是否存在
print("name" in user)  # 输出：True

# keys()：获取所有键
print(user.keys())  # 输出：dict_keys(['name', 'age', 'hobbies', 'city', 'email'])

# values()：获取所有值
print(user.values())  # 输出：dict_values(['张三', 21, ['编程', '阅读'], '北京', 'zhangsan@test.com'])

# items()：获取所有键值对（常用遍历）
print(user.items())  # 输出：dict_items([('name', '张三'), ('age', 21), ...])

3. 遍历字典

# 遍历键
for key in user:
    print(key, user[key])

# 遍历键值对（推荐）
for k, v in user.items():
    print(f"{k}: {v}")

4. 适用场景

  • 存储结构化数据（如用户信息、商品属性）；
  • 快速查找数据（通过键访问，效率远高于列表）；
  • 配置文件解析（如JSON数据转字典）；
  • 统计频次（如统计字符串中字符出现次数）。

五、集合（Set）：无序唯一的“去重容器”

集合以{}定义（空集合需用set()），自动去重且支持集合运算，适合数据去重、交集/并集计算。

1. 基础定义与去重特性

# 定义集合（自动去重）
num_set = {1, 2, 2, 3, 4, 4}
print(num_set)  # 输出：{1, 2, 3, 4}

# 空集合必须用set()，{}是空字典
empty_set = set()
print(type(empty_set))  # 输出：

# 从列表/元组创建集合（去重）
nums = [1, 2, 2, 3]
nums_set = set(nums)
print(nums_set)  # 输出：{1, 2, 3}

2. 核心操作：增删查

（1）增加元素

s = {1, 2, 3}
# add：添加单个元素
s.add(4)
print(s)  # 输出：{1, 2, 3, 4}

# update：添加多个元素（可迭代对象）
s.update([5, 6])
print(s)  # 输出：{1, 2, 3, 4, 5, 6}

（2）删除元素

# remove：删除元素（不存在则报错）
s.remove(6)
print(s)  # 输出：{1, 2, 3, 4, 5}

# discard：删除元素（不存在不报错，推荐）
s.discard(10)  # 无报错
print(s)       # 输出：{1, 2, 3, 4, 5}

# pop：随机删除一个元素（集合无序）
s.pop()
print(s)  # 输出：{2, 3, 4, 5}（随机，结果可能不同）

（3）查找操作

# in：判断元素是否存在
print(3 in s)  # 输出：True

3. 集合运算（核心优势）

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

# 并集：a和b所有元素（去重）
print(a | b)  # 输出：{1, 2, 3, 4, 5, 6}
print(a.union(b))

# 交集：a和b共同元素
print(a & b)  # 输出：{3, 4}
print(a.intersection(b))

# 差集：a有但b没有的元素
print(a - b)  # 输出：{1, 2}
print(a.difference(b))

# 对称差集：a和b中互不相同的元素
print(a ^ b)  # 输出：{1, 2, 5, 6}
print(a.symmetric_difference(b))

4. 适用场景

  • 数据去重（如列表去重：list(set(lst))）；
  • 集合运算（如查找两个列表的共同元素、差异元素）；
  • 快速判断元素是否存在（效率高于列表）；
  • 去重且无需保持顺序的场景。

六、四大容器类型对比与选型指南

类型定义符号有序性可变性元素唯一性访问方式核心优势
列表[]是是否数字索引灵活增删改、适配通用场景
元组()是否否数字索引安全、内存占用少
字典{}是（3.7+）是键唯一键（Key）结构化数据、快速查找
集合{}/set()否是是无索引（遍历）自动去重、集合运算

选型原则

  1. 需有序且频繁修改 → 列表；
  2. 需有序且固定不变 → 元组；
  3. 需键值映射、快速查找 → 字典；
  4. 需去重或集合运算 → 集合。

七、实战案例：容器类型综合应用

案例1：统计字符串中字符出现频次（字典）

def count_char(s):
    char_count = {}
    for char in s:
        # 若字符已存在，计数+1；否则初始化为1
        char_count[char] = char_count.get(char, 0) + 1
    return char_count

s = "hello python"
print(count_char(s))
# 输出：{'h': 2, 'e': 1, 'l': 2, 'o': 2, ' ': 1, 'p': 1, 'y': 1, 't': 1, 'n': 1}

案例2：两个列表去重并求交集（集合）

lst1 = [1, 2, 3, 4, 5]
lst2 = [4, 5, 6, 7, 8]

# 去重
lst1_unique = list(set(lst1))
lst2_unique = list(set(lst2))

# 求交集
intersection = list(set(lst1) & set(lst2))

print("lst1去重：", lst1_unique)  # 输出：[1, 2, 3, 4, 5]
print("lst2去重：", lst2_unique)  # 输出：[4, 5, 6, 7, 8]
print("交集：", intersection)     # 输出：[4, 5]

案例3：存储学生信息（列表+字典）

# 列表存储多个学生（字典）
students = [
    {"name": "张三", "age": 20, "score": 90},
    {"name": "李四", "age": 19, "score": 85},
    {"name": "王五", "age": 21, "score": 95}
]

# 遍历并打印成绩≥90的学生
for stu in students:
    if stu["score"] >= 90:
        print(f"{stu['name']}：{stu['score']}分（优秀）")
# 输出：
# 张三：90分（优秀）
# 王五：95分（优秀）
avatar
文章
阅读
粉丝