8.Python3字典（dict）：键值的增删改查_入门到进阶

南_山无梅落2025-12-14 8:19

字典是Python中非常强大的内置数据结构，像是一个"智能索引卡片盒"。我们从以下几个方面来讲解：

目录

[1. 字典是什么？](#1. 字典是什么？)

[2. 创建字典](#2. 创建字典)

[3. 增：添加键值对](#3. 增：添加键值对)

[4. 删：删除键值对](#4. 删：删除键值对)

[5. 改：修改键值对](#5. 改：修改键值对)

[6. 查：查找键值对](#6. 查：查找键值对)

[7. 字典遍历](#7. 字典遍历)

[8. 字典操作总结表](#8. 字典操作总结表)

[9. 字典 vs 列表 vs 元组](#9. 字典 vs 列表 vs 元组)

[10. 常见错误提醒](#10. 常见错误提醒)

[11. 字典的进阶用法](#11. 字典的进阶用法)

[12. 总结](#12. 总结)

字典（dict）- 键值对集合

1. 字典是什么？

字典是一种可变 的、无序的键值对集合。每个键（key）对应一个值（value），就像我们现实中的字典：通过"单词"（键）查找对应的"解释"（值）。

特点：

  • 键必须是不可变类型（字符串、数字、元组）
  • 值可以是任意类型
  • 字典无序（Python 3.7+ 虽然保持了插入顺序，但本质上还是无序的）

关于有序无序的补充：

以前是纯哈希表（专门用来存储**"键值对"**（Key-Value）的数据结构。无论数据结构有多大，通过键可以迅速定位到对应的值）。哈希表可以看成一个大仓库，东西都乱放的，没有顺序。

现在说的有序，其实是多加了一个索引数组，字典的存储就更紧凑、省内存。我们通过索引数组（前台），找到对应哈希表（后台）的键值对的位置。输出的话，就是按照后台的插入顺序01234输出。所以看起来有序。

  • 建议：在日常写代码时，完全可以依赖字典的插入顺序 ，不用担心它变乱。

2. 创建字典

python 复制代码 
# 空字典
empty_dict = {}

# 有元素的字典（使用大括号）
student = {
    "name": "小明",
    "age": 18,
    "grade": "高三"
}

# 使用dict()构造函数
person = dict(name="小红", age=17, city="北京")

# 混合类型字典
mixed = {
    "整数": 100,
    "字符串": "Python",
    "列表": [1, 2, 3],
    "元组": (4, 5, 6),
    "嵌套字典": {"key": "value"}
}

print(student)  # 输出：{'name': '小明', 'age': 18, 'grade': '高三'}

代码解释 ：用大括号{}创建字典，键值对用key: value格式，之间用逗号隔开。

3. 增：添加键值对

python 复制代码 
# 创建一个空字典
info = {}

# 方法1：直接赋值添加（最常用）
info["name"] = "张三"
info["age"] = 25
print(info)  # 输出：{'name': '张三', 'age': 25}

# 方法2：update()批量添加
info.update({"job": "工程师", "city": "上海"})
print(info)  # 输出：{'name': '张三', 'age': 25, 'job': '工程师', 'city': '上海'}

# 方法3：setdefault()添加（如果键不存在）
info.setdefault("salary", 8000)  # 添加，因为salary不存在
print(info)  # 输出：{'name': '张三', 'age': 25, 'job': '工程师', 'city': '上海', 'salary': 8000}

info.setdefault("name", "李四")  # 不添加，因为name已存在
print(info["name"])  # 输出：张三（保持不变）

关键点 ：dict[key] = value最简单，update()批量添加，setdefault()智能添加。

4. 删：删除键值对

python 复制代码 
data = {"a": 1, "b": 2, "c": 3, "d": 4, "e": 5}

# 方法1：del 根据键删除
del data["a"]  # 删除键为"a"的项
print(data)  # 输出：{'b': 2, 'c': 3, 'd': 4, 'e': 5}

# 方法2：pop() 删除并返回值
value = data.pop("b")  # 删除键为"b"的项，并返回值
print(f"删除的值：{value}")  # 输出：2
print(f"删除后字典：{data}")  # 输出：{'c': 3, 'd': 4, 'e': 5}

# 方法3：popitem() 删除最后一项（Python 3.7+）
key, value = data.popitem()  # 删除并返回最后一项
print(f"删除的键值对：{key}={value}")  # 输出：e=5
print(f"删除后字典：{data}")  # 输出：{'c': 3, 'd': 4}

# 方法4：clear() 清空字典
data.clear()
print(data)  # 输出：{}

关键点 ：del直接删除，pop()删除并返回，popitem()删除最后一项，clear()清空全部。

5. 改：修改键值对

python 复制代码 
user = {"name": "张三", "age": 20, "city": "北京"}

# 方法1：直接赋值修改
user["age"] = 21  # 修改年龄
print(user)  # 输出：{'name': '张三', 'age': 21, 'city': '北京'}

# 方法2：update()批量修改
user.update({"city": "上海", "job": "学生"})  # 修改城市，添加工作
print(user)  # 输出：{'name': '张三', 'age': 21, 'city': '上海', 'job': '学生'}

# 注意：如果update的键不存在，会新增键值对

6. 查：查找键值对

python 复制代码 
book = {
    "title": "Python编程",
    "author": "John",
    "price": 59.9,
    "year": 2023
}

# 方法1：直接通过键访问
title = book["title"]
print(f"书名：{title}")  # 输出：Python编程

# 方法2：get()安全访问（推荐）
price = book.get("price")
print(f"价格：{price}")  # 输出：59.9

# get()可以设置默认值（键不存在时返回默认值）
pages = book.get("pages", 300)  # pages键不存在，返回默认值300
print(f"页数：{pages}")  # 输出：300

# 方法3：in检查键是否存在
if "author" in book:
    print(f"作者存在：{book['author']}")  # 输出：作者存在：John

# 方法4：keys()获取所有键
all_keys = book.keys()
print(f"所有键：{list(all_keys)}")  # 输出：['title', 'author', 'price', 'year']

# 方法5：values()获取所有值
all_values = book.values()
print(f"所有值：{list(all_values)}")  # 输出：['Python编程', 'John', 59.9, 2023]

# 方法6：items()获取所有键值对
all_items = book.items()
print(f"所有键值对：{list(all_items)}")
# 输出：[('title', 'Python编程'), ('author', 'John'), ('price', 59.9), ('year', 2023)]

# 方法7：len()获取键值对数量
count = len(book)
print(f"字典长度：{count}")  # 输出：4

关键点 ：get()比直接访问更安全，keys()、values()、items()是三个重要方法。

7. 字典遍历

python 复制代码 
student = {"name": "小明", "age": 18, "grade": "高三", "score": 95}

print("=== 遍历所有键 ===")
for key in student:
    print(f"键：{key}")

print("\n=== 遍历所有值 ===")
for value in student.values():
    print(f"值：{value}")

print("\n=== 遍历所有键值对 ===")
for key, value in student.items():
    print(f"{key}: {value}")

# 输出：
# 键：name
# 键：age
# 键：grade
# 键：score
# 
# 值：小明
# 值：18
# 值：高三
# 值：95
# 
# name: 小明
# age: 18
# grade: 高三
# score: 95

8. 字典操作总结表

|--------|----------------------------|---------|------------------------|--------|
| 操作类型 | 方法/语法 | 作用 | 示例 | 返回值 |
| 创建 | {} | 创建字典 | d = {"a": 1} | 字典 |
| | dict() | 构造函数 | d = dict(a=1) | 字典 |
| 增 | d[key] = value | 添加/修改 | d["b"] = 2 | 无 |
| | update(dict2) | 批量添加 | d.update({"c":3}) | 无 |
| | setdefault(key, default) | 智能添加 | d.setdefault("d", 4) | 值 |
| 删 | del d[key] | 删除指定键 | del d["a"] | 无 |
| | pop(key) | 删除并返回 | d.pop("b") | 值 |
| | popitem() | 删除最后一项 | d.popitem() | (键, 值) |
| | clear() | 清空字典 | d.clear() | 无 |
| 改 | d[key] = value | 修改值 | d["a"] = 10 | 无 |
| | update(dict2) | 批量修改 | d.update({"a":10}) | 无 |
| 查 | d[key] | 访问值 | d["a"] | 值 |
| | get(key, default) | 安全访问 | d.get("z", 0) | 值 |
| | keys() | 所有键 | d.keys() | 键视图 |
| | values() | 所有值 | d.values() | 值视图 |
| | items() | 所有键值对 | d.items() | 键值对视图 |
| | in | 检查键是否存在 | "a" in d | 布尔值 |
| | len(d) | 获取长度 | len(d) | 整数 |

9. 字典 vs 列表 vs 元组

|----------|-----------------------------|----------------|--------------|
| 对比项 | 字典 | 列表 | 元组 |
| 符号 | {} | [] | () |
| 存储方式 | 键值对 | 有序序列 | 有序序列 |
| 可变性 | ✅ 可修改 | ✅ 可修改 | ❌ 不可修改 |
| 索引方式 | 键 | 整数索引 | 整数索引 |
| 查找速度 | 极快（通过键） | 较慢（遍历） | 较慢（遍历） |
| 内存占用 | 较多 | 中等 | 较少 |
| 典型用途 | 配置文件、JSON数据、数据库记录 | 动态数据集合 | 固定数据、函数返回多个值 |
| 示例 | {"name": "小明", "age": 18} | ["小明", "小红"] | (100, 200) |

建议：需要快速通过键查找数据就用字典，需要有序集合就用列表，数据固定就用元组。

10. 常见错误提醒

python 复制代码 
# 错误1：用可变类型作为字典的键
# d = {[1, 2]: "列表"}  # TypeError: unhashable type: 'list'
# d = {{"a":1}: "字典"}  # TypeError: unhashable type: 'dict'

# 正确：用不可变类型作为键
d1 = {("a", "b"): "元组作为键"}  # 正确，元组不可变
d2 = {"字符串": "值"}  # 正确，字符串不可变
d3 = {100: "数字"}  # 正确，数字不可变

# 错误2：访问不存在的键
# data = {"a": 1}
# print(data["b"])  # KeyError: 'b'

# 正确：使用get()方法
value = data.get("b", 0)  # 键不存在时返回默认值0
print(value)  # 输出：0

# 错误3：遍历时修改字典大小
# d = {"a": 1, "b": 2, "c": 3}
# for key in d:
#     if key == "b":
#         del d[key]  # RuntimeError: dictionary changed size during iteration

# 正确：先收集要删除的键，再删除
d = {"a": 1, "b": 2, "c": 3}
to_delete = []
for key in d:
    if key == "b":
        to_delete.append(key)
for key in to_delete:
    del d[key]
print(d)  # 输出：{'a': 1, 'c': 3}

11. 字典的进阶用法

python 复制代码 
# 1. 字典推导式（类似列表推导式）
squares = {x: x*x for x in range(1, 6)}
print(squares)  # 输出：{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# 2. 字典合并（Python 3.5+）
dict1 = {"a": 1, "b": 2}
dict2 = {"c": 3, "d": 4}
merged = {**dict1, **dict2}  # 合并两个字典
print(merged)  # 输出：{'a': 1, 'b': 2, 'c': 3, 'd': 4}

# 3. 嵌套字典
students = {
    "小明": {"age": 18, "grade": "A"},
    "小红": {"age": 17, "grade": "B"},
    "小刚": {"age": 19, "grade": "A+"}
}

# 访问嵌套字典
print(students["小明"]["age"])  # 输出：18

# 4. fromkeys()快速创建字典
keys = ["name", "age", "city"]
default_dict = dict.fromkeys(keys, "未知")
print(default_dict)  # 输出：{'name': '未知', 'age': '未知', 'city': '未知'}

# 5. 带条件的字典推导式
numbers = [1, 2, 3, 4, 5, 6]
even_squares = {x: x*x for x in numbers if x % 2 == 0}
print(even_squares)  # 输出：{2: 4, 4: 16, 6: 36}

代码解释：

squares = {x: x*x for x in range(1, 6)}

**range(1, 6)：**生成从 1 到 5 的整数序列（不包括 6）

**for x in range(1, 6)：**遍历这个序列中的每个数字

**x: x*x：**对于每个数字 x，创建一个键值对，其中键是 x，值是 x 的平方

**{...}：**用花括号包围表示创建一个字典

**squares =：**将生成的字典赋值给变量 squares

它的传统写法是：

python 复制代码 
squares = {}
for x in range(1, 6):
    squares[x] = x * x

字典推导式，是一种更简洁的创建字典的方式。

12. 总结

  • 字典：键值对集合，通过键快速查找值
  • 核心特点：可变、无序、键必须不可变
  • 常用操作 ：增删改查四类操作
  • 安全访问 ：优先使用get()方法避免KeyError
  • 三大视图 ：keys()、values()、items()是遍历字典的关键
  • 使用场景：配置文件、JSON数据处理、数据库记录、缓存等

记忆口诀：

  • 字典用{}，键值对存储
  • 键要找不可变，值可随便变
  • 增删改查样样行，get()访问最安全
  • 遍历用items()，清晰又方便

这篇文章涵盖了字典的核心操作，从基础的增删改查到进阶用法，帮助你全面掌握Python字典的使用，让我们一起加油吧~

相关推荐
爱尔兰极光4 小时前
Python--常量和变量
开发语言·python
柒.梧.4 小时前
数据结构：二叉排序树，平衡二叉树，红黑树的介绍
数据结构·算法
黑客思维者4 小时前
Python modbus-tk在配电物联网边缘网关的应用
开发语言·python·物联网
Cigaretter74 小时前
Day 30 类的定义与方法
开发语言·python
Xの哲學4 小时前
Linux ALSA音频架构: 从内核驱动到应用开发的全面解析
linux·服务器·算法·架构·边缘计算
是毛毛吧4 小时前
数据结构与算法11种排序算法全面对比分析
数据结构·算法
郝学胜-神的一滴4 小时前
Separate Buffer、InterleavedBuffer 策略与 OpenGL VAO 深度解析
开发语言·c++·程序人生·算法·游戏程序·图形渲染
裤裤兔4 小时前
python2与python3的兼容
开发语言·python·numpy
长安er4 小时前
LeetCode 102/103/513 二叉树层序遍历（BFS）三类经典题解题总结
数据结构·算法·leetcode·二叉树·bfs·层序遍历
热门推荐
01GitHub 镜像站点02【超详细教程】手把手教你从微软官网免费下载Windows 10官方原版ISO镜像（2025最新版）03【AutoGLM部署】本地私有化部署AI手机Agent04UV安装并设置国内源05Open-AutoGLM Windows 安装部署教程06Linux下V2Ray安装配置指南07安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）08BongoCat - 跨平台键盘猫动画工具09Cursor 又偷偷更新，这个功能太实用：Visual Editor for Cursor Browser10Windows 11 官方系统安装与重装完整教程（2025年最新版）