8.1 什么是字典？

字典（Dictionary）是 Python 中一种非常灵活的内置数据结构，它以键值对（Key-Value Pair）的形式存储数据。字典就像一本真实的字典：“键”（Key）相当于字典中的 “单词”，“值”（Value）相当于单词对应的 “解释”，通过 “单词” 可以快速找到对应的 “解释”。

与列表和元组不同，字典中的元素是无序的（在 Python 3.7 + 版本中，字典会保留插入顺序，但不建议依赖这一特性），它通过 “键” 来访问元素，而不是通过索引。这使得字典在根据 “键” 查找 “值” 时效率极高。

8.2 字典的创建

字典使用花括号（{}）来表示，每个键值对由 “键：值” 组成，键值对之间用逗号（,）分隔。创建字典的基本语法如下：

字典名 = {键1: 值1, 键2: 值2, 键3: 值3, ...}

示例：

# 存储学生信息的字典（键为信息类别，值为具体信息）

student = {

"name": "张三",

"age": 18,

"gender": "男",

"score": 90

}

# 存储商品信息的字典

product = {

"id": 1001,

"name": "笔记本电脑",

"price": 5999.99,

"stock": 50

}

# 空字典

empty_dict = {}

# 使用dict()函数创建字典

person = dict(name="李四", age=20, city="北京")

print(person) # 输出：{'name': '李四', 'age': 20, 'city': '北京'}

字典的键的要求

字典的键必须满足以下条件：

1. 键必须是不可变的数据类型，如整数、字符串、元组等（列表等可变类型不能作为键）。

1. 键必须是唯一的，如果字典中存在重复的键，后面的键值对会覆盖前面的。

示例：

# 错误：列表是可变类型，不能作为键

# invalid_dict = {[1, 2]: "value"} # 会报错：TypeError: unhashable type: 'list'

# 重复的键：后面的会覆盖前面的

duplicate_key = {"name": "张三", "name": "李四"}

print(duplicate_key) # 输出：{'name': '李四'}

8.3 访问字典元素

访问字典中的元素主要有两种方式：通过 “键” 访问和使用get()方法。

8.3.1 通过 “键” 访问

通过 “键” 访问字典元素的语法如下：

字典名[键]

示例：

student = {

"name": "张三",

"age": 18,

"score": 90

}

# 访问姓名

print(student["name"]) # 输出：张三

# 访问年龄

print(student["age"]) # 输出：18

如果访问的键不存在，会导致 “键不存在” 错误（KeyError）：

print(student["gender"])  # 会报错：KeyError: 'gender'

8.3.2 使用get()方法

get()方法的语法如下：

字典名.get(键, 默认值)

• 如果键存在，返回对应的值；

• 如果键不存在，返回指定的默认值（如果未指定默认值，返回None）。

示例：

student = {

"name": "张三",

"age": 18,

"score": 90

}

# 访问存在的键

print(student.get("name")) # 输出：张三

# 访问不存在的键，指定默认值

print(student.get("gender", "未知")) # 输出：未知

# 访问不存在的键，不指定默认值

print(student.get("address")) # 输出：None

使用get()方法可以避免因键不存在而导致的错误，在实际编程中更常用。

8.4 修改字典元素

字典是可变的，我们可以通过 “键” 来修改已有键对应的值。语法如下：

字典名[键] = 新值

示例：

student = {

"name": "张三",

"age": 18,

"score": 90

}

# 修改成绩

student["score"] = 95

print(student["score"]) # 输出：95

# 修改年龄

student["age"] = 19

print(student) # 输出：{'name': '张三', 'age': 19, 'score': 95}

8.5 字典的常用操作

8.5.1 添加元素

向字典中添加新的键值对的语法与修改元素类似：如果键不存在，赋值操作会变成添加元素。

student = {

"name": "张三",

"age": 18

}

# 添加性别

student["gender"] = "男"

print(student) # 输出：{'name': '张三', 'age': 18, 'gender': '男'}

# 添加地址

student["address"] = "北京市"

print(student) # 输出：{'name': '张三', 'age': 18, 'gender': '男', 'address': '北京市'}

8.5.2 删除元素

1. del：根据键删除字典中的键值对。

student = {

"name": "张三",

"age": 18,

"gender": "男"

}

# 删除"gender"键值对

del student["gender"]

print(student) # 输出：{'name': '张三', 'age': 18}

# 删除整个字典（删除后字典不再存在）

# del student

1. pop()：根据键删除键值对，并返回对应的值（如果键不存在，会报错，或返回指定的默认值）。

student = {

"name": "张三",

"age": 18,

"score": 90

}

# 删除"score"键值对，并返回值

score = student.pop("score")

print(score) # 输出：90

print(student) # 输出：{'name': '张三', 'age': 18}

# 删除不存在的键，指定默认值

gender = student.pop("gender", "未知")

print(gender) # 输出：未知

1. clear()：清空字典中的所有键值对，字典变为空字典。

student = {

"name": "张三",

"age": 18

}

student.clear()

print(student) # 输出：{}

8.5.3 其他常用操作

1. len()：获取字典中键值对的数量。

student = {"name": "张三", "age": 18, "score": 90}

print(len(student)) # 输出：3

1. keys()：返回字典中所有键组成的视图对象。

student = {"name": "张三", "age": 18, "score": 90}

keys = student.keys()

print(keys) # 输出：dict_keys(['name', 'age', 'score'])

# 转换为列表

print(list(keys)) # 输出：['name', 'age', 'score']

1. values()：返回字典中所有值组成的视图对象。

student = {"name": "张三", "age": 18, "score": 90}

values = student.values()

print(values) # 输出：dict_values(['张三', 18, 90])

# 转换为列表

print(list(values)) # 输出：['张三', 18, 90]

1. items()：返回字典中所有键值对组成的视图对象（每个键值对以元组(键, 值)的形式表示）。

student = {"name": "张三", "age": 18, "score": 90}

items = student.items()

print(items) # 输出：dict_items([('name', '张三'), ('age', 18), ('score', 90)])

# 转换为列表

print(list(items)) # 输出：[('name', '张三'), ('age', 18), ('score', 90)]

1. update()：使用另一个字典或可迭代的键值对更新当前字典（如果键存在，会覆盖原有的值；如果键不存在，会添加新的键值对）。

student = {"name": "张三", "age": 18}

other_info = {"score": 90, "age": 19}

student.update(other_info)

print(student) # 输出：{'name': '张三', 'age': 19, 'score': 90}

8.6 字典的遍历

遍历字典主要有以下几种方式：遍历键、遍历值、遍历键值对。

8.6.1 遍历键

student = {"name": "张三", "age": 18, "score": 90}

# 方法1：直接遍历字典（默认遍历键）

for key in student:

print(key)

# 方法2：使用keys()方法

for key in student.keys():

print(key)

运行结果（两种方法相同）：

name

age

score

8.6.2 遍历值

student = {"name": "张三", "age": 18, "score": 90}

for value in student.values():

print(value)

运行结果：

张三

18

90

8.6.3 遍历键值对

student = {"name": "张三", "age": 18, "score": 90}

for key, value in student.items():

print(f"{key}: {value}")

运行结果：

name: 张三

age: 18

score: 90

8.7 字典推导式

字典推导式是一种简洁的创建字典的方式，语法如下：

{键表达式: 值表达式 for 变量 in 可迭代对象 if 条件表达式}

字典推导式的执行过程是：遍历可迭代对象中的每个元素，当条件表达式为True时，将键表达式和值表达式的结果作为键值对添加到新字典中。

示例：

# 创建一个键为1-5的整数，值为对应整数平方的字典

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

print(squares) # 输出：{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# 从列表中创建字典，筛选出值为偶数的键值对

numbers = [1, 2, 3, 4, 5, 6]

even_squares = {x: x** 2 for x in numbers if x % 2 == 0}

print(even_squares) # 输出：{2: 4, 4: 16, 6: 36}

# 交换字典的键和值

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

swapped = {v: k for k, v in original.items()}

print(swapped) # 输出：{1: 'a', 2: 'b', 3: 'c'}

8.8 嵌套字典

字典可以嵌套，即字典中的值可以是另一个字典。嵌套字典常用于表示更复杂的数据结构。

示例：存储多个学生的信息

students = {

"student1": {

"name": "张三",

"age": 18,

"score": 90

},

"student2": {

"name": "李四",

"age": 19,

"score": 85

},

"student3": {

"name": "王五",

"age": 17,

"score": 95

}

}

# 访问嵌套字典中的元素

print(students["student1"]["name"]) # 输出：张三

print(students["student3"]["score"]) # 输出：95

# 遍历嵌套字典

for student_id, info in students.items():

print(f"学号：{student_id}")

for key, value in info.items():

print(f" {key}: {value}")

运行结果：

学号：student1

name: 张三

age: 18

score: 90

学号：student2

name: 李四

age: 19

score: 85

学号：student3

name: 王五

age: 17

score: 95

8.9 示例：字典的综合应用

统计一段文本中每个单词出现的次数。

text = "I love Python Python is a great language I love coding with Python"

# 将文本转换为小写并按空格分割成单词列表

words = text.lower().split()

# 创建一个字典用于统计单词出现次数

word_count = {}

# 遍历单词列表，统计次数

for word in words:

# 如果单词已在字典中，次数加1；否则，添加到字典，次数设为1

if word in word_count:

word_count[word] += 1

else:

word_count[word] = 1

# 打印统计结果

print("单词出现次数统计：")

for word, count in word_count.items():

print(f"{word}: {count}次")

运行结果：

单词出现次数统计：

i: 2次

love: 2次

python: 3次

is: 1次

a: 1次

great: 1次

language: 1次

coding: 1次

with: 1次

8.10 小结

本章我们学习了 Python 中的字典，包括字典的创建、元素访问（通过键或get()方法）、修改元素、添加和删除元素等操作，还学习了字典的遍历方式、字典推导式和嵌套字典。

字典以键值对的形式存储数据，通过键可以快速访问对应的值，这使得它在处理具有关联关系的数据时非常高效。与列表、元组相比，字典的最大优势是查找速度快，适合存储需要频繁根据 “键” 查询 “值” 的数据。

下一章，我们将学习 Python 中的集合，它是一种用于存储唯一元素的数据结构。