CHAPTER 04

Python 组合数据类型

列表 · 元组 · 字典 · 集合

欢迎关注微信公众号

coder程 查令十街84号
1

列表 List

有序可变序列,最常用
2

元组 Tuple

有序不可变序列
3

字典 Dict

键值对映射
4

集合 Set

无序不重复元素

创建与访问

fruits = ["apple", "banana", "cherry"]
mixed = [1, "a", True, [2, 3]]

fruits[0]       # "apple"
fruits[-1]      # "cherry"
fruits[1:3]    # ["banana", "cherry"]

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

增删改查

lst = [1, 2, 3]

lst.append(4)        # [1, 2, 3, 4]  尾部添加
lst.insert(1, "x")   # [1, "x", 2, 3, 4]  插入
lst.remove(2)        # 删除第一个 2
p = lst.pop()        # 弹出末尾,返回元素
lst.clear()          # 清空列表
列表是可变的: 可以直接修改元素,增删元素。列表中元素类型不必相同。

常用方法

nums = [3, 1, 4, 1, 5, 9]

nums.sort()             # 原地排序 [1, 1, 3, 4, 5, 9]
nums.reverse()          # 原地反转
nums.count(1)           # 2
nums.index(5)           # 4 (第一个 5 的位置)

# 不改变原列表的排序
new = sorted(nums, reverse=True)

列表推导式

# 基本形式
squares = [x**2 for x in range(5)]
# [0, 1, 4, 9, 16]

# 带条件
evens = [x for x in range(10) if x % 2 == 0]
# [0, 2, 4, 6, 8]

# 嵌套
matrix = [[i*j for j in range(3)] for i in range(3)]
# [[0,0,0], [0,1,2], [0,2,4]]

赋值(引用)

a = [1, 2, 3]
b = a        # b 和 a 指向同一个对象
b[0] = 99
print(a)     # [99, 2, 3]  ← a 也变了!

浅拷贝

# 三种浅拷贝方式
b = a.copy()
b = a[:]
b = list(a)

# 浅拷贝只复制外层,
# 内层嵌套对象仍共享

深拷贝

import copy

a = [[1, 2], [3, 4]]
b = copy.deepcopy(a)

b[0][0] = 99
print(a)   # [[1, 2], [3, 4]]  a 不变
print(b)   # [[99, 2], [3, 4]]
关键区别: 浅拷贝复制"一层";深拷贝递归复制所有层级。嵌套列表务必注意!

创建与使用

t = (1, 2, 3)      # 圆括号
t2 = 1, 2, 3      # 括号可省略
single = (5,)     # 单元素必须加逗号!

# 支持索引和切片
t[0]     # 1
t[:2]   # (1, 2)

# 解包
a, b, c = t

元组 vs 列表

特性 列表 List 元组 Tuple
语法 [ ] ( )
可变性 可变 不可变
性能 较慢 更快
用途 动态数据 固定配置、字典键
方法 丰富 仅 count/index
什么时候用元组? 数据不需要修改时(如坐标、配置项)、作为字典的 key 时。

创建与访问

person = {
    "name": "Tom",
    "age": 25,
    "city": "Beijing"
}

person["name"]         # "Tom"
person.get("age")      # 25
person.get("job", "N/A") # "N/A"  默认值

# 添加/修改
person["job"] = "Engineer"

遍历与操作

# 遍历键值对
for k, v in person.items():
    print(k, v)

# 仅键 / 仅值
person.keys()
person.values()

# 删除
del person["city"]
v = person.pop("age")   # 删除并返回值
字典键的要求: 键必须是 不可变类型 (str、int、float、tuple),列表和字典不能当键。

字典推导式

# 从列表创建
squares = {x: x**2 for x in range(5)}
# {0:0, 1:1, 2:4, 3:9, 4:16}

# 过滤
d = {k: v for k, v in items if v > 0}

合并字典(Python 3.9+)

a = {"x": 1}
b = {"y": 2}
c = a | b    # {"x":1, "y":2}
a |= b       # a 原地更新

常用技巧

# setdefault:键不存在时设置
d = {}
d.setdefault("nums", []).append(1)

# Counter 统计
from collections import Counter
cnt = Counter("banana")
# Counter({'a':3, 'n':2, 'b':1})

# 按值排序
sorted(d.items(), key=lambda x: x[1])

创建与基本操作

s = {1, 2, 3, 3, 3}    # {1, 2, 3}  自动去重
s2 = set([1, 2, 2, 3])  # 从列表创建

s.add(4)           # 添加元素
s.remove(2)        # 删除(不存在报错)
s.discard(99)      # 安全删除
s.pop()             # 随机弹出一个

集合运算

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

a | b   # {1,2,3,4,5}  并集
a & b   # {3}          交集
a - b   # {1, 2}       差集
a ^ b   # {1,2,4,5}    对称差

# 判断子集
a.issubset(b)
a.isdisjoint(b)   # 是否无交集
集合特点: 无序、不重复、元素必须是不可变类型。集合运算效率极高,适合去重和成员检测。
类型 符号 有序 可变 重复 用途
列表 List [ ] 通用序列,动态数据
元组 Tuple ( ) 固定数据,字典键
字典 Dict {key:value} ✓* (3.7+) 键唯一 键值映射,快速查找
集合 Set { } 去重,集合运算
选择指南: 数据会变 → 列表;数据固定 → 元组;键值查找 → 字典;去重/集合运算 → 集合。
性能提示: in 操作在集合/字典中是 O(1),在列表中是 O(n)。大数据量查询优先用集合/字典。

本章总结

列表 List

有序可变,支持增删改查和切片。注意赋值是引用传递,深拷贝用 copy.deepcopy。

元组 Tuple

有序不可变,性能更好。适合固定数据和字典键。单元素必须加逗号。

字典 Dict

键值映射,键必须不可变。get() 安全取值,items() 遍历键值对。

集合 Set

无序不重复,支持并交差运算。去重利器,成员检测 O(1)。

下一章 ▶