【Python学习】字典（Dictionary）
目录
方式3：popitem()方法（删除最后一个键值对，并返回该键值对元组）
字典（Dictionary）是Python中最常用、最灵活的数据类型之一，属于“可变容器”，用于存储键值对（key-value）数据，类似于现实生活中的“字典”——通过“拼音（键）”查找“汉字（值）”，核心优势是查找速度快、存储结构灵活，适用于需要快速通过标识获取对应数据的场景（如存储用户信息、配置参数等）。
本教程将从基础到进阶，全面讲解字典的使用方法，包含基础操作、高级技巧、常见问题及实战案例，全程搭配可直接运行的代码示例，适合Python初学者快速掌握。
一、字典的基础认知
1.1 字典的定义
字典由一对大括号 {} 包裹，内部包含若干键值对，键（key）与值（value）之间用冒号 : 分隔，不同键值对之间用逗号 , 分隔，语法格式如下：
# 基本格式 字典名 = {key1: value1, key2: value2, ..., keyn: valuen}
说明：
-
键（key）：必须是不可变数据类型，常用的有字符串（str）、整数（int）、元组（tuple）；不能用列表（list）、字典（dict）等可变类型（会报错）。
-
值（value）：可以是任意数据类型，包括字符串、整数、列表、字典、函数等，无限制。
-
键（key）必须唯一，如果出现重复键，后面的键值对会覆盖前面的（不会报错）。
1.2 字典的特点（核心）
-
可变：字典创建后，可随时添加、修改、删除键值对（不改变字典本身的内存地址）。
-
无序（Python 3.7+ 有序）：Python 3.6及之前版本，字典的键值对顺序不固定；Python 3.7及以后，字典会保留键值对的插入顺序（无需额外操作）。
-
键唯一：同一个字典中，不能有两个相同的键，重复插入会覆盖原有值。
-
查找高效：字典的查找速度远快于列表（列表需遍历所有元素，字典通过“哈希表”直接定位键，时间复杂度为O(1)）。
1.3 空字典的创建
创建空字典有两种常用方式，适用于后续动态添加键值对的场景：
# 方式1：直接用空大括号（推荐） empty_dict1 = {} # 方式2：用dict()函数 empty_dict2 = dict() print(type(empty_dict1)) # 输出：<class 'dict'> print(empty_dict2) # 输出：{}
二、字典的基础操作（必学）
2.1 字典的创建（4种常用方式）
除了空字典，实际开发中常用以下4种方式创建字典，根据场景选择即可：
方式1：直接赋值（最常用）
# 示例：存储学生信息（键为属性，值为对应信息） student = {"name": "张三", "age": 18, "gender": "男", "score": 95} print(student) # 输出：{'name': '张三', 'age': 18, 'gender': '男', 'score': 95}
方式2：用dict()函数（推荐，更灵活）
# 写法1：传入键值对参数（键无需加引号） student1 = dict(name="李四", age=19, gender="女", score=92) # 写法2：传入包含元组的列表（每个元组是一个键值对） student2 = dict([("name", "王五"), ("age", 17), ("score", 88)]) print(student1) # 输出：{'name': '李四', 'age': 19, 'gender': '女', 'score': 92} print(student2) # 输出：{'name': '王五', 'age': 17, 'score': 88}
方式3：用fromkeys()方法（创建“值相同”的字典）
语法：dict.fromkeys(键列表, 统一值)，适用于需要批量创建键，且初始值相同的场景。
# 示例：创建3个键，初始值均为None dict1 = dict.fromkeys(["a", "b", "c"]) # 示例：创建3个键，初始值均为0 dict2 = dict.fromkeys(["x", "y", "z"], 0) print(dict1) # 输出：{'a': None, 'b': None, 'c': None} print(dict2) # 输出：{'x': 0, 'y': 0, 'z': 0}
方式4：字典推导式（进阶，简洁高效）
类似列表推导式，通过表达式快速生成字典，适用于有规律的键值对生成。
# 示例1：生成键为1-5，值为键的平方的字典 dict3 = {i: i**2 for i in range(1, 6)} # 示例2：将两个列表合并为字典（键列表和值列表长度需一致） keys = ["name", "age", "gender"] values = ["赵六", 20, "男"] dict4 = {k: v for k, v in zip(keys, values)} print(dict3) # 输出：{1: 1, 2: 4, 3: 9, 4: 16, 5: 25} print(dict4) # 输出：{'name': '赵六', 'age': 20, 'gender': '男'}
2.2 字典的访问（3种方式）
访问字典的核心是“通过键（key）获取值（value）”，常用3种方式，重点掌握前两种：
方式1：直接用“字典名[键]”（最常用）
student = {"name": "张三", "age": 18, "score": 95} # 访问存在的键 print(student["name"]) # 输出：张三 print(student["age"]) # 输出：18 # 注意：访问不存在的键，会直接报错（KeyError） # print(student["height"]) # 报错：KeyError: 'height'
方式2：用get()方法（推荐，更安全）
语法：字典名.get(key, 默认值)，优势是：访问不存在的键时，不会报错，会返回默认值（默认值不写则返回None）。
student = {"name": "张三", "age": 18, "score": 95} # 访问存在的键（和直接访问效果一致） print(student.get("name")) # 输出：张三 # 访问不存在的键（返回默认值，不报错） print(student.get("height")) # 输出：None print(student.get("height", 175)) # 输出：175（自定义默认值）
方式3：访问所有键/值/键值对（批量访问）
通过3个内置方法，批量获取字典的键、值、键值对，返回可迭代对象（可用于遍历）：
student = {"name": "张三", "age": 18, "score": 95} # 1. 获取所有键：keys()，返回类似列表的对象 print(student.keys()) # 输出：dict_keys(['name', 'age', 'score']) # 转换为列表（方便操作） print(list(student.keys())) # 输出：['name', 'age', 'score'] # 2. 获取所有值：values() print(student.values()) # 输出：dict_values(['张三', 18, 95]) # 3. 获取所有键值对：items()，每个键值对是一个元组 print(student.items()) # 输出：dict_items([('name', '张三'), ('age', 18), ('score', 95)])
2.3 字典的修改（2种方式）
字典的修改核心是“修改已有键的值”，两种方式均可，根据场景选择：
方式1：直接用“字典名[键] = 新值”（最常用）
student = {"name": "张三", "age": 18, "score": 95} # 修改已有键的值 student["age"] = 19 # 将age从18改为19 student["score"] = 98 # 将score从95改为98 print(student) # 输出：{'name': '张三', 'age': 19, 'score': 98}
方式2：用update()方法（批量修改/添加）
语法：字典名.update(新字典/键值对)，功能：
-
如果新字典中的键在原字典中存在，就修改原字典对应键的值；
-
如果新字典中的键在原字典中不存在，就新增该键值对。
student = {"name": "张三", "age": 18, "score": 95} # 方式1：传入新字典（批量修改/添加） student.update({"age": 19, "gender": "男"}) print(student) # 输出：{'name': '张三', 'age': 19, 'score': 95, 'gender': '男'} # 方式2：传入键值对参数（批量修改/添加） student.update(score=98, height=175) print(student) # 输出：{'name': '张三', 'age': 19, 'score': 98, 'gender': '男', 'height': 175}
2.4 字典的添加（2种方式）
添加键值对的核心是“给原字典中不存在的键赋值”，两种方式和修改类似：
student = {"name": "张三", "age": 18} # 方式1：直接赋值（最常用） student["score"] = 95 # 新增键score，值为95 student["gender"] = "男" # 新增键gender，值为男 # 方式2：用update()方法 student.update({"height": 175, "class": "高一(1)班"}) print(student) # 输出：{'name': '张三', 'age': 18, 'score': 95, 'gender': '男', 'height': 175, 'class': '高一(1)班'}
2.5 字典的删除（4种方式）
删除字典的内容分为“删除指定键值对”“清空字典”“删除整个字典”，根据需求选择：
方式1：del 语句（删除指定键值对/整个字典）
student = {"name": "张三", "age": 18, "score": 95} # 1. 删除指定键值对（常用） del student["score"] print(student) # 输出：{'name': '张三', 'age': 18} # 2. 删除整个字典（删除后，字典变量不可再使用） del student # print(student) # 报错：NameError: name 'student' is not defined
方式2：pop()方法（删除指定键值对，并返回该键的值）
语法：字典名.pop(key, 默认值)，和get()类似，键不存在时可返回默认值（不报错）。
student = {"name": "张三", "age": 18, "score": 95} # 删除存在的键，返回对应值 score = student.pop("score") print(score) # 输出：95 print(student) # 输出：{'name': '张三', 'age': 18} # 删除不存在的键，返回默认值（不报错） height = student.pop("height", 175) print(height) # 输出：175
方式3：popitem()方法（删除最后一个键值对，并返回该键值对元组）
注意：Python 3.7+ 中，popitem() 删除的是“最后插入”的键值对；3.6及之前版本，删除的是“随机”键值对。
student = {"name": "张三", "age": 18, "score": 95} # 删除最后一个键值对（score:95） item = student.popitem() print(item) # 输出：('score', 95) print(student) # 输出：{'name': '张三', 'age': 18}
方式4：clear()方法（清空字典，保留字典变量）
清空后，字典变为空字典，变量仍可使用（区别于del删除整个字典）。
student = {"name": "张三", "age": 18, "score": 95} student.clear() print(student) # 输出：{}
三、字典的高级用法（进阶必备）
3.1 字典的遍历（3种常用方式）
遍历字典是实际开发中最常用的操作，结合keys()、values()、items()方法，可实现不同需求的遍历：
方式1：遍历所有键（最基础）
student = {"name": "张三", "age": 18, "score": 95} # 方式1：直接遍历字典（默认遍历键） for key in student: print(key) # 输出：name、age、score（顺序按插入顺序） # 方式2：用keys()方法（更直观） for key in student.keys(): print(key) # 输出效果同上
方式2：遍历所有值
student = {"name": "张三", "age": 18, "score": 95} for value in student.values(): print(value) # 输出：张三、18、95
方式3：遍历所有键值对（最常用）
用items()方法，同时获取键和值，效率最高，适用于需要同时操作键和值的场景。
student = {"name": "张三", "age": 18, "score": 95} # 方式1：直接遍历items()，拆包键和值 for key, value in student.items(): print(f"键：{key}，值：{value}") # 输出结果： # 键：name，值：张三 # 键：age，值：18 # 键：score，值：95 # 方式2：不拆包，直接获取键值对元组 for item in student.items(): print(item) # 输出：('name', '张三'), ('age', 18), ('score', 95)
3.2 嵌套字典（字典中包含字典）
当需要存储更复杂的数据（如多个用户的信息）时，可使用嵌套字典——字典的值可以是另一个字典。
# 示例：存储3个学生的信息（嵌套字典） students = { "student1": {"name": "张三", "age": 18, "score": 95}, "student2": {"name": "李四", "age": 19, "score": 92}, "student3": {"name": "王五", "age": 17, "score": 88} } # 访问嵌套字典的值（层层递进：字典名[外层键][内层键]） print(students["student1"]["name"]) # 输出：张三 print(students["student2"]["score"]) # 输出：92 # 修改嵌套字典的值 students["student3"]["age"] = 18 print(students["student3"]) # 输出：{'name': '王五', 'age': 18, 'score': 88} # 遍历嵌套字典 for student_id, info in students.items(): print(f"学生ID：{student_id}") for key, value in info.items(): print(f" {key}：{value}")
输出结果：
学生ID：student1 name：张三 age：18 score：95 学生ID：student2 name：李四 age：19 score：92 学生ID：student3 name：王五 age：18 score：88
3.3 字典的复制（2种方式）
字典是可变对象，直接用“=”赋值，会让两个变量指向同一个字典（修改一个，另一个也会变），因此需要用专门的方法复制字典。
方式1：copy()方法（浅复制）
语法：新字典 = 原字典.copy()，特点：
-
复制字典的“表层”键值对，若值是可变对象（如列表、字典），则复制的是对象的引用（修改子对象，原字典和新字典都会变）。
-
适用于字典的值是不可变对象（字符串、整数）的场景。
# 示例1：值为不可变对象（复制后互不影响） dict1 = {"a": 1, "b": 2} dict2 = dict1.copy() dict2["a"] = 100 print(dict1) # 输出：{'a': 1, 'b': 2}（原字典不变） print(dict2) # 输出：{'a': 100, 'b': 2}（新字典改变） # 示例2：值为可变对象（列表）（修改子对象，两者都变） dict3 = {"a": [1, 2, 3], "b": 4} dict4 = dict3.copy() dict4["a"].append(4) # 修改列表（可变对象） print(dict3) # 输出：{'a': [1, 2, 3, 4], 'b': 4}（原字典也变） print(dict4) # 输出：{'a': [1, 2, 3, 4], 'b': 4}
方式2：deepcopy()方法（深复制，推荐）
语法：新字典 = copy.deepcopy(原字典)，需要导入copy模块，特点：
-
完全复制字典的所有层级（包括子对象，如列表、嵌套字典），原字典和新字典完全独立，修改任何一个都不会影响另一个。
-
适用于字典包含可变子对象（列表、嵌套字典）的场景。
import copy # 必须导入copy模块 dict3 = {"a": [1, 2, 3], "b": 4} dict4 = copy.deepcopy(dict3) dict4["a"].append(4) # 修改列表（可变对象） print(dict3) # 输出：{'a': [1, 2, 3], 'b': 4}（原字典不变） print(dict4) # 输出：{'a': [1, 2, 3, 4], 'b': 4}（新字典改变）
3.4 字典的常用内置方法（汇总）
除了前面用到的方法，以下是字典常用的内置方法，整理成表格，方便查阅：
|
方法 |
语法 |
功能说明 |
示例 |
|---|---|---|---|
|
get() |
dict.get(key, default) |
获取指定键的值，键不存在返回默认值（默认None） |
dict.get("a", 0) → 0（若"a"不存在） |
|
keys() |
dict.keys() |
返回字典所有键的可迭代对象 |
list(dict.keys()) → [key1, key2] |
|
values() |
dict.values() |
返回字典所有值的可迭代对象 |
list(dict.values()) → [v1, v2] |
|
items() |
dict.items() |
返回字典所有键值对的可迭代对象（元组形式） |
for k,v in dict.items(): |
|
update() |
dict.update(new_dict) |
批量修改/添加键值对 |
dict.update({"a":10, "b":20}) |
|
pop() |
dict.pop(key, default) |
删除指定键值对，返回该键的值 |
dict.pop("a") → 10（若"a"存在） |
|
popitem() |
dict.popitem() |
删除最后一个键值对，返回该键值对元组 |
dict.popitem() → ("b", 20) |
|
clear() |
dict.clear() |
清空字典，保留字典变量 |
dict.clear() → {} |
|
copy() |
dict.copy() |
浅复制字典 |
new_dict = dict.copy() |
|
fromkeys() |
dict.fromkeys(keys, value) |
批量创建键值对，值统一为value |
dict.fromkeys([1,2], 0) → {1:0, 2:0} |
四、常见问题与避坑技巧
4.1 常见错误及解决方法
-
错误1：KeyError（键不存在）原因：访问的键在字典中不存在，或拼写错误（Python对大小写敏感）。解决方法：用get()方法访问（推荐），或先判断键是否存在（用
key in dict）。dict1 = {"a": 1, "b": 2}# 错误写法# print(dict1["c"]) # KeyError# 正确写法1：用get()print(dict1.get("c", "键不存在")) # 输出：键不存在# 正确写法2：先判断if "c" in dict1:print(dict1["c"])else:print("键不存在") -
错误2：TypeError（键是可变类型）原因：字典的键使用了列表、字典等可变类型。解决方法：将键改为字符串、整数、元组等不可变类型。
# 错误写法# dict1 = {[1,2]: 3} # TypeError: unhashable type: 'list'# 正确写法dict1 = {(1,2): 3} # 用元组作为键dict2 = {"a": 3} # 用字符串作为键 -
错误3：修改字典时，遍历报错原因：遍历字典的同时，修改字典的长度（添加/删除键值对），会破坏遍历的迭代器。解决方法：遍历字典的副本（如
dict.copy().items()），再修改原字典。dict1 = {"a": 1, "b": 2, "c": 3}# 错误写法（遍历同时删除键）# for key in dict1:# if key == "a":# del dict1[key] # RuntimeError# 正确写法（遍历副本）for key in dict1.copy():if key == "a":del dict1[key]print(dict1) # 输出：{'b': 2, 'c': 3}
4.2 实用避坑技巧
-
键的命名规范：尽量使用字符串作为键，命名简洁明了（如"name"、"age"），避免使用数字作为键（容易混淆）。
-
避免重复键：创建字典时，若出现重复键，后面的会覆盖前面的，开发中需注意检查键的唯一性。
-
判断键是否存在：除了get()方法，用
key in dict判断键是否存在，效率高、逻辑清晰。 -
复制字典选deepcopy()：若字典包含嵌套结构（如列表、字典），优先用copy.deepcopy()，避免修改子对象时影响原字典。
-
字典排序：字典本身无序（3.7+有序），若需按键/值排序，可结合sorted()函数：
dict1 = {"b": 2, "a": 1, "c": 3}# 按键排序（返回列表，需转换为字典）sorted_by_key = dict(sorted(dict1.items(), key=lambda x: x[0]))print(sorted_by_key) # 输出：{'a': 1, 'b': 2, 'c': 3}# 按值排序sorted_by_value = dict(sorted(dict1.items(), key=lambda x: x[1]))print(sorted_by_value) # 输出：{'a': 1, 'b': 2, 'c': 3}
五、实战案例（巩固练习）
通过2个实战案例，将字典的基础操作和高级用法结合起来，加深理解，可直接复制代码运行。
案例1：学生信息管理系统（基础版）
功能：添加学生信息、查询学生信息、修改学生分数、删除学生信息、显示所有学生信息。
# 初始化学生字典（key为学号，value为学生信息字典） students = {} while True: print("\n===== 学生信息管理系统 =====") print("1. 添加学生信息") print("2. 查询学生信息") print("3. 修改学生分数") print("4. 删除学生信息") print("5. 显示所有学生信息") print("6. 退出系统") choice = input("请输入操作编号（1-6）：") if choice == "1": # 添加学生信息 student_id = input("请输入学号：") if student_id in students: print("该学号已存在！") continue name = input("请输入姓名：") age = int(input("请输入年龄：")) score = int(input("请输入分数：")) students[student_id] = {"name": name, "age": age, "score": score} print("添加成功！") elif choice == "2": # 查询学生信息 student_id = input("请输入要查询的学号：") student = students.get(student_id) if student: print(f"学号：{student_id}") print(f"姓名：{student['name']}") print(f"年龄：{student['age']}") print(f"分数：{student['score']}") else: print("该学生不存在！") elif choice == "3": # 修改学生分数 student_id = input("请输入要修改的学号：") student = students.get(student_id) if student: new_score = int(input("请输入新分数：")) student["score"] = new_score print("修改成功！") else: print("该学生不存在！") elif choice == "4": # 删除学生信息 student_id = input("请输入要删除的学号：") if student_id in students: del students[student_id] print("删除成功！") else: print("该学生不存在！") elif choice == "5": # 显示所有学生信息 if not students: print("暂无学生信息！") continue print("所有学生信息：") for sid, info in students.items(): print(f"学号：{sid}，姓名：{info['name']}，年龄：{info['age']}，分数：{info['score']}") elif choice == "6": print("退出系统，再见！") break else: print("输入错误，请重新输入（1-6）！")
案例2：统计字符串中字符出现次数（进阶版）
功能：输入一个字符串，用字典统计每个字符（不区分大小写）出现的次数，最后按出现次数排序输出。
import copy # 输入字符串，转换为小写（不区分大小写） s = input("请输入一个字符串：").lower() # 初始化空字典，用于存储字符出现次数 char_count = {} # 遍历字符串，统计次数 for char in s: # 只统计字母和数字（忽略空格、标点等） if char.isalnum(): # 若字符已在字典中，次数+1；否则新增键，次数=1 char_count[char] = char_count.get(char, 0) + 1 # 按出现次数降序排序（转换为字典） sorted_char = dict(sorted(char_count.items(), key=lambda x: x[1], reverse=True)) # 输出结果 print("\n字符出现次数统计（按次数降序）：") for char, count in sorted_char.items(): print(f"字符 '{char}'：出现 {count} 次")
示例运行：
请输入一个字符串：Hello World! 123 字符出现次数统计（按次数降序）： 字符 'l'：出现 3 次 字符 'o'：出现 2 次 字符 'h'：出现 1 次 字符 'e'：出现 1 次 字符 'w'：出现 1 次 字符 'r'：出现 1 次 字符 'd'：出现 1 次 字符 '1'：出现 1 次 字符 '2'：出现 1 次 字符 '3'：出现 1 次
六、总结
字典是Python中最核心的数据类型之一，核心是“键值对”结构，重点掌握以下内容：
-
基础操作：创建、访问、修改、添加、删除（重点掌握get()、update()、pop()方法）。
-
高级用法：遍历（items()方法最常用）、嵌套字典、字典复制（deepcopy()）、排序。
-
避坑要点：键必须是不可变类型、避免KeyError、遍历同时不修改字典长度。
字典的灵活性和高效性，使其在实际开发中应用广泛（如配置文件、用户信息、数据缓存等），多练习实战案例，就能熟练掌握其用法。
小龙虾开发者社区是 CSDN 旗下专注 OpenClaw 生态的官方阵地，聚焦技能开发、插件实践与部署教程，为开发者提供可直接落地的方案、工具与交流平台，助力高效构建与落地 AI 应用
更多推荐
11
0- 0
已为社区贡献4条内容
所有评论(0)