Python(二十一) 中的字典
一、什么是字典
字典，英文叫 dictionary，简称 dict。
在 Python 中，字典是一种用来保存“键值对”的数据结构。
通俗地说：
字典就像现实生活中的通讯录。
通过一个名字，可以找到对应的电话号码。
例如：
姓名：小明
年龄：18
城市：北京
写成 Python 字典：
student = {
"name": "小明",
"age": 18,
"city": "北京"
}
这里：
"name" 是键，"小明" 是值
"age" 是键，18 是值
"city" 是键，"北京" 是值
字典适合保存一组有对应关系的数据。
例如：
学生信息
商品信息
用户资料
配置项
统计结果
二、什么是键值对
字典中的每一项都由两部分组成：
键 key
值 value
格式：
键: 值
示例：
student = {
"name": "小明",
"age": 18
}
其中：
"name": "小明" 是一个键值对
"age": 18 是一个键值对
可以这样理解：
键负责查找。
值负责保存真正的数据。
就像查字典：
通过“词语”找到“解释”。
通过“键”找到“值”。
三、创建字典
1. 创建普通字典
student = {
"name": "小明",
"age": 18,
"score": 95
}
print(student)
输出结果：
{'name': '小明', 'age': 18, 'score': 95}
2. 创建空字典
空字典表示暂时没有任何键值对。
student = {}
print(student)
输出结果：
{}
空字典常用于后面逐步添加数据。
3. 使用 dict() 创建字典
student = dict(name="小明", age=18)
print(student)
输出结果：
{'name': '小明', 'age': 18}
注意：
使用 dict(name="小明") 这种写法时，键名不需要加引号。
但这种键名必须符合变量命名规则。
4. 由列表创建字典
pairs = [("name", "小明"), ("age", 18)]
student = dict(pairs)
print(student)
输出结果：
{'name': '小明', 'age': 18}
这种写法初学阶段了解即可。
四、字典的基本特点
Python 字典有几个重要特点：
1. 字典使用大括号 {}
2. 字典中的数据是键值对
3. 键不能重复
4. 键通常使用字符串，也可以使用数字、元组等不可变类型
5. 值可以是任意类型
6. 字典可以修改
示例：
student = {
"name": "小明",
"age": 18,
"scores": [90, 85, 100]
}
这里：
"name" 的值是字符串
"age" 的值是整数
"scores" 的值是列表
五、键不能重复
字典中的键必须是唯一的。
如果写了重复的键，后面的值会覆盖前面的值。
示例：
student = {
"name": "小明",
"name": "小红"
}
print(student)
输出结果：
{'name': '小红'}
原因：
两个键都叫 "name"。
后面的 "小红" 覆盖了前面的 "小明"。
教学提醒：
字典中的键就像每个抽屉的标签。
同一个字典里，不应该有两个完全相同的标签。
六、键必须是不可变类型
字典的键必须是不可变类型。
常见可以作为键的类型：
字符串 str
整数 int
浮点数 float
布尔值 bool
元组 tuple
最常用的是字符串。
示例：
student = {
"name": "小明",
"age": 18
}
列表不能作为字典的键。
错误示例：
data = {
["name"]: "小明"
}
这会报错。
原因：
列表是可变对象，不能作为字典的键。
初学阶段可以先记住：
字典的键最常用字符串。
不要用列表当键。
七、通过键获取值
字典不是通过位置索引获取数据，而是通过键获取数据。
格式：
字典[键]
示例：
student = {
"name": "小明",
"age": 18,
"city": "北京"
}
print(student["name"])
print(student["age"])
输出结果：
小明
18
解释：
student["name"] 表示获取键 "name" 对应的值。
student["age"] 表示获取键 "age" 对应的值。
注意：
列表靠索引找元素。
字典靠键找值。
八、访问不存在的键会报错
如果使用 字典[键] 访问不存在的键，会报错。
示例：
student = {
"name": "小明",
"age": 18
}
print(student["city"])
会报错：
KeyError: 'city'
原因：
字典中没有 "city" 这个键。
为了避免报错，可以先判断键是否存在：
student = {
"name": "小明",
"age": 18
}
if "city" in student:
print(student["city"])
else:
print("没有 city 这个键")
更常用的方法是使用 get()。
九、get() 的用法
get() 用于安全地获取字典中的值。
格式：
字典.get(键)
示例：
student = {
"name": "小明",
"age": 18
}
print(student.get("name"))
print(student.get("city"))
输出结果：
小明
None
解释：
如果键存在，get() 返回对应的值。
如果键不存在，get() 默认返回 None，不会报错。
也可以设置默认值：
student = {
"name": "小明",
"age": 18
}
city = student.get("city", "未知城市")
print(city)
输出结果：
未知城市
这里：
如果 "city" 存在，就返回 city 对应的值。
如果 "city" 不存在，就返回 "未知城市"。
教学重点：
字典[键]：键不存在会报错。
字典.get(键)：键不存在不会报错，可以给默认值。
十、判断键是否存在
可以使用 in 判断字典中是否有某个键。
示例：
student = {
"name": "小明",
"age": 18
}
if "name" in student:
print("有 name 这个键")
注意：
in 判断的是键，不是值。
示例：
student = {
"name": "小明",
"age": 18
}
print("name" in student)
print("小明" in student)
输出结果：
True
False
因为 "小明" 是值，不是键。
如果要判断某个值是否存在，可以使用：
print("小明" in student.values())
十一、添加键值对
如果给一个不存在的键赋值，就是添加新的键值对。
格式：
字典[新键] = 新值
示例：
student = {
"name": "小明",
"age": 18
}
student["city"] = "北京"
print(student)
输出结果：
{'name': '小明', 'age': 18, 'city': '北京'}
解释：
原来没有 "city" 这个键。
student["city"] = "北京" 就添加了一个新的键值对。
十二、修改字典中的值
如果给一个已经存在的键赋值，就是修改这个键对应的值。
示例：
student = {
"name": "小明",
"age": 18
}
student["age"] = 19
print(student)
输出结果：
{'name': '小明', 'age': 19}
解释：
"age" 原来的值是 18。
重新赋值后变成了 19。
可以这样记：
键不存在：添加。
键已存在：修改。
十三、update() 批量添加或修改
update() 可以一次添加或修改多个键值对。
示例：
student = {
"name": "小明",
"age": 18
}
student.update({
"age": 19,
"city": "北京"
})
print(student)
输出结果：
{'name': '小明', 'age': 19, 'city': '北京'}
解释：
"age" 已经存在，所以被修改为 19。
"city" 不存在，所以被添加进去。
也可以这样写：
student.update(score=95, grade="三年级")
初学阶段掌握第一种字典写法即可。
十四、setdefault() 设置默认值
setdefault() 的作用是：
如果键存在，就返回原来的值。
如果键不存在，就添加这个键，并设置默认值。
示例：
student = {
"name": "小明"
}
age = student.setdefault("age", 18)
print(age)
print(student)
输出结果：
18
{'name': '小明', 'age': 18}
如果键已经存在：
student = {
"name": "小明",
"age": 20
}
age = student.setdefault("age", 18)
print(age)
print(student)
输出结果：
20
{'name': '小明', 'age': 20}
教学提醒：
setdefault() 初学阶段了解即可。
它常用于统计和分组场景。
十五、删除键值对
删除字典内容常见方式有：
pop() 按键删除，并返回被删除的值
del 删除指定键
popitem() 删除最后一个键值对
clear() 清空字典
十六、pop() 按键删除
pop() 会根据键删除对应键值对，并返回被删除的值。
示例：
student = {
"name": "小明",
"age": 18,
"city": "北京"
}
age = student.pop("age")
print(age)
print(student)
输出结果：
18
{'name': '小明', 'city': '北京'}
如果删除不存在的键，会报错：
student.pop("score")
可以设置默认值，避免报错：
score = student.pop("score", 0)
print(score)
如果 "score" 不存在，就返回默认值 0。
十七、del 删除指定键
del 也可以删除字典中的键值对。
示例：
student = {
"name": "小明",
"age": 18
}
del student["age"]
print(student)
输出结果：
{'name': '小明'}
注意：
如果删除不存在的键，del 会报错。
安全写法：
student = {
"name": "小明",
"age": 18
}
if "age" in student:
del student["age"]
十八、popitem() 删除最后一个键值对
popitem() 会删除并返回最后一个键值对。
示例：
student = {
"name": "小明",
"age": 18,
"city": "北京"
}
item = student.popitem()
print(item)
print(student)
输出结果类似：
('city', '北京')
{'name': '小明', 'age': 18}
注意：
Python 3.7 之后，字典会保持插入顺序。
popitem() 删除最后插入的键值对。
初学阶段只需要知道：
popitem() 会删除一个键值对，并返回它。
十九、clear() 清空字典
clear() 用于清空字典中的所有键值对。
示例：
student = {
"name": "小明",
"age": 18
}
student.clear()
print(student)
输出结果：
{}
注意：
clear() 是清空字典内容，字典变量本身还存在。
二十、字典长度 len()
len() 可以获取字典中键值对的数量。
示例：
student = {
"name": "小明",
"age": 18,
"city": "北京"
}
print(len(student))
输出结果：
3
这里表示字典中有 3 个键值对。
判断字典是否为空：
student = {}
if student:
print("字典不是空的")
else:
print("字典是空的")
空字典 {} 在条件判断中会被当作 False。
二十一、遍历字典
遍历字典就是把字典中的内容一个一个取出来。
常见遍历方式有：
遍历键
遍历值
遍历键值对
二十二、遍历字典的键
直接遍历字典，默认遍历的是键。
示例：
student = {
"name": "小明",
"age": 18,
"city": "北京"
}
for key in student:
print(key)
输出结果：
name
age
city
也可以使用 keys()：
for key in student.keys():
print(key)
这两种效果类似。
教学时可以这样讲：
for key in 字典，默认拿到的是键。
二十三、遍历字典的值
使用 values() 可以遍历所有值。
示例：
student = {
"name": "小明",
"age": 18,
"city": "北京"
}
for value in student.values():
print(value)
输出结果：
小明
18
北京
注意：
values() 只能拿到值，拿不到对应的键。
二十四、遍历字典的键值对 items()
使用 items() 可以同时遍历键和值。
示例：
student = {
"name": "小明",
"age": 18,
"city": "北京"
}
for key, value in student.items():
print(key, "=", value)
输出结果：
name = 小明
age = 18
city = 北京
这是字典遍历中最常用的方式之一。
可以这样理解：
items() 每次取出一组键值对。
key 接收键。
value 接收值。
二十五、keys()、values()、items() 的区别
keys() 获取所有键
values() 获取所有值
items() 获取所有键值对
示例：
student = {
"name": "小明",
"age": 18
}
print(student.keys())
print(student.values())
print(student.items())
输出结果类似：
dict_keys(['name', 'age'])
dict_values(['小明', 18])
dict_items([('name', '小明'), ('age', 18)])
如果想转换成列表：
keys = list(student.keys())
values = list(student.values())
items = list(student.items())
初学阶段重点掌握：
for key, value in student.items():
print(key, value)
二十六、字典是可变对象
字典是可变对象，可以添加、修改和删除内容。
示例：
student = {"name": "小明"}
student["age"] = 18
student["name"] = "小红"
print(student)
输出结果：
{'name': '小红', 'age': 18}
这和字符串不同。
字符串不能直接修改某个字符。
字典可以直接修改某个键对应的值。
二十七、字典复制
字典复制也容易出错。
先看一个例子：
a = {"name": "小明"}
b = a
b["age"] = 18
print(a)
print(b)
输出结果：
{'name': '小明', 'age': 18}
{'name': '小明', 'age': 18}
原因：
b = a 不是复制一个新字典。
它只是让 b 和 a 指向同一个字典。
如果想复制一个新字典，可以使用 copy()：
a = {"name": "小明"}
b = a.copy()
b["age"] = 18
print(a)
print(b)
输出结果：
{'name': '小明'}
{'name': '小明', 'age': 18}
注意：
copy() 是浅拷贝。
如果字典里面还有列表或字典，情况会更复杂。
初学阶段先记住：
b = a 不是复制新字典。
b = a.copy() 才是复制一个普通的新字典。
二十八、嵌套字典
字典的值也可以是另一个字典。
这叫嵌套字典。
示例：
students = {
"1001": {
"name": "小明",
"age": 18
},
"1002": {
"name": "小红",
"age": 17
}
}
可以把它理解成：
外层字典：学号 -> 学生信息
内层字典：姓名、年龄等具体信息
获取小明的姓名：
print(students["1001"]["name"])
输出结果：
小明
修改小红年龄：
students["1002"]["age"] = 18
添加一个学生：
students["1003"] = {
"name": "小刚",
"age": 19
}
嵌套字典适合保存结构化数据。
例如：
多个学生的信息
多个商品的信息
多个用户的信息
二十九、遍历嵌套字典
示例：
students = {
"1001": {"name": "小明", "age": 18},
"1002": {"name": "小红", "age": 17},
"1003": {"name": "小刚", "age": 19}
}
for student_id, info in students.items():
print("学号：", student_id)
print("姓名：", info["name"])
print("年龄：", info["age"])
输出结果：
学号： 1001
姓名： 小明
年龄： 18
学号： 1002
姓名： 小红
年龄： 17
学号： 1003
姓名： 小刚
年龄： 19
解释：
student_id 接收外层字典的键。
info 接收外层字典的值，也就是内层字典。
info["name"] 获取内层字典中的姓名。
三十、列表中放字典
实际开发中，也经常用列表保存多个字典。
示例：
students = [
{"name": "小明", "age": 18, "score": 90},
{"name": "小红", "age": 17, "score": 95},
{"name": "小刚", "age": 19, "score": 85}
]
这种结构可以理解为：
列表保存多个学生。
每个学生用一个字典表示。
遍历：
for student in students:
print(student["name"], student["score"])
输出结果：
小明 90
小红 95
小刚 85
按成绩排序：
students.sort(key=lambda student: student["score"], reverse=True)
print(students)
这种结构非常常见，适合作为课堂综合案例。
三十一、字典推导式
字典推导式可以用简洁方式生成字典。
普通写法：
squares = {}
for i in range(1, 6):
squares[i] = i * i
print(squares)
输出结果：
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
字典推导式写法：
squares = {i: i * i for i in range(1, 6)}
print(squares)
输出结果一样：
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
筛选字典：
scores = {
"小明": 90,
"小红": 55,
"小刚": 80
}
passed = {name: score for name, score in scores.items() if score >= 60}
print(passed)
输出结果：
{'小明': 90, '小刚': 80}
教学建议：
初学阶段先掌握普通 for 循环写法，再学习字典推导式。
三十二、fromkeys() 创建字典
fromkeys() 可以用一组键创建字典，并给它们设置相同的默认值。
示例：
keys = ["name", "age", "city"]
student = dict.fromkeys(keys, None)
print(student)
输出结果：
{'name': None, 'age': None, 'city': None}
如果不指定默认值，默认就是 None。
student = dict.fromkeys(keys)
注意：
fromkeys() 初学阶段了解即可。
三十三、字典合并
1. 使用 update()
a = {"name": "小明"}
b = {"age": 18}
a.update(b)
print(a)
输出结果：
{'name': '小明', 'age': 18}
注意：
update() 会修改原字典 a。
2. 使用 | 合并
Python 3.9 之后，字典可以使用 | 合并。
a = {"name": "小明"}
b = {"age": 18}
c = a | b
print(c)
输出结果：
{'name': '小明', 'age': 18}
如果有相同的键，右边的值会覆盖左边。
a = {"name": "小明", "age": 18}
b = {"age": 20}
c = a | b
print(c)
输出结果：
{'name': '小明', 'age': 20}
教学提醒：
如果学生使用的 Python 版本低于 3.9，就不能使用 | 合并字典。
三十四、字典和列表的区别
列表和字典都可以保存多个数据，但使用方式不同。
列表 list：
通过位置索引访问数据。
适合保存一组有顺序的数据。
字典 dict：
通过键访问数据。
适合保存有明确名称的数据。
列表示例：
student = ["小明", 18, "北京"]
print(student[0])
问题：
student[0] 是姓名，但只看代码不够直观。
字典示例：
student = {
"name": "小明",
"age": 18,
"city": "北京"
}
print(student["name"])
优点：
student["name"] 一看就知道是在取姓名。
教学时可以这样讲：
列表适合按顺序放数据。
字典适合按名称管理数据。
三十五、常见注意事项
1. 字典使用大括号 {}
正确写法：
student = {"name": "小明", "age": 18}
不要和列表的方括号混淆：
students = ["小明", "小红"]
2. 键和值之间使用冒号
错误写法：
student = {"name" = "小明"}
正确写法：
student = {"name": "小明"}
3. 多个键值对之间使用逗号
错误写法：
student = {
"name": "小明"
"age": 18
}
正确写法：
student = {
"name": "小明",
"age": 18
}
4. 访问不存在的键会报 KeyError
student = {"name": "小明"}
print(student["age"])
会报错。
更安全：
print(student.get("age", "未知"))
5. get() 不会修改字典
student = {"name": "小明"}
age = student.get("age", 18)
print(student)
输出：
{'name': '小明'}
解释：
get("age", 18) 只是取值时给默认值。
它不会自动把 "age": 18 添加到字典中。
如果想不存在时添加键，可以使用：
student.setdefault("age", 18)
6. in 判断的是键，不是值
student = {"name": "小明"}
print("name" in student)
print("小明" in student)
输出：
True
False
7. 键不能重复
student = {
"name": "小明",
"name": "小红"
}
最终只会保留后面的值。
8. 键不要使用可变类型
错误写法：
data = {
["name"]: "小明"
}
列表不能作为键。
9. b = a 不是复制新字典
a = {"name": "小明"}
b = a
b["age"] = 18
print(a)
输出：
{'name': '小明', 'age': 18}
如果想复制：
b = a.copy()
10. 遍历时不要随意修改字典大小
不推荐：
scores = {"小明": 90, "小红": 55, "小刚": 80}
for name, score in scores.items():
if score < 60:
del scores[name]
这样可能会报错。
更推荐：
scores = {"小明": 90, "小红": 55, "小刚": 80}
passed = {}
for name, score in scores.items():
if score >= 60:
passed[name] = score
print(passed)
或者：
passed = {name: score for name, score in scores.items() if score >= 60}
三十六、课堂示例
示例 1：保存一个学生信息
student = {
"name": "小明",
"age": 18,
"score": 95
}
print(student["name"])
print(student["age"])
print(student["score"])
讲解重点：
字典通过键获取值。
student["name"] 表示获取姓名。
示例 2：安全获取城市信息
student = {
"name": "小明",
"age": 18
}
city = student.get("city", "未知城市")
print(city)
讲解重点：
get() 可以避免键不存在时报错。
示例 3：添加和修改学生信息
student = {
"name": "小明",
"age": 18
}
student["city"] = "北京"
student["age"] = 19
print(student)
讲解重点：
键不存在就是添加。
键已存在就是修改。
示例 4：删除学生信息
student = {
"name": "小明",
"age": 18,
"city": "北京"
}
age = student.pop("age")
print("删除的年龄是：", age)
print(student)
讲解重点：
pop() 根据键删除，并返回被删除的值。
示例 5：遍历学生信息
student = {
"name": "小明",
"age": 18,
"city": "北京"
}
for key, value in student.items():
print(key, ":", value)
讲解重点：
items() 可以同时拿到键和值。
示例 6：统计字符出现次数
text = "banana"
count = {}
for ch in text:
count[ch] = count.get(ch, 0) + 1
print(count)
输出结果：
{'b': 1, 'a': 3, 'n': 2}
讲解重点：
get(ch, 0) 表示如果 ch 不存在，就先当作 0。
然后加 1。
这是 get() 的经典用法。
示例 7：保存多个学生信息
students = [
{"name": "小明", "score": 90},
{"name": "小红", "score": 95},
{"name": "小刚", "score": 85}
]
for student in students:
print(student["name"], student["score"])
讲解重点：
列表中可以保存多个字典。
每个字典表示一个学生。
示例 8：按成绩筛选学生
students = [
{"name": "小明", "score": 90},
{"name": "小红", "score": 55},
{"name": "小刚", "score": 85}
]
passed_students = []
for student in students:
if student["score"] >= 60:
passed_students.append(student)
print(passed_students)
讲解重点：
字典可以表示单个对象。
列表可以保存多个对象。
三十七、课堂练习
练习 1：创建学生字典
要求：创建一个字典，保存姓名、年龄、城市。
参考代码：
student = {
"name": "小明",
"age": 18,
"city": "北京"
}
print(student)
练习 2：获取字典中的值
要求：输出学生的姓名和年龄。
参考代码：
student = {
"name": "小明",
"age": 18
}
print(student["name"])
print(student["age"])
练习 3：使用 get() 获取值
要求：使用 get() 获取城市，如果没有城市就输出“未知”。
参考代码：
student = {
"name": "小明",
"age": 18
}
city = student.get("city", "未知")
print(city)
练习 4：添加键值对
要求：给学生字典添加成绩。
参考代码：
student = {
"name": "小明",
"age": 18
}
student["score"] = 95
print(student)
练习 5：修改键对应的值
要求：把年龄从 18 修改为 19。
参考代码：
student = {
"name": "小明",
"age": 18
}
student["age"] = 19
print(student)
练习 6：删除一个键值对
要求：删除学生字典中的城市。
参考代码：
student = {
"name": "小明",
"age": 18,
"city": "北京"
}
student.pop("city")
print(student)
练习 7：遍历字典
要求：遍历输出学生字典中的所有键和值。
参考代码：
student = {
"name": "小明",
"age": 18,
"city": "北京"
}
for key, value in student.items():
print(key, value)
练习 8：统计单词出现次数
要求：统计列表中每个单词出现的次数。
参考代码：
words = ["apple", "banana", "apple", "orange", "banana", "apple"]
count = {}
for word in words:
count[word] = count.get(word, 0) + 1
print(count)
练习 9：保存多个商品信息
要求：用列表和字典保存多个商品名称和价格。
参考代码：
products = [
{"name": "苹果", "price": 5},
{"name": "香蕉", "price": 3},
{"name": "橙子", "price": 4}
]
for product in products:
print(product["name"], product["price"])
练习 10：筛选高分学生
要求：筛选成绩大于等于 90 的学生。
参考代码：
students = [
{"name": "小明", "score": 90},
{"name": "小红", "score": 85},
{"name": "小刚", "score": 95}
]
good_students = []
for student in students:
if student["score"] >= 90:
good_students.append(student)
print(good_students)
三十八、教学建议
讲解字典时，可以按照下面顺序：
1. 先用通讯录或学生信息引出键值对
2. 讲字典的创建
3. 讲键和值的概念
4. 讲通过键获取值
5. 讲 get()，重点强调安全获取
6. 讲添加和修改
7. 讲删除
8. 讲 keys、values、items 遍历
9. 讲嵌套字典和列表中放字典
10. 最后通过统计字符次数、学生信息管理等例子练习
可以用下面的问题引导学生：
如果要保存一个学生的姓名、年龄、成绩，用列表清楚还是字典清楚？
字典为什么叫键值对？
student["age"] 和 student.get("age") 有什么区别？
for key in student 遍历出来的是键还是值？
如果字典中没有某个键，怎样避免程序报错？
教学重点建议放在：
键值对
通过键获取值
get()
添加和修改
删除
items() 遍历
字典和列表的区别
嵌套结构
字典推导式、setdefault、fromkeys、字典合并可以作为拓展内容。
三十九、总结
字典是 Python 中用来保存键值对的数据结构。
可以这样记：
字典：用 {} 表示
键：用来查找数据
值：真正保存的数据
键值对：键和值组成的一项数据
常用操作：
student = {"name": "小明", "age": 18}
print(student["name"])
print(student.get("city", "未知"))
student["score"] = 95
student["age"] = 19
student.pop("score")
for key, value in student.items():
print(key, value)
常用方法：
get() 安全获取值
keys() 获取所有键
values() 获取所有值
items() 获取所有键值对
update() 批量添加或修改
pop() 删除指定键并返回值
clear() 清空字典
copy() 复制字典
最重要的注意事项：
1. 字典中的数据是键值对
2. 键不能重复
3. 键通常使用字符串
4. 通过 字典[键] 获取值，键不存在会报错
5. get() 获取不存在的键不会报错
6. in 判断的是键，不是值
7. 键不存在时赋值是添加，键存在时赋值是修改
8. 遍历键值对常用 items()
9. b = a 不是复制新字典
10. 遍历时不要随意修改字典大小
一句话总结：
字典让我们可以用“名字”管理数据，比单纯靠位置索引更清楚，非常适合保存对象信息和统计结果。
