Python字典，核心编程必备技能，建议收藏！-优快云博客

Python字典，核心编程必备技能，建议收藏！

前言

大家好，我是[你的名字]。在日常Python开发中，字典（dict）绝对是我用得最频繁的数据结构，没有之一。无论是处理JSON数据、缓存配置，还是做计数器、去重，字典都扮演着至关重要的角色。

今天这篇文章，我想把自己对字典的理解系统性地整理出来，从基础用法到底层原理，再到一些容易被忽视的“坑”，希望能帮你彻底掌握Python字典。

话不多说，我们直接开始。

一、什么是字典？

字典是Python内置的一种可变、无序的容器模型，以“键值对”（key: value）的形式存储数据。你可以把它想象成一个现实中的电话本：通过人名（键）就能快速找到电话号码（值），而不需要从头翻到尾。

1.1 字典的创建方式

python

# 方式一：花括号（最常用）
user = {"name": "小明", "age": 18}

# 方式二：dict()构造函数
user2 = dict(name="小红", age=20)

# 方式三：通过列表生成
user3 = dict([("name", "小刚"), ("age", 22)])

# 空字典
empty_dict = {}

1.2 字典的关键约束

使用字典时，有两个核心规则必须牢记：

约束	说明
键必须唯一	如果同一个键被赋值两次，后面的值会覆盖前面的值
键必须不可变	键只能是字符串、数字、元组等不可变类型；列表、字典、集合不能作为键

python

# 合法的键
d = {
    1: "数字键",
    "name": "字符串键",
    (1, 2): "元组键"   # 元组不可变，OK
}

# 非法的键（会报错 TypeError）
d = {[1, 2]: "列表键"}  # 列表可变，不能作为键

二、字典的核心操作（增删改查）

这是日常开发中使用频率最高的部分，务必熟练掌握。

2.1 查（访问元素）

python

user = {"name": "小明", "age": 18}

# 方法1：直接通过key访问（key不存在时会报错 KeyError）
print(user["name"])   # 输出: 小明
# print(user["sex"])  # 报错！

# 方法2：使用get()方法（推荐，安全）
print(user.get("sex"))          # 输出: None
print(user.get("sex", "未知"))  # 输出: 未知（可指定默认值）

# 方法3：setdefault()（如果key不存在，则设置默认值并返回）
age = user.setdefault("age", 0)    # 存在，返回18
sex = user.setdefault("sex", "男") # 不存在，添加 sex="男"，返回"男"
print(user)  # {'name': '小明', 'age': 18, 'sex': '男'}

2.2 增 / 改（添加或修改元素）

python

user = {"name": "小明"}

# 直接赋值：key存在则修改，不存在则新增
user["age"] = 18      # 新增
user["name"] = "大明" # 修改

print(user)  # {'name': '大明', 'age': 18}

# 批量更新：使用update()合并另一个字典
user.update({"city": "北京", "age": 19})
print(user)  # {'name': '大明', 'age': 19, 'city': '北京'}

2.3 删（删除元素）

python

user = {"name": "小明", "age": 18, "city": "北京"}

# pop(key)：删除指定key，并返回对应的值
age = user.pop("age")
print(age)          # 18
print(user)         # {'name': '小明', 'city': '北京'}

# popitem()：删除并返回最后一个键值对（Python3.7+ 有序）
item = user.popitem()
print(item)         # ('city', '北京')
print(user)         # {'name': '小明'}

# del：删除指定key
del user["name"]
print(user)         # {}

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

三、字典的遍历技巧

python

user = {"name": "小明", "age": 18, "city": "北京"}

# 1. 遍历所有key（默认）
for key in user:
    print(key, user[key])

# 2. 遍历所有key（更明确）
for key in user.keys():
    print(key)

# 3. 遍历所有value
for value in user.values():
    print(value)

# 4. 遍历所有键值对（最常用，效率高）
for key, value in user.items():
    print(f"{key}: {value}")

四、字典与列表的性能对比（重要！）

很多初学者在处理数据时习惯用列表，但在数据量较大时，列表的查找效率远低于字典。

场景	列表（List）	字典（Dict）
查找元素	O(n) — 需要逐个遍历	O(1) — 直接通过哈希计算位置
插入元素	O(1) 或 O(n)（插入中间位置）	O(1)
删除元素	O(n)	O(1)
适用场景	有序数据、栈、队列	快速查找、映射关系、缓存

实际案例：

假设有一个包含100万条数据的列表，要查找某个元素是否存在，最坏情况下需要遍历100万次。而使用字典，只需要一次哈希计算，速度是天壤之别。

python

import time

# 列表查找
lst = list(range(1000000))
start = time.time()
print(999999 in lst)  # True
print("列表查找耗时:", time.time() - start)

# 字典查找（key就是数字本身）
d = {i: i for i in range(1000000)}
start = time.time()
print(999999 in d)    # True
print("字典查找耗时:", time.time() - start)

运行结果会让你直观感受到字典的速度优势。

五、进阶技巧（实用干货）

5.1 字典推导式

类似列表推导式，可以快速生成字典。

python

# 生成平方数字典
squares = {x: x**2 for x in range(5)}
print(squares)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# 过滤：只保留偶数
even_squares = {x: x**2 for x in range(10) if x % 2 == 0}
print(even_squares)  # {0: 0, 2: 4, 4: 16, 6: 36, 8: 64}

5.2 defaultdict —— 避免KeyError的利器

当你需要统计频次或分组时，defaultdict 可以省去判断key是否存在的麻烦。

python

from collections import defaultdict

# 普通方式：需要判断
words = ["apple", "banana", "apple", "orange", "banana", "apple"]
count = {}
for word in words:
    if word in count:
        count[word] += 1
    else:
        count[word] = 1

# 使用defaultdict：自动初始化
count = defaultdict(int)  # 默认值为0
for word in words:
    count[word] += 1

print(dict(count))  # {'apple': 3, 'banana': 2, 'orange': 1}

5.3 Counter —— 计数专用

如果只是做计数，collections.Counter 更加方便。

python

from collections import Counter

words = ["apple", "banana", "apple", "orange", "banana", "apple"]
count = Counter(words)
print(count)          # Counter({'apple': 3, 'banana': 2, 'orange': 1})
print(count["apple"]) # 3

5.4 合并字典的几种方式

python

d1 = {"a": 1, "b": 2}
d2 = {"b": 3, "c": 4}

# Python 3.9+ 使用 | 操作符
d3 = d1 | d2
print(d3)  # {'a': 1, 'b': 3, 'c': 4}

# 使用 ** 解包（通用）
d4 = {**d1, **d2}
print(d4)  # {'a': 1, 'b': 3, 'c': 4}

# 使用 update()（会修改原字典）
d1.update(d2)
print(d1)  # {'a': 1, 'b': 3, 'c': 4}

六、底层原理：哈希表与散列冲突

字典之所以这么快，底层依靠的是哈希表（Hash Table）。

工作流程：

当你存储一个键值对时，Python会计算键的哈希值（通过 hash() 函数）。
根据哈希值计算出该键值对在内存数组中的存储位置（索引）。
当你要查找一个键时，同样计算哈希值，然后直接跳转到对应位置读取数据，一步到位。

关于哈希冲突：

不同的键有可能计算出相同的哈希值（或映射到同一个位置），这称为“哈希冲突”。Python采用开放寻址法来解决冲突——如果发现目标位置已被占用，就会继续向下探测，直到找到一个空位。

为什么键必须是不可变类型？

因为如果键是可变的（比如列表），其内容一旦变化，哈希值就会改变，导致无法再找到之前存储的数据。所以Python强制要求键必须是不可变类型。

七、常见“坑”与避坑指南

坑1：遍历时修改字典

python

d = {"a": 1, "b": 2, "c": 3}

# 错误：在遍历过程中删除元素会报错
for key in d:
    if key == "b":
        del d[key]  # RuntimeError: dictionary changed size during iteration

# 正确方式：先转为列表再遍历
for key in list(d.keys()):
    if key == "b":
        del d[key]
print(d)  # {'a': 1, 'c': 3}

坑2：用列表作为键

python

# 错误示例
d = {[1, 2]: "value"}  # TypeError: unhashable type: 'list'

# 如果需要用序列作为键，请用元组
d = {(1, 2): "value"}   # OK

坑3：复制字典时引用同一个对象

python

d1 = {"a": [1, 2]}
d2 = d1          # 浅复制，d2和d1指向同一个对象
d2["a"].append(3)
print(d1)        # {'a': [1, 2, 3]}  —— 原字典被修改了！

# 正确方式：深拷贝
import copy
d1 = {"a": [1, 2]}
d2 = copy.deepcopy(d1)
d2["a"].append(3)
print(d1)        # {'a': [1, 2]}  —— 原字典不变

八、总结

知识点	要点
核心特性	键值对存储、键唯一且不可变、无序（Python3.7+ 插入有序）
访问方式	优先使用 `get()` 避免KeyError
遍历	`items()` 遍历键值对效率最高
性能	查找/插入/删除都是O(1)，远优于列表
底层	基于哈希表实现，键必须可哈希
推荐库	`defaultdict`、`Counter` 简化代码