从入门到实战全解析Python中字典Dict的常用方法
作者：小小测试开发
在Python编程中，字典（Dictionary）是一种核心的“键值对”数据结构，堪称“数据存储的万能 钥匙”。相比于列表的有序索引访问，字典通过唯一的“键（Key）”映射“值（Value）”，能实现O(1)时间复杂度的高效查找，在配置存储、数据关联、缓存实现等场景中不可或缺。本文将系统梳理字典的核心特性、创建方式、常用方法，结合大量实战示例，带你从“会用”到“活用”字典。
一、先搞懂：字典的核心特性（对比列表/元组更易理解）
字典与列表、元组同属Python基础数据结构，但核心设计逻辑差异显著，先通过对比表快速明确字典的核心特征：
| 特性 | 字典（Dict） | 列表（List） | 元组（Tuple） |
|---|---|---|---|
| 数据结构 | 键值对（哈希表） | 有序序列 | 有序不可变序列 |
| 访问方式 | 通过键（Key）访问 | 通过索引（0开始）访问 | 通过索引（0开始）访问 |
| 可变性 | 可变（支持增删改键值对） | 可变（支持增删改元素） | 不可变（创建后无法修改） |
| 元素唯一性 | 键（Key）唯一，值（Value）可重复 | 元素可重复 | 元素可重复 |
| 适用场景 | 存储关联数据、配置项、缓存等 | 存储动态序列数据、任务队列等 | 存储固定数据、多返回值等 |
字典核心特性总结：
- 键值映射：每个元素是“key: value”对，通过key快速定位value；
- 键唯一性：同一个字典中key不能重复，重复赋值会覆盖原有value；
- 键不可变：key必须是不可变类型（字符串、数字、元组等），列表、字典等可变类型不能作为key；
- 值包容性：value可是任意类型（字符串、数字、列表、字典等），支持嵌套；
- 高效查找：基于哈希表实现，查找、添加、删除操作效率远高于列表。
二、字典的5种常见创建方式
在使用字典前，先掌握多种创建方式，按需选择最高效的方式：
1. 直接用{}创建（最常用）
# 空字典
empty_dict = {}
print(empty_dict, type(empty_dict)) # 输出：{} <class 'dict'>
# 普通键值对字典（key为字符串、数字）
user_info = {
"name": "张三",
"age": 25,
"is_student": False
}
print(user_info) # 输出：{'name': '张三', 'age': 25, 'is_student': False}
2. 用dict()函数创建
# 方式1：传入键值对参数
user_info = dict(name="张三", age=25, is_student=False)
print(user_info) # 输出：{'name': '张三', 'age': 25, 'is_student': False}
# 方式2：传入可迭代对象（如列表、元组）
list_data = [("name", "张三"), ("age", 25)]
user_info = dict(list_data)
print(user_info) # 输出：{'name': '张三', 'age': 25}
3. 字典推导式（快速生成字典）
# 生成键为1-5、值为键平方的字典
square_dict = {x: x*x for x in range(1, 6)}
print(square_dict) # 输出：{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
# 过滤推导：只保留键为偶数的项
even_square_dict = {x: x*x for x in range(1, 6) if x % 2 == 0}
print(even_square_dict) # 输出：{2: 4, 4: 16}
4. 用fromkeys()创建（指定键，值默认统一）
# 语法：dict.fromkeys(keys, value)
# 生成键为["a", "b", "c"]、值默认None的字典
default_dict = dict.fromkeys(["a", "b", "c"])
print(default_dict) # 输出：{'a': None, 'b': None, 'c': None}
# 生成键为1-3、值统一为0的字典
zero_dict = dict.fromkeys(range(1, 4), 0)
print(zero_dict) # 输出：{1: 0, 2: 0, 3: 0}
5. 嵌套字典（存储复杂数据）
# 字典嵌套：存储用户的详细信息
user_detail = {
"name": "张三",
"age": 25,
"contact": {
"phone": "13800138000",
"email": "zhangsan@example.com"
},
"hobbies": ["篮球", "编程"]
}
print(user_detail["contact"]["phone"]) # 输出：13800138000
三、字典常用方法全解析（按功能分类）
字典的方法围绕“键值对的添加/修改、删除、查询、遍历、其他操作”展开，每个方法均包含「语法」「作用」「实战示例」和「注意点」，帮你精准掌握用法。
1. 键值对添加/修改：4种核心方式
字典的可变性核心体现在“动态添加/修改键值对”，常用4种方式，按需选择：
直接赋值（最常用）
语法：dict[key] = value
作用：如果key不存在，新增键值对；如果key已存在，修改对应value。
user_info = {"name": "张三", "age": 25}
# key不存在，新增键值对
user_info["gender"] = "男"
print(user_info) # 输出：{'name': '张三', 'age': 25, 'gender': '男'}
# key已存在，修改value
user_info["age"] = 26
print(user_info) # 输出：{'name': '张三', 'age': 26, 'gender': '男'}
注意点：key必须是不可变类型（字符串、数字、元组等），否则会报错（如list作为key会报TypeError）。
update()：批量添加/修改键值对
语法：dict.update(other_dict/iterable)
作用：批量添加/修改键值对，参数可以是另一个字典，或可迭代的键值对序列（如列表、元组）。
user_info = {"name": "张三", "age": 25}
# 传入另一个字典，批量修改/添加
update_dict = {"age": 26, "gender": "男", "phone": "13800138000"}
user_info.update(update_dict)
print(user_info) # 输出：{'name': '张三', 'age': 26, 'gender': '男', 'phone': '13800138000'}
# 传入可迭代序列（列表嵌套元组）
user_info.update([("email", "zhangsan@example.com"), ("hobby", "篮球")])
print(user_info) # 输出：新增email和hobby键值对
注意点：update()会直接修改原字典，不会返回新字典；如果传入的key已存在，会覆盖原有value。
setdefault()：添加键值对（key不存在时）
语法：dict.setdefault(key, default_value)
作用：如果key不存在，新增键值对（key: default_value），并返回default_value；如果key已存在，不修改value，直接返回原有value。
user_info = {"name": "张三", "age": 25}
# key不存在，新增并返回默认值
gender = user_info.setdefault("gender", "男")
print(gender) # 输出：男
print(user_info) # 输出：{'name': '张三', 'age': 25, 'gender': '男'}
# key已存在，返回原有value，不修改
age = user_info.setdefault("age", 26)
print(age) # 输出：25
print(user_info) # 输出：无变化
注意点：如果不指定default_value，默认值为None（即key不存在时，value设为None）。
2. 键值对删除：4种常用方式
删除字典中的键值对，核心区别在于“删除依据”（按key/按最后一对）和“是否保留删除的value”：
del：按key删除键值对（通用语法）
语法：del dict[key]
作用：删除指定key对应的键值对；如果key不存在，会报错。
user_info = {"name": "张三", "age": 25, "gender": "男"}
# 按key删除
del user_info["gender"]
print(user_info) # 输出：{'name': '张三', 'age': 25}
# 删除不存在的key，报错
# del user_info["phone"] # 报错：KeyError: 'phone'
注意点：del是Python内置语法，不是字典的方法；删除前建议用key in dict判断key是否存在。
pop()：按key删除，返回删除的value
语法：dict.pop(key, default)
作用：删除指定key对应的键值对，并返回该key的value；如果key不存在，若指定了default则返回default，否则报错。
user_info = {"name": "张三", "age": 25, "gender": "男"}
# 按key删除，返回value
gender = user_info.pop("gender")
print(gender) # 输出：男
print(user_info) # 输出：{'name': '张三', 'age': 25}
# key不存在，指定默认值，不报错
phone = user_info.pop("phone", "未知")
print(phone) # 输出：未知
# key不存在，不指定默认值，报错
# user_info.pop("email") # 报错：KeyError: 'email'
注意点：pop()是唯一“删除键值对并返回value”的方法，适合需要复用删除value的场景。
popitem()：删除最后一对键值对（Python 3.7+）
语法：dict.popitem()
作用：删除字典中“最后插入”的键值对，并返回该键值对组成的元组（key, value）；如果字典为空，会报错。
user_info = {"name": "张三", "age": 25, "gender": "男"}
# 删除最后一对，返回元组
last_item = user_info.popitem()
print(last_item) # 输出：('gender', '男')
print(user_info) # 输出：{'name': '张三', 'age': 25}
# 继续删除最后一对
last_item = user_info.popitem()
print(last_item) # 输出：('age', 25)
注意点：Python 3.7之前，字典是无序的，popitem()会随机删除一对键值对；3.7及之后，字典有序，删除最后插入的一对。
clear()：清空所有键值对
语法：dict.clear()
作用：删除字典中的所有键值对，将字典变为空字典（保留字典对象本身）。
user_info = {"name": "张三", "age": 25}
user_info.clear()
print(user_info) # 输出：{}
print(type(user_info)) # 输出：<class 'dict'>（对象仍存在）
注意点：clear()是“清空元素”，不是删除字典对象；如果想直接删除字典对象，可用del dict_name。
3. 键值对查询：5种常用方式
查询是字典最核心的操作之一，常用方式包括“按key直接查询、get()查询、获取所有键/值/键值对”：
按key直接查询（最常用）
语法：dict[key]
作用：返回指定key对应的value；如果key不存在，会报错。
user_info = {"name": "张三", "age": 25}
# 按key查询
print(user_info["name"]) # 输出：张三
# key不存在，报错
# print(user_info["phone"]) # 报错：KeyError: 'phone'
注意点：适合确定key存在的场景；如果key可能不存在，建议用get()方法。
get()：安全查询（推荐）
语法：dict.get(key, default)
作用：返回指定key对应的value；如果key不存在，若指定了default则返回default，否则返回None（不报错）。
user_info = {"name": "张三", "age": 25}
# key存在，返回value
print(user_info.get("name")) # 输出：张三
# key不存在，返回默认值
print(user_info.get("phone", "未知")) # 输出：未知
# key不存在，不指定默认值，返回None
print(user_info.get("email")) # 输出：None
注意点：get()是最安全的查询方式，能有效避免KeyError，推荐日常开发优先使用。
keys()：获取所有key
语法：dict.keys()
作用：返回字典中所有key组成的“视图对象”（可迭代，类似列表，但不支持索引）；可通过list()转换为列表。
user_info = {"name": "张三", "age": 25, "gender": "男"}
# 获取key视图对象
keys = user_info.keys()
print(keys) # 输出：dict_keys(['name', 'age', 'gender'])
print(type(keys)) # 输出：<class 'dict_keys'>
# 转换为列表
key_list = list(keys)
print(key_list) # 输出：['name', 'age', 'gender']
values()：获取所有value
语法：dict.values()
作用：返回字典中所有value组成的视图对象，可通过list()转换为列表。
user_info = {"name": "张三", "age": 25, "gender": "男"}
values = user_info.values()
print(values) # 输出：dict_values(['张三', 25, '男'])
print(list(values)) # 输出：['张三', 25, '男']
items()：获取所有键值对
语法：dict.items()
作用：返回字典中所有键值对组成的视图对象，每个键值对是一个元组（key, value）；可通过list()转换为列表。
user_info = {"name": "张三", "age": 25, "gender": "男"}
items = user_info.items()
print(items) # 输出：dict_items([('name', '张三'), ('age', 25), ('gender', '男')])
print(list(items)) # 输出：[('name', '张三'), ('age', 25), ('gender', '男')]
4. 字典遍历：3种常用方式
结合keys()、values()、items()，可实现对字典的灵活遍历：
遍历所有key
user_info = {"name": "张三", "age": 25, "gender": "男"}
# 方式1：直接遍历字典（默认遍历key）
for key in user_info:
print(key) # 输出：name、age、gender
# 方式2：通过keys()遍历
for key in user_info.keys():
print(key)
遍历所有value
user_info = {"name": "张三", "age": 25, "gender": "男"}
for value in user_info.values():
print(value) # 输出：张三、25、男
遍历所有键值对（最常用）
user_info = {"name": "张三", "age": 25, "gender": "男"}
for key, value in user_info.items():
print(f"{key}: {value}")
# 输出：
# name: 张三
# age: 25
# gender: 男
5. 其他实用操作：copy()、in判断
copy()：复制字典（浅拷贝）
语法：dict.copy()
作用：返回字典的“浅拷贝”副本（新字典），修改副本不会影响原字典（区别于直接赋值）。
# 直接赋值（引用传递，修改新字典会影响原字典）
user1 = {"name": "张三", "age": 25}
user2 = user1
user2["age"] = 26
print(user1) # 输出：{'name': '张三', 'age': 26}（原字典被修改）
# copy()拷贝（值传递，修改副本不影响原字典）
user3 = user1.copy()
user3["age"] = 25
print(user1) # 输出：{'name': '张三', 'age': 26}（原字典未变）
print(user3) # 输出：{'name': '张三', 'age': 25}
注意点：copy()是浅拷贝，如果字典中有嵌套的可变对象（如嵌套字典、列表），修改嵌套对象仍会影响原字典；深拷贝需用copy模块的deepcopy函数。
in/not in：判断key是否存在
语法：key in dict / key not in dict
作用：判断指定key是否存在于字典中，返回布尔值（True/False）。
user_info = {"name": "张三", "age": 25}
print("name" in user_info) # 输出：True
print("phone" in user_info) # 输出：False
print("phone" not in user_info) # 输出：True
注意点：in判断的是“key是否存在”，而非value；判断value是否存在需用value in dict.values()（效率较低，不推荐频繁使用）。
四、字典实战场景：3个高频案例
结合实际开发场景，看看字典的具体应用：
1. 场景1：存储用户配置信息
# 存储应用的用户配置
config = {
"app_name": "Python工具集",
"version": "1.0.0",
"theme": "dark",
"language": "zh-CN",
"settings": {
"auto_update": True,
"cache_size": 1024
}
}
# 读取配置
print(f"应用名称：{config['app_name']}")
print(f"是否自动更新：{config['settings']['auto_update']}")
# 修改配置
config["theme"] = "light"
config["settings"]["cache_size"] = 2048
print("修改后主题：", config["theme"])
2. 场景2：统计字符串词频
# 统计一段文本中每个单词出现的次数
text = "I love Python Python is easy I love coding"
words = text.split() # 拆分字符串为单词列表
word_count = {}
for word in words:
# 方式1：用in判断
if word in word_count:
word_count[word] += 1
else:
word_count[word] = 1
# 方式2：用get()简化（更简洁）
# word_count[word] = word_count.get(word, 0) + 1
print(word_count) # 输出：{'I': 2, 'love': 2, 'Python': 2, 'is': 1, 'easy': 1, 'coding': 1}
3. 场景3：模拟接口返回数据
# 模拟后端接口返回的JSON数据（Python中用字典表示）
api_response = {
"code": 200,
"msg": "success",
"data": {
"user_list": [
{"id": 1, "name": "张三", "age": 25},
{"id": 2, "name": "李四", "age": 26}
],
"total": 2
}
}
# 解析接口数据
if api_response["code"] == 200:
total = api_response["data"]["total"]
user_list = api_response["data"]["user_list"]
print(f"总用户数：{total}")
for user in user_list:
print(f"用户ID：{user['id']}，姓名：{user['name']}")
else:
print("接口请求失败：", api_response["msg"])
五、新手必避的4个字典坑
- KeyError：key不存在：直接用
dict[key]查询不存在的key会报错；避免方法：用get()方法，或先通过in判断key是否存在。 - key必须是不可变类型：列表、字典等可变类型不能作为key，否则会报TypeError；正确做法：用字符串、数字、元组等不可变类型作为key。
- 浅拷贝的嵌套对象问题：copy()是浅拷贝，修改嵌套的可变对象（如嵌套字典）会影响原字典；解决方法：用
copy.deepcopy()实现深拷贝。 - 遍历中修改字典的坑：在for循环中直接添加/删除键值对，可能导致遍历不完整；避免方法：遍历字典的副本（如
for key in dict.copy()），或先收集要修改的key，再批量处理。
六、总结：字典常用方法速查表与核心原则
为方便快速查阅，整理字典常用方法速查表：
| 功能分类 | 方法/语法 | 核心作用 | 关键提示 |
|---|---|---|---|
| 添加/修改 | dict[key] = value | 新增/修改单个键值对 | key不存在则新增，存在则修改 |
| update(other) | 批量新增/修改 | 参数为字典或可迭代键值对 | |
| setdefault(key, default) | key不存在时新增 | 存在则返回原有value，不修改 | |
| 删除 | del dict[key] | 按key删除 | key不存在报错 |
| pop(key, default) | 按key删除，返回value | 可指定默认值，避免报错 | |
| popitem() | 删除最后一对键值对 | 3.7+有序，返回（key, value） | |
| clear() | 清空所有键值对 | 保留字典对象 | |
| 查询 | dict[key] | 按key查询value | key不存在报错 |
| get(key, default) | 安全查询value | 不存在返回default/None | |
| keys() | 获取所有key | 返回视图对象，可转列表 | |
| values() | 获取所有value | 返回视图对象，可转列表 | |
| items() | 获取所有键值对 | 返回视图对象，元素为元组 | |
| 其他 | copy() | 浅拷贝字典 | 嵌套可变对象仍受影响 |
| key in dict | 判断key是否存在 | 高效，推荐优先使用 |
字典核心使用原则：
- 查询优先用get()，避免KeyError；
- 新增/修改单个键值对用直接赋值，批量操作用update()；
- 删除需复用value用pop()，删除最后一对用popitem()，清空用clear()；
- 遍历键值对优先用items()，遍历key/value分别用keys()/values()；
- 判断key是否存在用in，避免无效查询。
字典是Python中最灵活、最高效的数据结构之一，掌握以上方法和技巧，能大幅提升你的开发效率。多结合实战场景练习，就能熟练驾驭字典的各种用法。
到此这篇关于从入门到实战全解析Python中字典Dict的常用方法的文章就介绍到这了,更多相关Python字典Dict常用方法内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！