Python 零基础入门系列（六）：字典与集合——映射与去重操作
·
🐍 Python 零基础入门系列（六）：字典与集合——映射与去重操作
📢 系列说明：
欢迎来到《Python 零基础入门系列》第六篇！前五篇我们掌握了基础语法、运算符、流程控制、字符串和列表元组。📅 更新时间：2026 年 3 月（基于 Python 3.14 最新版本）
🎯 本篇你将学到：字典的创建与操作、50+ 常用字典方法、集合的运算与去重、两者特点与区别，以及 3 个实用数据管理项目。
⏱️ 预计阅读时间：50-60 分钟 | 💻 实践时间：40-50 分钟
📌 前置知识：已完成前五篇（基础语法、运算符、流程控制、字符串、列表与元组）
📋 完整目录
┌─────────────────────────────────────────────────────────────┐
│ 本篇博客内容导航 │
├─────────────────────────────────────────────────────────────┤
│ 第一部分：字典基础 │
│ ├── 1. 什么是字典？ │
│ ├── 2. 字典的创建方式 │
│ └── 3. 字典的访问与修改 │
├─────────────────────────────────────────────────────────────┤
│ 第二部分：字典常用方法 │
│ ├── 4. 添加与更新（update/setdefault） │
│ ├── 5. 删除操作（pop/popitem/clear/del） │
│ ├── 6. 查找方法（get/keys/values/items） │
│ └── 7. 字典遍历技巧 │
├─────────────────────────────────────────────────────────────┤
│ 第三部分：字典推导式 │
│ ├── 8. 基础语法 │
│ └── 9. 条件过滤 │
├─────────────────────────────────────────────────────────────┤
│ 第四部分：集合详解 │
│ ├── 10. 什么是集合？ │
│ ├── 11. 集合的创建 │
│ ├── 12. 集合的增删操作 │
│ └── 13. 集合的数学运算（交集/并集/差集） │
├─────────────────────────────────────────────────────────────┤
│ 第五部分：字典 vs 集合 │
│ ├── 14. 数据结构对比 │
│ ├── 15. 使用场景对比 │
│ └── 16. 性能对比 │
├─────────────────────────────────────────────────────────────┤
│ 第六部分：综合实战 │
│ ├── 17. 实战一：通讯录管理系统 │
│ ├── 18. 实战二：词频统计工具 │
│ └── 19. 实战三：数据去重处理器 │
└─────────────────────────────────────────────────────────────┘
第一部分：字典基础
1. 什么是字典？
📖 定义
字典（Dictionary） 是 Python 中的无序、可变映射类型，通过键值对（Key-Value） 存储数据，是哈希表的实现。
┌─────────────────────────────────────────────────────────────┐
│ 字典的本质 │
├─────────────────────────────────────────────────────────────┤
│ │
│ {"name": "小明", "age": 18, "city": "北京"} │
│ │ │ │ │ │ │ │
│ 键 值 键 值 键 值 │
│ │
│ 核心特性： │
│ ✅ 映射（Mapping）- 键映射到值 │
│ ✅ 可变（Mutable）- 可以添加、修改、删除 │
│ ✅ 键唯一（Unique Keys）- 键不能重复 │
│ ✅ 键不可变（Immutable Keys）- 键必须是不可变类型 │
│ ✅ 3.7+ 有序 - Python 3.7+ 保持插入顺序 │
│ │
└─────────────────────────────────────────────────────────────┘
📊 字典 vs 列表
| 特性 | 列表 | 字典 |
|---|---|---|
| 访问方式 | 索引（数字） | 键（任意不可变类型） |
| 数据组织 | 有序序列 | 键值对映射 |
| 查找速度 | O(n) | O(1) |
| 适用场景 | 有序数据集合 | 关联数据映射 |
2. 字典的创建方式
📝 多种创建方法
# 1. 花括号创建（最常用）
dict1 = {"name": "小明", "age": 18, "city": "北京"}
# 2. 空字典
dict2 = {}
dict3 = dict()
# 3. dict() 转换
dict4 = dict()
dict5 = dict(name="小明", age=18) # 关键字参数
# 4. fromkeys() 创建（所有键相同值）
dict6 = dict.fromkeys(["a", "b", "c"], 0)
print(dict6) # {'a': 0, 'b': 0, 'c': 0}
# 5. 字典推导式
dict7 = {x: x**2 for x in range(5)}
print(dict7) # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
# 6. 混合类型键值
dict8 = {
"name": "小明",
100: "数字键",
(1, 2): "元组键",
"scores": [90, 85, 88]
}
print(f"dict1: {dict1}")
print(f"dict4: {dict4}")
⚠️ 键的限制
# ✅ 可用作键的类型（不可变）
valid_dict = {
"string": "字符串键",
123: "整数键",
3.14: "浮点数键",
(1, 2): "元组键",
True: "布尔键"
}
# ❌ 不能用作键的类型（可变）
# invalid_dict = {
# [1, 2]: "列表键", # TypeError!
# {"a": 1}: "字典键", # TypeError!
# {1, 2}: "集合键" # TypeError!
# }
# 验证：可哈希性
print(hash("string")) # ✅ 可哈希
print(hash(123)) # ✅ 可哈希
print(hash((1, 2))) # ✅ 可哈希
# print(hash([1, 2])) # ❌ TypeError!
3. 字典的访问与修改
🔍 访问值
person = {"name": "小明", "age": 18, "city": "北京"}
# 方法 1：方括号访问（键不存在会报错）
print(person["name"]) # 小明
# print(person["email"]) # KeyError!
# 方法 2：get() 方法（键不存在返回 None 或默认值）
print(person.get("age")) # 18
print(person.get("email")) # None
print(person.get("email", "无")) # 无
# 方法 3：in 判断键是否存在
print("name" in person) # True
print("email" in person) # False
🔧 修改值
person = {"name": "小明", "age": 18, "city": "北京"}
# 修改已有键
person["age"] = 19
print(person) # {'name': '小明', 'age': 19, 'city': '北京'}
# 添加新键
person["email"] = "xiaoming@example.com"
print(person) # {..., 'email': 'xiaoming@example.com'}
# 批量更新
person.update({"city": "上海", "phone": "13800138000"})
print(person) # {..., 'city': '上海', 'phone': '13800138000'}
第二部分：字典常用方法
4. 添加与更新
| 方法 | 说明 | 示例 | 结果 |
|---|---|---|---|
update() |
批量更新/添加 | d.update({"a":1}) |
更新字典 |
setdefault() |
键不存在则设置默认值 | d.setdefault("a", 0) |
返回值 |
🔍 示例
person = {"name": "小明", "age": 18}
# update - 批量更新
person.update({"age": 19, "city": "北京"})
print(person) # {'name': '小明', 'age': 19, 'city': '北京'}
# update - 添加多个
person.update(email="xiaoming@example.com", phone="13800138000")
print(person)
# setdefault - 键不存在则设置
person.setdefault("gender", "男")
print(person) # {..., 'gender': '男'}
# setdefault - 键已存在则不变
person.setdefault("gender", "女")
print(person) # {..., 'gender': '男'}（不变）
# 实用：计数器
counts = {}
for char in "hello":
counts.setdefault(char, 0)
counts[char] += 1
print(counts) # {'h': 1, 'e': 1, 'l': 2, 'o': 1}
5. 删除操作
| 方法 | 说明 | 返回值 | 键不存在 |
|---|---|---|---|
pop() |
删除指定键 | 值 | KeyError |
popitem() |
删除最后一项 | (键，值) | KeyError |
clear() |
清空字典 | None | - |
del |
删除语句 | - | KeyError |
🔍 示例
person = {"name": "小明", "age": 18, "city": "北京", "email": "x@example.com"}
# pop - 删除指定键
age = person.pop("age")
print(f"删除的年龄：{age}") # 18
print(person) # {'name': '小明', 'city': '北京', 'email': 'x@example.com'}
# pop - 带默认值
email = person.pop("phone", "无")
print(f"电话：{email}") # 无
# popitem - 删除最后一项（3.7+ 是插入顺序的最后）
last = person.popitem()
print(f"删除的项：{last}") # ('email', 'x@example.com')
# clear - 清空
person.clear()
print(person) # {}
# del - 删除语句
person = {"name": "小明", "age": 18}
del person["age"]
print(person) # {'name': '小明'}
# del - 删除整个字典
del person
# print(person) # NameError!
6. 查找方法
| 方法 | 说明 | 返回类型 | 示例 |
|---|---|---|---|
get() |
获取值 | 值 | d.get("key") |
keys() |
获取所有键 | 视图 | d.keys() |
values() |
获取所有值 | 视图 | d.values() |
items() |
获取所有键值对 | 视图 | d.items() |
🔍 示例
person = {"name": "小明", "age": 18, "city": "北京"}
# keys - 所有键
keys = person.keys()
print(keys) # dict_keys(['name', 'age', 'city'])
print(list(keys)) # ['name', 'age', 'city']
# values - 所有值
values = person.values()
print(values) # dict_values(['小明', 18, '北京'])
print(list(values)) # ['小明', 18, '北京']
# items - 所有键值对
items = person.items()
print(items) # dict_items()
print(list(items)) #
# 视图是动态的
person["email"] = "x@example.com"
print(keys) # dict_keys(['name', 'age', 'city', 'email']) 自动更新！
7. 字典遍历技巧
🔍 多种遍历方式
person = {"name": "小明", "age": 18, "city": "北京"}
# 1. 遍历键（默认）
for key in person:
print(key) # name, age, city
# 2. 遍历键（显式）
for key in person.keys():
print(key)
# 3. 遍历值
for value in person.values():
print(value) # 小明，18, 北京
# 4. 遍历键值对（推荐）
for key, value in person.items():
print(f"{key}: {value}")
# name: 小明
# age: 18
# city: 北京
# 5. 带索引遍历
for i, (key, value) in enumerate(person.items(), 1):
print(f"{i}. {key} = {value}")
# 6. 条件遍历
for key, value in person.items():
if isinstance(value, int):
print(f"{key} 是数字：{value}")
第三部分：字典推导式
8. 基础语法
📝 语法格式
{键表达式：值表达式 for 变量 in 序列}
🔍 示例
# 传统方式
squares = {}
for i in range(5):
squares[i] = i ** 2
print(squares) # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
# 字典推导式
squares = {i: i ** 2 for i in range(5)}
print(squares) # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
# 更多示例
# 1. 键值互换
original = {"a": 1, "b": 2, "c": 3}
swapped = {v: k for k, v in original.items()}
print(swapped) # {1: 'a', 2: 'b', 3: 'c'}
# 2. 字符串转字典
text = "hello"
char_count = {char: text.count(char) for char in text}
print(char_count) # {'h': 1, 'e': 1, 'l': 2, 'o': 1}
# 3. 列表转字典
keys = ["name", "age", "city"]
values = ["小明", 18, "北京"]
person = {k: v for k, v in zip(keys, values)}
print(person) # {'name': '小明', 'age': 18, 'city': '北京'}
# 4. 过滤 None 值
data = {"a": 1, "b": None, "c": 3, "d": None}
cleaned = {k: v for k, v in data.items() if v is not None}
print(cleaned) # {'a': 1, 'c': 3}
9. 条件过滤
🔍 示例
numbers = {1: 10, 2: 20, 3: 30, 4: 40, 5: 50}
# 筛选偶数键
even_keys = {k: v for k, v in numbers.items() if k % 2 == 0}
print(even_keys) # {2: 20, 4: 40}
# 筛选值大于 25
large_values = {k: v for k, v in numbers.items() if v > 25}
print(large_values) # {3: 30, 4: 40, 5: 50}
# 多个条件
result = {k: v for k, v in numbers.items() if k % 2 == 0 if v > 25}
print(result) # {4: 40}
# if-else 表达式
status = {k: "大" if v > 25 else "小" for k, v in numbers.items()}
print(status) # {1: '小', 2: '小', 3: '大', 4: '大', 5: '大'}
# 实用：统计字母频率
text = "hello world"
freq = {char: text.count(char) for char in text if char != " "}
print(freq) # {'h': 1, 'e': 1, 'l': 3, 'o': 2, 'w': 1, 'r': 1, 'd': 1}
第四部分：集合详解
10. 什么是集合？
📖 定义
集合（Set） 是 Python 中的无序、不重复元素集合，支持数学集合运算（交集、并集、差集等）。
┌─────────────────────────────────────────────────────────────┐
│ 集合的本质 │
├─────────────────────────────────────────────────────────────┤
│ │
│ {1, 2, 3, 4, 5} │
│ │
│ 核心特性： │
│ ✅ 无序（Unordered）- 元素无固定顺序 │
│ ✅ 不重复（Unique）- 自动去重 │
│ ✅ 可变（Mutable）- 可以添加、删除元素 │
│ ✅ 元素不可变 - 集合元素必须是可哈希类型 │
│ │
│ 冻结集合（frozenset）： │
│ ❌ 不可变 - 创建后不能修改 │
│ ✅ 可用作字典的键 │
│ │
└─────────────────────────────────────────────────────────────┘
11. 集合的创建
📝 创建方式
# 1. 花括号创建
set1 = {1, 2, 3, 4, 5}
set2 = {"苹果", "香蕉", "橙子"}
# 2. 空集合（注意：{} 是空字典！）
set3 = set() # ✅ 正确
# set4 = {} # ❌ 这是空字典！
# 3. set() 转换
set5 = set("hello") # {'h', 'e', 'l', 'o'}（去重）
set6 = set([1, 2, 2, 3, 3, 3]) # {1, 2, 3}（去重）
set7 = set((1, 2, 3)) # {1, 2, 3}
# 4. 集合推导式
set8 = {x ** 2 for x in range(5)}
print(set8) # {0, 1, 4, 9, 16}
print(f"set1: {set1}")
print(f"set5: {set5}")
print(f"set6: {set6}")
# 验证类型
print(type({})) # <class 'dict'>
print(type(set())) # <class 'set'>
12. 集合的增删操作
🔧 添加元素
| 方法 | 说明 | 示例 |
|---|---|---|
add() |
添加单个元素 | s.add(5) |
update() |
添加多个元素 | s.update([1,2,3]) |
fruits = {"苹果", "香蕉"}
# add - 添加单个
fruits.add("橙子")
print(fruits) # {'苹果', '香蕉', '橙子'}
# add - 重复添加无效果
fruits.add("苹果")
print(fruits) # {'苹果', '香蕉', '橙子'}（不变）
# update - 添加多个
fruits.update(["葡萄", "西瓜"])
print(fruits) # {'苹果', '香蕉', '橙子', '葡萄', '西瓜'}
# update - 从其他集合添加
more_fruits = {"草莓", "蓝莓"}
fruits.update(more_fruits)
print(fruits)
🗑️ 删除元素
| 方法 | 说明 | 元素不存在 |
|---|---|---|
remove() |
删除指定元素 | KeyError |
discard() |
删除指定元素 | 无错误 |
pop() |
随机删除一个 | KeyError（空集合） |
clear() |
清空集合 | - |
fruits = {"苹果", "香蕉", "橙子", "葡萄"}
# remove - 删除指定元素
fruits.remove("香蕉")
print(fruits) # {'苹果', '橙子', '葡萄'}
# fruits.remove("西瓜") # KeyError!
# discard - 删除指定元素（安全）
fruits.discard("橙子")
print(fruits) # {'苹果', '葡萄'}
fruits.discard("西瓜") # 无错误
# pop - 随机删除一个
removed = fruits.pop()
print(f"删除了：{removed}")
# clear - 清空
fruits.clear()
print(fruits) # set()
13. 集合的数学运算
📊 运算对比表
| 运算 | 符号 | 方法 | 说明 |
|---|---|---|---|
| 交集 | & |
intersection() |
共同元素 |
| 并集 | | |
union() |
所有元素 |
| 差集 | - |
difference() |
A 有 B 无 |
| 对称差集 | ^ |
symmetric_difference() |
只在一个中 |
| 子集 | <= |
issubset() |
是否包含于 |
| 超集 | >= |
issuperset() |
是否包含 |
🔍 示例
set_a = {1, 2, 3, 4, 5}
set_b = {4, 5, 6, 7, 8}
# 交集 - 共同元素
print(set_a & set_b) # {4, 5}
print(set_a.intersection(set_b)) # {4, 5}
# 并集 - 所有元素
print(set_a | set_b) # {1, 2, 3, 4, 5, 6, 7, 8}
print(set_a.union(set_b)) # {1, 2, 3, 4, 5, 6, 7, 8}
# 差集 - A 有 B 无
print(set_a - set_b) # {1, 2, 3}
print(set_a.difference(set_b)) # {1, 2, 3}
print(set_b - set_a) # {6, 7, 8}
# 对称差集 - 只在一个集合中
print(set_a ^ set_b) # {1, 2, 3, 6, 7, 8}
print(set_a.symmetric_difference(set_b)) # {1, 2, 3, 6, 7, 8}
# 子集/超集判断
set_c = {1, 2, 3}
print(set_c <= set_a) # True（c 是 a 的子集）
print(set_a >= set_c) # True（a 是 c 的超集）
print(set_c < set_a) # True（c 是 a 的真子集）
# 不相交判断
set_d = {10, 11, 12}
print(set_a.isdisjoint(set_d)) # True（无共同元素）
💡 实用技巧
# 技巧 1：列表去重
numbers = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
unique = list(set(numbers))
print(unique) # [1, 2, 3, 4]（顺序可能变化）
# 技巧 2：保持顺序去重
numbers = [1, 2, 2, 3, 3, 3, 4]
seen = set()
unique_ordered = []
for n in numbers:
if n not in seen:
seen.add(n)
unique_ordered.append(n)
print(unique_ordered) # [1, 2, 3, 4]
# 技巧 3：找共同好友
friends_a = {"小明", "小红", "小刚", "小丽"}
friends_b = {"小红", "小刚", "小强", "小华"}
common = friends_a & friends_b
print(f"共同好友：{common}") # {'小红', '小刚'}
# 技巧 4：找差异
only_a = friends_a - friends_b
only_b = friends_b - friends_a
print(f"只在 A 中：{only_a}") # {'小明', '小丽'}
print(f"只在 B 中：{only_b}") # {'小强', '小华'}
第五部分：字典 vs 集合
14. 数据结构对比
┌─────────────────────────────────────────────────────────────┐
│ 数据结构对比 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 字典（Dictionary） │
│ ═══════════ │
│ • 存储：键值对（Key-Value） │
│ • 键：唯一、不可变 │
│ • 值：任意类型、可重复 │
│ • 访问：通过键访问值 O(1) │
│ • 用途：映射、关联数据 │
│ │
│ ───────────────────────────────────────────────────────── │
│ │
│ 集合（Set） │
│ ═══════ │
│ • 存储：唯一元素 │
│ • 元素：不可变、不重复 │
│ • 访问：判断存在性 O(1) │
│ • 用途：去重、集合运算、成员检测 │
│ │
└─────────────────────────────────────────────────────────────┘
🔍 代码对比
# 字典 - 键值映射
student = {"name": "小明", "age": 18, "score": 90}
print(student["name"]) # 通过键取值
# 集合 - 唯一元素
unique_ids = {1001, 1002, 1003, 1004}
print(1001 in unique_ids) # 判断是否存在
15. 使用场景对比
┌─────────────────────────────────────────────────────────────┐
│ 使用场景对比 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 📌 使用字典的场景 │
│ ══════════════ │
│ • 存储对象的属性（如用户信息） │
│ • 建立映射关系（如 ID→名称） │
│ • 计数器/频率统计 │
│ • 缓存数据 │
│ • 配置信息存储 │
│ │
│ ───────────────────────────────────────────────────────── │
│ │
│ 📌 使用集合的场景 │
│ ══════════════ │
│ • 数据去重 │
│ • 快速成员检测 │
│ • 集合运算（交集/并集/差集） │
│ • 过滤重复项 │
│ • 找共同/差异元素 │
│ │
└─────────────────────────────────────────────────────────────┘
16. 性能对比
📊 时间复杂度对比
| 操作 | 列表 | 字典 | 集合 |
|---|---|---|---|
| 查找 | O(n) | O(1) | O(1) |
| 添加 | O(1)* | O(1) | O(1) |
| 删除 | O(n) | O(1) | O(1) |
| 成员检测 | O(n) | O(1) | O(1) |
*列表末尾添加为 O(1)，中间添加为 O(n)
🔍 性能测试
import timeit
# 成员检测性能对比
list_large = list(range(10000))
set_large = set(range(10000))
dict_large = {i: i for i in range(10000)}
# 列表查找
list_time = timeit.timeit('9999 in list_large',
globals=globals(), number=1000)
# 集合查找
set_time = timeit.timeit('9999 in set_large',
globals=globals(), number=1000)
# 字典查找
dict_time = timeit.timeit('9999 in dict_large',
globals=globals(), number=1000)
print(f"列表查找时间：{list_time:.4f}秒")
print(f"集合查找时间：{set_time:.4f}秒")
print(f"字典查找时间：{dict_time:.4f}秒")
print(f"集合比列表快约：{list_time/set_time:.0f}倍")
第六部分：综合实战
17. 实战一：通讯录管理系统
📋 项目需求
- 添加联系人（姓名、电话、邮箱）
- 查询联系人
- 修改联系人信息
- 删除联系人
- 显示所有联系人
- 搜索（按姓名/电话）
💻 完整代码
先自行练习,完整代码见下一篇博客
18. 实战二：词频统计工具
📋 项目需求
- 输入文本内容
- 统计每个单词出现次数
- 按频率排序显示
- 显示 Top N 高频词
- 支持去除停用词
💻 完整代码
先自行练习,完整代码见下一篇博客
19. 实战三：数据去重处理器
📋 项目需求
- 输入数据列表
- 使用集合去重
- 保持原始顺序去重
- 找出重复元素
- 统计重复次数
💻 完整代码
先自行练习,完整代码见下一篇博客
📝 总结与下一篇预告
本篇核心知识点回顾
┌─────────────────────────────────────────────────────────────┐
│ 知识点思维导图 │
├─────────────────────────────────────────────────────────────┤
│ │
│ Python 字典与集合 │
│ │ │
│ ├── 字典（Dictionary） │
│ │ ├── 创建（{}/dict()/fromkeys） │
│ │ ├── 访问（[]/get()） │
│ │ ├── 修改（赋值/update） │
│ │ ├── 删除（pop/popitem/clear/del） │
│ │ ├── 遍历（keys/values/items） │
│ │ └── 推导式（基础/条件） │
│ │ │
│ ├── 集合（Set） │
│ │ ├── 创建（set()） │
│ │ ├── 增删（add/update/remove/discard） │
│ │ └── 运算（交/并/差/对称差） │
│ │ │
│ ├── 字典 vs 集合 │
│ │ ├── 结构（键值对 vs 唯一元素） │
│ │ ├── 性能（O(1) 查找） │
│ │ └── 场景（映射 vs 去重） │
│ │ │
│ └── 实战应用 │
│ ├── 通讯录管理系统 │
│ ├── 词频统计工具 │
│ └── 数据去重处理器 │
│ │
└─────────────────────────────────────────────────────────────┘
✅ 学习检查清单
- 理解字典的键值对结构
- 掌握字典的增删改查方法
- 熟练使用字典推导式
- 理解集合的去重特性
- 掌握集合的数学运算
- 清楚字典与集合的区别
- 完成 3 个实战项目
🚀 下一篇预告
《Python 零基础入门系列（七）：函数基础知识（上）》
┌─────────────────────────────────────────────────────────────┐
│ 第七篇内容预告 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 1️⃣ 什么是函数 │
│ • 函数的概念与作用 │
│ • 为什么要使用函数 │
│ • DRY 原则（Don't Repeat Yourself） │
│ │
│ 2️⃣ 函数的定义和调用 │
│ • def 关键字 │
│ • 函数命名规范 │
│ • 调用函数 │
│ │
│ 3️⃣ 函数的参数 │
│ • 位置参数 │
│ • 关键字参数 │
│ • 默认参数 │
│ • 可变参数（*args/**kwargs） │
│ │
│ 4️⃣ 函数的返回值 │
│ • return 语句 │
│ • 返回多个值 │
│ • 无返回值的情况 │
│ │
│ 5️⃣ 综合实战 │
│ • 计算器函数 │
│ • 数据处理函数 │
│ • 工具函数库 │
│ │
└─────────────────────────────────────────────────────────────┘
📅 完整系列更新计划
┌─────────────────────────────────────────────────────────────┐
│ 🐍 Python 零基础入门系列 · 完整规划（12 篇版） │
├─────────────────────────────────────────────────────────────┤
│ │
│ 📌 第一篇：Python 认知 + 环境搭建 + 基础语法 │
│ ✅ 已完成 │
│ │
│ 📌 第二篇：常用运算符完全详解 │
│ ✅ 已完成 │
│ │
│ 📌 第三篇：流程控制——条件判断与循环结构 │
│ ✅ 已完成 │
│ │
│ 📌 第四篇：字符串常用操作详解 │
│ ✅ 已完成 │
│ │
│ 📌 第五篇：列表与元组——序列操作全解析 │
│ ✅ 已完成 │
│ │
│ 📌 第六篇（本篇）：字典与集合——映射与去重操作 │
│ ✅ 已完成 │
│ │
│ 📌 第七篇：函数基础知识（上） │
│ 🔜 即将发布 │
│ • 什么是函数 │
│ • 函数的定义和调用 │
│ • 函数的参数 │
│ • 函数的返回值 │
│ │
│ 📌 第八篇：函数基础知识（下） │
│ 🔜 敬请期待 │
│ • 函数的文档注释 │
│ • 函数的嵌套调用 │
│ • 局部变量和全局变量 │
│ │
│ 📌 第九篇：函数进阶知识 │
│ 🔜 敬请期待 │
│ • 匿名函数（lambda） │
│ • 递归函数 │
│ • 高阶函数 │
│ │
│ 📌 第十篇：闭包和装饰器 │
│ 🔜 敬请期待 │
│ • 闭包的概念与原理 │
│ • 装饰器的语法与用法 │
│ • 带参数的装饰器 │
│ │
│ 📌 第十一篇：模块和包 │
│ 🔜 敬请期待 │
│ • 模块的导入与使用 │
│ • 常用标准库模块 │
│ • 包的创建与结构 │
│ │
│ 📌 第十二篇及后续：更多进阶内容 │
│ 🔜 敬请期待 │
│ • 文件操作 │
│ • 异常处理 │
│ • 面向对象编程 │
│ │
└─────────────────────────────────────────────────────────────┘
📊 系列进度可视化
进度条：████████████████████░░░░ 6/12 完成
✅ ✅ ✅ ✅ ✅ ✅ 🔜 🔜 🔜 🔜 🔜 🔜
📚 推荐学习资源
| 类型 | 名称 | 链接 |
|---|---|---|
| 官网 | Python 官方网站 | https://www.python.org |
| 文档 | Python 官方文档（中文） | https://docs.python.org/zh-cn/3/ |
| 教程 | 菜鸟教程 Python | https://www.runoob.com/python3/ |
| 教程 | 廖雪峰 Python 教程 | https://www.liaoxuefeng.com/wiki/1016959663602400 |
| 练习 | LeetCode | https://leetcode.cn |
| 练习 | CheckiO（游戏化学习） | https://checkio.org |
| 社区 | Stack Overflow | https://stackoverflow.com |
| 社区 | Python 中文社区 | https://python-china.org |
💬 结语
"字典和集合是 Python 高效数据处理的核心，掌握它们，你就掌握了快速查找和去重的利器。"
恭喜你完成了 Python 入门系列的第六篇！现在你已经：
- ✅ 掌握了字典的创建、访问、增删改查
- ✅ 学会了字典推导式的高效用法
- ✅ 理解了集合的去重特性与数学运算
- ✅ 清楚字典与集合的区别与使用场景
- ✅ 完成了通讯录、词频统计、数据去重 3 个实战项目
下一步建议：
- 把实战代码亲手敲一遍，尝试添加新功能
- 用字典和集合解决日常数据管理问题
- 复习前六篇内容，形成完整知识体系
- 准备迎接第七篇——函数基础知识！
记住：选择合适的数据结构能让代码更高效、更优雅！
📅 更新时间：2026 年 3 月 18 日
✍️ 作者：书到用时方恨少! | 专注 Python 教学与 AI 技术分享
💌 如有疑问，欢迎在评论区留言讨论！
如果觉得这篇文章有帮助，请点赞👍、收藏⭐、转发🔄，让更多的小伙伴一起加入 Python 学习的行列！
📢 系列文章索引
| 篇数 | 主题 | 状态 | 链接 |
|---|---|---|---|
| 第一篇 | Python 认知 + 环境搭建 + 基础语法 | ✅ 已完成 | 点击查看 |
| 第二篇 | 常用运算符完全详解 | ✅ 已完成 | 点击查看 |
| 第三篇 | 流程控制——条件判断与循环结构 | ✅ 已完成 | 点击查看 |
| 第四篇 | 字符串常用操作详解 | ✅ 已完成 | 点击查看 |
| 第五篇 | 列表与元组——序列操作全解析 | ✅ 已完成 | 点击查看 |
| 第六篇 | 字典与集合——映射与去重操作 | ✅ 已完成 | 当前文章 |
| 第七篇 | 函数基础知识（上） | 🔜 敬请期待 | 敬请期待 |
| 第八篇 | 函数基础知识（下） | 🔜 敬请期待 | 敬请期待 |
| 第九篇 | 函数进阶知识 | 🔜 敬请期待 | 敬请期待 |
| 第十篇 | 闭包和装饰器 | 🔜 敬请期待 | 敬请期待 |
| 第十一篇 | 模块和包 | 🔜 敬请期待 | 敬请期待 |
| 第十二篇 | 更多进阶内容 | 🔜 敬请期待 | 敬请期待 |
🔔 订阅提醒：关注我，不错过每一篇更新！
更多推荐
9
0- 0
已为社区贡献6条内容
所有评论(0)