Python五大容器详解：列表、元组、字典、集合与字符串-代码聚汇网

Python五大容器详解：列表、元组、字典、集合与字符串

北极巨兔·2026-08-16·阅读 23 GEO检测（免费）

Python容器列表元组

|难度：普通|阅读约 24 分钟

1. Python五大容器概述

在Python编程中，容器(Container)是指能够存储多个元素的数据结构。它们就像现实生活中的收纳盒，可以有序或无序地存放各种物品。Python内置了五种核心容器类型：列表(list)、元组(tuple)、字典(dict)、集合(set)和字符串(str)。这些容器各具特色，适用于不同的场景。

提示：虽然字符串(str)严格来说属于序列类型，但在Python中它具备容器的特性，可以像列表一样进行索引和切片操作，因此常被归为容器讨论。

我刚开始学习Python时，常常困惑于何时使用哪种容器。经过多年实战，我总结出一个简单原则：需要可变性时用列表，需要不可变性时用元组，需要键值对时用字典，需要去重时用集合，处理文本时自然就用字符串了。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 列表(List)：灵活的多功能容器

2.1 列表的基本特性

列表是Python中最常用的可变序列，用方括号[]表示。它的核心特点包括：

有序性：元素按插入顺序存储
可变性：创建后可以修改
异构性：可以存储不同类型的数据
动态性：大小可随时调整

python复制# 创建列表的多种方式
empty_list = []
numbers = [1, 2, 3, 4, 5]
mixed = [1, "hello", 3.14, True]

2.2 列表的常用操作

列表支持丰富的操作方法，以下是我在日常开发中最常用的：

增删改查操作

python复制# 添加元素
fruits = ["apple", "banana"]
fruits.append("orange")  # 末尾添加
fruits.insert(1, "pear")  # 指定位置插入

# 删除元素
del fruits[0]  # 删除指定位置
fruits.remove("banana")  # 删除指定值
popped = fruits.pop()  # 弹出最后一个元素

# 修改元素
fruits[0] = "kiwi"

# 查找元素
if "apple" in fruits:
    print("Found!")

切片操作
切片是Python中非常强大的特性，可以轻松获取子列表：

python复制numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
first_three = numbers[:3]  # [0,1,2]
last_three = numbers[-3:]  # [7,8,9]
even_index = numbers[::2]  # [0,2,4,6,8]
reversed_list = numbers[::-1]  # 反转列表

2.3 列表推导式

列表推导式(List Comprehension)是Python中优雅且高效创建列表的方式：

python复制# 传统方式
squares = []
for x in range(10):
    squares.append(x**2)

# 使用列表推导式
squares = [x**2 for x in range(10)]

# 带条件的推导式
even_squares = [x**2 for x in range(10) if x % 2 == 0]

注意：虽然列表推导式简洁，但过度复杂的推导式会降低可读性。我的经验法则是：如果推导式超过两行或包含多个if条件，最好改用普通for循环。

3. 元组(Tuple)：不可变的轻量容器

3.1 元组的基本特性

元组用圆括号()表示，与列表的主要区别在于：

不可变性：创建后不能修改
更轻量：占用内存比列表小
可哈希性：可作为字典的键

python复制# 创建元组
empty_tuple = ()
single_item = (42,)  # 注意逗号，否则不是元组
coordinates = (10, 20)

3.2 元组的典型应用场景

根据我的经验，元组最适合以下场景：

1. 作为不可变记录

python复制# 表示二维点
point = (x, y)

# 表示RGB颜色
color = (255, 0, 0)

2. 函数返回多个值

python复制def get_stats(data):
    return min(data), max(data), sum(data)/len(data)

min_val, max_val, avg_val = get_stats([1,2,3,4,5])

3. 作为字典的键

python复制# 列表不能作为字典键，会报错
locations = {
    (35.68, 139.76): "Tokyo",
    (40.71, -74.01): "New York"
}

3.3 命名元组(NamedTuple)

对于需要更多语义的场景，可以使用collections模块中的namedtuple：

python复制from collections import namedtuple

Person = namedtuple("Person", ["name", "age", "gender"])
p = Person("Alice", 30, "F")
print(p.name)  # 比p[0]更清晰

4. 字典(Dict)：高效的键值对容器

4.1 字典的基本特性

字典用花括号{}表示，存储键值对(key-value pairs)，特点包括：

无序性(Python 3.7+后变为有序)
键必须唯一且不可变
查找速度极快(O(1)时间复杂度)

python复制# 创建字典
empty_dict = {}
person = {"name": "Alice", "age": 25, "city": "New York"}

4.2 字典的常用操作

基本操作

python复制# 访问元素
name = person["name"]  # 如果键不存在会报KeyError
age = person.get("age", 0)  # 安全获取，可设默认值

# 添加/修改元素
person["email"] = "alice@example.com"
person["age"] = 26

# 删除元素
del person["city"]
email = person.pop("email")  # 删除并返回

遍历字典

python复制# 遍历键
for key in person:
    print(key)

# 遍历键值对
for key, value in person.items():
    print(f"{key}: {value}")

4.3 字典的高级用法

defaultdict
处理缺失键时自动创建默认值：

python复制from collections import defaultdict

word_counts = defaultdict(int)
for word in words:
    word_counts[word] += 1  # 不会报KeyError

字典推导式

python复制squares = {x: x*x for x in range(5)}
# {0:0, 1:1, 2:4, 3:9, 4:16}

合并字典

python复制dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}

# Python 3.5+
merged = {**dict1, **dict2}  # {'a':1, 'b':3, 'c':4}

# Python 3.9+
merged = dict1 | dict2

5. 集合(Set)：去重与数学运算利器

5.1 集合的基本特性

集合用花括号{}表示(与字典相同，但没有冒号)，特点包括：

无序性
元素唯一性(自动去重)
可变性(set)或不可变性(frozenset)

python复制# 创建集合
empty_set = set()  # 不能用{}，这是空字典
numbers = {1, 2, 3, 3, 4}  # 自动去重 {1,2,3,4}

5.2 集合的数学运算

集合最强大的功能是支持数学集合运算：

python复制A = {1, 2, 3}
B = {2, 3, 4}

# 并集
A | B  # {1,2,3,4}
A.union(B)

# 交集
A & B  # {2,3}
A.intersection(B)

# 差集
A - B  # {1}
A.difference(B)

# 对称差集(仅在其中一个集合中的元素)
A ^ B  # {1,4}
A.symmetric_difference(B)

5.3 集合的典型应用

1. 快速去重

python复制unique_words = set(words_list)

2. 成员测试

python复制valid_tags = {"python", "java", "javascript"}
if input_tag in valid_tags:
    print("Valid tag")

3. 过滤重复项

python复制seen = set()
for item in data:
    if item not in seen:
        process(item)
        seen.add(item)

6. 字符串(Str)：不可变的文本容器

6.1 字符串的基本操作

虽然字符串主要用于文本处理，但它具备容器的特性：

python复制s = "Hello, Python!"

# 索引
first_char = s[0]  # 'H'

# 切片
sub = s[7:13]  # 'Python'

# 长度
length = len(s)  # 14

# 遍历
for char in s:
    print(char)

6.2 常用字符串方法

查找与替换

python复制# 查找
index = s.find("Python")  # 7
count = s.count("l")  # 2

# 替换
new_s = s.replace("Python", "World")

分割与连接

python复制# 分割
parts = "apple,banana,orange".split(",")  # ['apple','banana','orange']

# 连接
joined = "-".join(["2023", "08", "01"])  # '2023-08-01'

格式化

python复制# f-string (Python 3.6+)
name = "Alice"
age = 25
msg = f"My name is {name} and I'm {age} years old."

# format方法
msg = "My name is {} and I'm {} years old.".format(name, age)

7. 容器之间的转换与选择

7.1 类型转换

Python容器之间可以方便地相互转换：

python复制# 列表转集合(去重)
unique = set([1,2,2,3])  # {1,2,3}

# 元组转列表
mutable = list((1,2,3))  # [1,2,3]

# 字典键/值转列表
keys = list({"a":1, "b":2}.keys())  # ['a','b']

7.2 容器选择指南

根据我的经验，选择容器时考虑以下因素：

是否需要可变性：
- 可变：list, dict, set
- 不可变：tuple, str, frozenset
是否需要保持顺序：
- 有序：list, tuple, str (Python 3.7+后dict也保持插入顺序)
- 无序：set
数据访问方式：
- 索引/位置：list, tuple, str
- 键值：dict
- 唯一值：set
性能考虑：
- 频繁查找：dict和set的O(1)查找最快
- 频繁插入/删除：list末尾操作快，中间操作慢

8. 性能比较与内存占用

8.1 时间复杂度比较

操作	List	Set	Dict
查找(x in s)	O(n)	O(1)	O(1)
插入	O(1)	O(1)	O(1)
删除	O(n)	O(1)	O(1)
索引访问	O(1)	N/A	O(1)

8.2 内存占用实测

通过sys.getsizeof()可以查看对象内存占用(单位：字节)：

python复制import sys

data = list(range(1000))
print(sys.getsizeof(data))  # 列表：约9000
print(sys.getsizeof(tuple(data)))  # 元组：约8000
print(sys.getsizeof(set(data)))  # 集合：约65000
print(sys.getsizeof(dict.fromkeys(data)))  # 字典：约40000

实际项目中我发现：当元素数量少时，类型选择对性能影响不大；但数据量大时，选择合适的容器能显著提升性能。

9. 实际应用案例分享

9.1 使用字典统计词频

python复制def word_count(text):
    counts = {}
    for word in text.split():
        counts[word] = counts.get(word, 0) + 1
    return counts

# 更简洁的collections.Counter版本
from collections import Counter
counts = Counter(text.split())

9.2 使用集合找出共同好友

python复制alice_friends = {"Bob", "Charlie", "Diana"}
bob_friends = {"Alice", "Charlie", "Eve"}

common_friends = alice_friends & bob_friends  # {'Charlie'}

9.3 使用列表推导式处理数据

python复制# 从日志中提取错误信息
logs = ["INFO: System started", "ERROR: File not found", "DEBUG: Checking config"]
errors = [log for log in logs if log.startswith("ERROR")]

10. 常见问题与解决方案

Q1：如何选择列表还是元组？

需要修改数据：用列表
数据不变且需要哈希：用元组
只是遍历数据：两者性能差异不大

Q2：字典键必须是不可变类型吗？
是的，常见的可哈希(不可变)类型包括：

基本类型：int, float, str, bool
不可变集合：tuple, frozenset
自定义类(默认可哈希，除非实现了__hash__)

Q3：为什么集合比列表查找快？
集合基于哈希表实现，查找时间复杂度为O(1)，而列表需要线性搜索O(n)。

Q4：如何合并两个字典？
Python 3.5+可以使用{**d1, **d2}，Python 3.9+可以用d1 | d2。

Q5：如何实现有序集合？
可以使用collections.OrderedDict模拟：

python复制from collections import OrderedDict
ordered_set = OrderedDict.fromkeys(items)

11. 性能优化技巧

预分配列表空间：已知大小时预先分配

python复制lst = [None] * 1000  # 比append快

使用生成器表达式处理大数据：节省内存

python复制sum(x*x for x in range(1000000))  # 不创建中间列表

字典的setdefault方法：简化某些操作

python复制# 传统方式
if key not in d:
    d[key] = []
d[key].append(value)

# 使用setdefault
d.setdefault(key, []).append(value)

利用集合去重：比列表检查更快

python复制unique = list(set(duplicates))  # 顺序会丢失
# 保持顺序
seen = set()
unique = [x for x in items if not (x in seen or seen.add(x))]

12. 容器相关的Pythonic技巧

多重赋值：

python复制# 交换变量
a, b = b, a

# 解包
first, *rest = [1,2,3,4]  # first=1, rest=[2,3,4]

链式比较：

python复制if 1 <= x < 10:  # Python允许这种写法
    print("Valid")

字典的get方法：

python复制# 安全访问字典
value = my_dict.get(key, default_value)

使用zip并行迭代：

python复制for name, score in zip(names, scores):
    print(f"{name}: {score}")

enumerate获取索引：

python复制for index, value in enumerate(items):
    print(f"Item {index}: {value}")

在实际项目中，我发现合理运用这些Pythonic写法不仅能提高代码可读性，还能减少出错概率。比如用enumerate替代range(len())，用get方法替代直接键访问等，都是值得培养的好习惯。