Python列表、元组、字典和集合_python中的列表元组和字典

liuian 2025-10-14 01:05 49 浏览

Python 中的列表（List）、元组（Tuple）、字典（Dict）和集合（Set）是四种最常用的核心数据结构。掌握它们的基础操作只是第一步，真正发挥威力的是那些高级用法和技巧。

首先我们先看一下这4种类型的详细对比，确定我们在开发的时候怎么选择使用哪一种类型。

数据结构	是否可变	是否有序	元素是否唯一	查找效率	内存结构	典型应用
列表 (List)	可变	有序	允许重复	O(n)	动态指针数组	动态有序数据
元组 (Tuple)	不可变	有序	允许重复	O(n)	静态指针数组	不变数据，作字典键
字典 (Dict)	可变	插入序	Key唯一	O(1)	哈希表	键值映射，快速查找
集合 (Set)	可变	无序	元素唯一	O(1)	哈希表(仅键)	去重，集合运算

总结与选择建议：

需要存储一个有序且可能变化的序列吗？ -> 选择列表。
需要存储一组不可变的、作为键或保证安全的数据吗？ -> 选择元组。
需要通过唯一的键来快速查找和关联值吗？ -> 选择字典。
需要保证元素的唯一性，或进行集合运算（如去重、求交集并集）吗？ -> 选择集合。

列表 (List) 的高级用法

列表的强大远超基础的增删改查。

列表推导式 (List Comprehension)。

这是编写 Pythonic 代码的利器，它用简洁的语法快速生成新列表

# 基础：快速生成平方数列表 
squares = [x**2 for x in range(10)]# [0, 1, 4, 9, ..., 81] 

# 带条件过滤：生成偶数的平方 
even_squares = [x**2 for x in range(10) if x % 2 == 0]# [0, 4, 16, 36, 64] 

# 多重循环：模拟嵌套循环，生成全排列 
pairs = [(x, y) for x in ['A', 'B'] for y in [1, 2]] 
# 结果: [('A', 1), ('A', 2), ('B', 1), ('B', 2)]

切片赋值与高级切片。

切片不仅可以取数据，还可以批量修改、删除甚至插入数据

my_list = [1, 2, 3, 4, 5] 

# 批量替换子序列 my_list[1:4] = [20, 30, 40]# my_list 变为 [1, 20, 30, 40, 5] 

# 批量删除子序列 (用空列表替换) my_list[1:4] = []# my_list 变为 [1, 5] 

# 使用步长进行间隔替换（数量必须匹配） my_list[::2] = [100, 200]# 将第1、3个元素替换为100, 200

与 map, filter, zip等函数式工具结合

这些内置函数让列表处理更高效和声明式。

numbers = ['1', '2', '3'] 

# map: 将函数应用于列表每个元素 int_list = list(map(int, numbers))  # [1, 2, 3] 

# filter: 过滤列表中满足条件的元素 even_list = list(filter(lambda x: x % 2 == 0, [1,2,3,4]))  # [2, 4] 

# zip: 将多个列表对应位置的元素"打包"成元组 
names = ['Alice', 'Bob'] 
scores = [85, 92] 
zipped = list(zip(names, scores))  # [('Alice', 85), ('Bob', 92)] 

# 用zip优雅地同步遍历多个列表 
for name, score in zip(names, scores): 
		print(f"{name}: {score}")

性能注意事项

列表在尾部进行 append和 pop操作很快（O(1)时间复杂度）。
在头部或中部进行 insert或 pop操作可能较慢（O(n)时间复杂度），因为需要移动后续元素。
对于需要频繁在两端进行添加或删除操作的场景，可以考虑使用 collections.deque（双端队列），它在队列两端都有出色的性能表现。

元组 (Tuple) 的高级用法

元组的“不可变性”是其核心优势，带来了安全、高效和可哈希的特性。

解包 (Unpacking)。

这是元组最优雅的特性之一，可以一次性将元组元素赋值给多个变量

# 基本解包 
point = (10, 20) 
x, y = point# x=10, y=20 

# 使用 * 进行可变长度解包 (Python 3) 
numbers = (1, 2, 3, 4, 5) 
first, *middle, last = numbers# first=1, middle=[2,3,4], last=5 
a, *b, c, d = numbers# a=1, b=[2,3], c=4, d=5 

# 在循环中解包 
for name, score in zipped:# 接上文zip的例子 
		print(f"{name}'s score is {score}") 

# 使用下划线 _ 忽略不需要的值 
name, _, salary = ("Alice", "Engineer", 50000)  # 忽略职位

作为字典的键或集合的元素。

由于元组是不可变的、可哈希的，它可以作为字典的键，这是列表无法做到的

# 用元组表示坐标，作为字典的键 
location_map = {
      (40.7128, -74.0060): "New York",
      (34.0522, -118.2437): "Los Angeles"
} 
print(location_map[(40.7128, -74.0060)])# 输出: New York 

# 元组也可以放入集合中（需确保所有元素都可哈希） 
unique_points = {(1, 2), (3, 4), (1, 2)}    # {(1, 2), (3, 4)}

命名元组 (Named Tuple)。

collections.namedtuple让元组不仅有序号，还有了名字，极大提升了代码的可读性

from collections import namedtuple 

# 定义一个命名元组类型 'Person' 
Person = namedtuple('Person', ['name', 'age', 'job']) 

# 创建命名元组实例 
alice = Person(name="Alice", age=30, job="Engineer") 

# 通过字段名访问，意义明确 
print(alice.name)    # Alice 
print(alice.job)    # Engineer 

# 仍然支持索引访问 
print(alice[0])    # Alice

函数返回多个值。

本质上，Python 函数返回多个值就是返回一个元组

def calculate_stats(data): 
		total = sum(data)
		count = len(data) 
		average = total / count return total, count, average    # 返回一个元组 (total, count, average) 

# 接收返回值时常用解包 
total, count, avg = calculate_stats([1, 2, 3, 4, 5])

字典 (Dict) 的高级用法

字典的核心在于基于键的快速查找（O(1)平均时间复杂度）。

字典推导式 (Dict Comprehension)。

与列表推导式类似，可以快速简洁地创建字典

# 快速创建键值对 
squares = {x: x*x for x in range(5)}# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16} 

# 交换键和值（前提是值都是可哈希的） 
original = {'a': 1, 'b': 2} 
swapped = {v: k for k, v in original.items()}# {1: 'a', 2: 'b'} 

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

setdefault和 get方法安全访问

这些方法可以优雅地处理键可能不存在的情况，避免 KeyError。

my_dict = {'name': 'Alice', 'age': 30} 
# get(key, default): 键不存在时返回默认值，不会引发异常 
job = my_dict.get('job', 'Unemployed')# 'Unemployed' 
age = my_dict.get('age')# 30 

# setdefault(key, default): 键不存在时，设置键值并返回默认值；键存在则返回对应的值 
# 常用于初始化列表、集合等值，避免重复判断 
data = {} 
for item in ['A', 'B', 'A', 'C']: 
		# 如果键不存在，将键对应的值初始化为空列表，然后追加元素 
    data.setdefault(item, []).append(f"Value_{item}") 
# data: {'A': ['Value_A', 'Value_A'], 'B': ['Value_B'], 'C': ['Value_C']}

字典合并 (Merging Dictionaries)

有多种方式可以将多个字典合并为一个。

d1 = {'a': 1, 'b': 2} 
d2 = {'b': 3, 'c': 4}    # 注意键 'b' 重复 

# 方法1: {**d1, **d2} (Python 3.5+) 
merged = {**d1, **d2}    # {'a': 1, 'b': 3, 'c': 4}，后面的值覆盖前面的 

# 方法2: d1.update(d2) (原地修改d1) 
d1.update(d2)    # d1 变为 {'a': 1, 'b': 3, 'c': 4} 

# 方法3: collections.ChainMap (逻辑合并，不创建新字典) 
from collections import ChainMap 
chain = ChainMap(d1, d2)    # 按顺序查找键

使用 collections模块中的特殊字典

defaultdict: 提供默认值工厂，简化初始化。

from collections import defaultdict 

# 初始化一个默认值为列表的字典 list_dict = defaultdict(list) 
list_dict['fruits'].append('apple')# 无需先判断键是否存在 

# 初始化一个默认值为0的字典（用于计数） 
count_dict = defaultdict(int) 
for word in ['apple', 'banana', 'apple']: 
		count_dict[word] += 1# 第一次遇到'apple'时，初始值就是0 
# count_dict: defaultdict(<class 'int'>, {'apple': 2, 'banana': 1})

Counter: 专为计数设计的字典子类。

from collections import Counter 
words = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple'] 
word_count = Counter(words) 
print(word_count)			# Counter({'apple': 3, 'banana': 2, 'orange': 1}) 
print(word_count.most_common(2))			# [('apple', 3), ('banana', 2)]

集合 (Set) 的高级用法

集合的核心是唯一性和数学集合操作。

集合推导式 (Set Comprehension)

与列表推导式类似，用于创建集合，自动去重。

# 创建一个包含平方数的集合（自动去重） 
numbers = [1, 2, 2, 3, 4, 4, 4] 
unique_squares = {x*x for x in numbers}			# {1, 4, 9, 16}

强大的集合运算

集合支持并集、交集、差集、对称差集等数学运算。

set_a = {1, 2, 3, 4} 
set_b = {3, 4, 5, 6} 

# 并集 (Union): 所有在A或B中的元素 
print(set_a | set_b)# {1, 2, 3, 4, 5, 6} 
print(set_a.union(set_b))# 同上 

# 交集 (Intersection): 所有同时在A和B中的元素 
print(set_a & set_b)# {3, 4} 
print(set_a.intersection(set_b))# 同上 

# 差集 (Difference): 在A中但不在B中的元素 
print(set_a - set_b)# {1, 2} 
print(set_a.difference(set_b))# 同上 

# 对称差集 (Symmetric Difference): 在A或B中，但不同时在两者中的元素 
print(set_a ^ set_b)# {1, 2, 5, 6} 
print(set_a.symmetric_difference(set_b))# 同上 

# 子集/超集判断 
print({1, 2}.issubset(set_a))			# True 
print(set_a.issuperset({1, 2}))			# True

从序列中快速去除重复项

这是集合最常用的场景之一。

my_list = [1, 2, 2, 3, 4, 4, 4, 5]
unique_list = list(set(my_list))			# [1, 2, 3, 4, 5] (顺序可能改变)

# 如果需要保持原始顺序，可以使用字典（Python 3.7+字典有序）
unique_list_ordered = list(dict.fromkeys(my_list).keys())			# [1, 2, 3, 4, 5]

python 列表替换