第9课：Python｜元组Tuple与字典Dict底层原理及实战用法

文章目录

• 📖 开篇导读
• 🎯 学习目标
• 📚 知识点理论精讲
• • 一、元组（Tuple）：不可变的序列
  • • 1.1 元组的定义
    • 1.2 元组的不可变性
    • 1.3 元组的常用操作
    • 1.4 元组的打包与拆包
    • 1.5 命名元组（namedtuple）
  • 二、字典（Dict）：键值对的魔法
  • • 2.1 字典的定义
    • 2.2 字典的底层原理：哈希表
    • 2.3 字典的基本操作
    • • 添加与修改
      • 获取值
      • 删除
      • 遍历字典
    • 2.4 字典视图的动态性
    • 2.5 字典推导式
    • 2.6 字典的合并（Python 3.9+）
  • 三、元组与列表的选择
• 💻 代码案例实操
• • 案例1：元组拆包的多种妙用
  • 案例2：字典的基本操作——学生成绩管理
  • 案例3：字典的高级方法与技巧
  • 案例4：字典底层哈希演示与性能
  • 案例5：字典实战——词频统计与文章分析
  • 案例6：嵌套字典与复杂数据操作
• ⚠️ 易错点避坑总结
• 📝 课后实战练习题
• • • 第1题：元组拆包练习
    • 第2题：字典基本操作
    • 第3题：字符统计器
    • 第4题：合并字典与默认值
    • 第5题：使用元组作为字典键
    • 第6题：嵌套字典与JSON处理
    • 第7题：模拟投票系统
• 🔜 下节课预告
• • 第10课：集合Set、数据类型转换与基础语法综合案例练习
• 🔗《50节课 Python 从入门到精通》系列课程导航

📖 开篇导读

前几节课我们学习了列表——一个强大的可变容器。但Python还提供了另一种序列类型：元组（Tuple）。它和列表很像，却有一个关键区别：不可变。为什么需要一种“不能修改”的列表？元组有什么独特的应用场景？

此外，我们即将接触Python中最常用的映射类型——字典（Dict）。如果说列表是通过“位置编号”来查找数据，那么字典就是通过“关键词”来查找，就像现实中的电话本（人名→号码）、词典（单词→释义）。字典是基于哈希表实现的，查询速度极快，是Python高效编程的核心武器之一。

💡 工作场景：函数返回多个值时，其实返回的是一个元组；数据库查询的一行记录可以用元组表示；配置参数常用字典；JSON数据解析后变成字典；缓存系统、词频统计、对象属性存储……字典无处不在。

这一课，我们将深入讲解元组的特性、拆包用法，以及字典的底层哈希表原理、常用方法、遍历技巧和字典推导式。学完本课，你将能够灵活选用合适的容器（列表、元组、字典）解决实际问题。

🎯 学习目标

🔥 面试考点：“元组真的完全不可变吗？”“字典的键可以是什么类型？为什么？”“如何合并两个字典？”“dict.get和dict[key]的区别？”“字典遍历时能否修改？”

📚 知识点理论精讲

一、元组（Tuple）：不可变的序列

1.1 元组的定义

元组使用圆括号()，元素之间用逗号分隔。即使只有一个元素，也必须加逗号以区分普通括号。

# 空元组
empty = ()

# 多个元素
t1 = (1, 2, 3)

# 一个元素必须加逗号
single = (1,) # 类型是tuple
not_tuple = (1) # 类型是int

# 括号可以省略（逗号才是关键）
t2 = 1, 2, 3 # 也是一个元组

🧠 通俗类比：列表像一本便签本，可以撕掉、添加、修改；元组像一张照片，拍完之后就不能改了。照片虽然不能改，但可以放在相册里作为永恒的记录。

1.2 元组的不可变性

元组一旦创建，不能修改其长度，也不能修改其元素的值（对于不可变元素而言）。但如果元组的元素本身是可变对象（如列表），该列表的内容可以修改，但元组仍然“持有”那个列表的引用，不能替换成另一个对象。

t = (1, 2, [3, 4])
# t[0] = 10 # TypeError: 'tuple' object does not support item assignment
t[2].append(5) # 可以修改列表的内容
print(t) # (1, 2, [3, 4, 5])

面试扩展：问“元组真的不可变吗？”答：元组的不可变指的是它“引用的不可变性”，而不是内部对象的不可变。元组存储的是对象的引用，你不能改变这些引用指向谁，但引用指向的可变对象本身是可以变化的。

1.3 元组的常用操作

由于不可变，元组的方法比列表少得多，但支持索引、切片、连接、重复等不修改原对象的操作。

t = (10, 20, 30, 40)

# 索引和切片
print(t[0]) # 10
print(t[1:3]) # (20, 30)

# 连接（返回新元组）
t2 = t + (50, 60)
print(t2) # (10,20,30,40,50,60)

# 重复
t3 = (1,2) * 3 # (1,2,1,2,1,2)

# 成员判断
print(20 in t) # True

# 长度
print(len(t)) # 4

# 方法：count和index
t = (1, 2, 2, 3)
print(t.count(2)) # 2
print(t.index(2)) # 1（第一次出现）

1.4 元组的打包与拆包

这是元组最强大的特性，也是Python代码简洁优雅的重要体现。

打包：将多个值直接赋值给一个元组变量。

拆包：将元组的元素分别赋值给多个变量。

# 打包
data = 1, 2, "hello" # 这是一个元组

# 拆包
a, b, c = data
print(a, b, c) # 1 2 hello

# 典型应用：交换变量（底层就是元组打包和解包）
x, y = 10, 20
x, y = y, x # 交换
print(x, y) # 20 10

# 带星号的拆包（收集多余元素）
first, *middle, last = [1, 2, 3, 4, 5]
print(first) # 1
print(middle) # [2, 3, 4]
print(last) # 5

函数返回多个值实际上就是返回一个元组，然后自动拆包：

def get_user_info():
name = "张三"
age = 25
city = "北京"
return name, age, city # 返回元组

name, age, city = get_user_info() # 拆包

1.5 命名元组（namedtuple）

如果元组的字段很多，通过索引访问容易出错。collections.namedtuple可以为元组的每个位置起名字，兼具元组的轻量和类的可读性。

from collections import namedtuple

# 定义Point类，包含x和y字段
Point = namedtuple('Point', ['x', 'y'])
p = Point(10, 20)
print(p.x, p.y) # 10 20
print(p[0], p[1]) # 10 20（仍然支持索引）

# 应用：坐标、数据库记录等

二、字典（Dict）：键值对的魔法

2.1 字典的定义

字典是无序（Python 3.7+ 插入顺序保留）、可变的键值对集合，使用花括号{}，每个键值对用冒号:分隔。

# 空字典
empty = {}

# 常用方式
person = {
"name": "李四",
"age": 30,
"city": "上海"
}

# 使用dict()构造器
person2 = dict(name="王五", age=28) # 键自动变成字符串
person3 = dict([("name", "赵六"), ("age", 35)]) # 从键值对列表

🧠 通俗类比：字典就像真实的词典——你要查“apple”这个词，直接翻到a开头的部分就能快速找到释义，而不需要一页一页翻。字典通过“键（key）”来快速定位“值（value）”。

2.2 字典的底层原理：哈希表

这是面试高频考点，也是理解字典性能的关键。

哈希表是一种通过哈希函数将键映射到存储位置的数据结构。

• 当向字典插入键值对d[key]=value时，Python会计算hash(key)得到一个整数，再通过某种运算（如取余）确定存储位置。
• 当查找d[key]时，同样计算哈希，直接定位，平均时间复杂度O(1)。
• 不同的键可能产生相同的哈希值（哈希冲突），Python通过开放寻址法或链表法解决。

键的要求：

• 键必须是可哈希的（hashable），即对象的哈希值在其生命周期内不变，并且可以与其他对象比较相等。
• 不可变类型（int、float、str、tuple、frozenset）都可哈希。
• 可变类型（list、dict、set）不可哈希，不能作为字典的键（除非转为元组）。

# 正确：不可变类型做键
d = {1: "int", "name": "str", (1,2): "tuple"}

# 错误：列表做键会报错
# d2 = {[1,2]: "list"} # TypeError: unhashable type: 'list'

💡 工作应用：使用元组作为复合键，例如dict[ (year, month) ] = sales。

2.3 字典的基本操作

添加与修改

person = {"name": "张三"}

# 添加新键值对
person["age"] = 25

# 修改已有键的值
person["name"] = "李四"

# 使用update合并另一个字典
person.update({"city": "北京", "score": 100})
print(person) # {'name': '李四', 'age': 25, 'city': '北京', 'score': 100}

# 如果键存在则不做任何操作（setdefault）
person.setdefault("country", "中国") # 键不存在就添加，存在则返回原值

获取值

person = {"name": "张三"}
print(person.get("age")) # None
print(person.get("age", 0)) # 0
# print(person["age"]) # KeyError

# 典型工作场景：计数
word = "apple"
counts = {}
counts[word] = counts.get(word, 0) + 1

删除

d = {"a":1, "b":2, "c":3}
del d["a"]
print(d) # {"b":2, "c":3}

value = d.pop("b") # value=2，删除键b
print(d) # {"c":3}

# 使用popitem删除最后一个插入项
last = d.popitem() # ("c",3)
print(d) # {}

d.clear()

遍历字典

person = {"name": "张三", "age": 25, "city": "北京"}

# 遍历键（默认）
for key in person:
print(key)

# 遍历键（显式）
for key in person.keys():
print(key)

# 遍历值
for value in person.values():
print(value)

# 遍历键值对（最常用）
for key, value in person.items():
print(f"{key}: {value}")

2.4 字典视图的动态性

keys(), values(), items()返回的是视图对象，它们动态反映字典的变化，而不是创建副本。

d = {"a": 1, "b": 2}
view = d.keys()
print(view) # dict_keys(['a', 'b'])
d["c"] = 3
print(view) # dict_keys(['a', 'b', 'c']) —— 自动更新

# 视图支持集合操作（keys和items支持，values不支持）
d1 = {"a":1, "b":2}
d2 = {"b":2, "c":3}
print(d1.keys() & d2.keys()) # {'b'}

⚠️ 高频坑点：遍历字典时不能修改字典的大小（增删元素），否则会抛出RuntimeError: dictionary changed size during iteration。解决方案：遍历键的副本list(d.keys())。

2.5 字典推导式

与列表推导式类似，可以快速生成字典。

# 基本：{键表达式: 值表达式 for 变量 in 可迭代对象}
squares = {x: x**2 for x in range(5)}
print(squares) # {0:0, 1:1, 2:4, 3:9, 4:16}

# 带条件：过滤掉偶数的键
odd_squares = {x: x**2 for x in range(10) if x % 2 != 0}

# 交换键值
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.6 字典的合并（Python 3.9+）

Python 3.9引入了|和|=运算符用于字典合并。

d1 = {"a": 1, "b": 2}
d2 = {"b": 3, "c": 4}

# 合并为新字典（d2覆盖d1的同名键）
merged = d1 | d2
print(merged) # {'a':1, 'b':3, 'c':4}

# 原地更新
d1 |= d2
print(d1) # {'a':1, 'b':3, 'c':4}

# 兼容旧版本的写法
merged = {**d1, **d2} # 解包合并

三、元组与列表的选择

💻 代码案例实操

案例1：元组拆包的多种妙用

"""
tuple_unpacking.py
演示元组拆包的各种高级用法
"""

# 1. 同时赋值（一行给多个变量）
a, b, c = 1, 2, 3
print(a, b, c)

# 2. 交换变量（经典）
x, y = 10, 20
x, y = y, x
print(f"交换后: x={x}, y={y}")

# 3. 函数返回多个值自动拆包
def get_stats(nums):
return min(nums), max(nums), sum(nums)/len(nums)

scores = [85, 92, 78, 88]
min_score, max_score, avg_score = get_stats(scores)
print(f"最低:{min_score}, 最高:{max_score}, 平均:{avg_score:.2f}")

# 4. 使用*收集剩余元素
first, *rest = [1, 2, 3, 4] # rest是列表
print(first, rest) # 1 [2,3,4]

first, *middle, last = "Python"
print(first, middle, last) # P ['y','t','h','o'] n

# 5. 忽略不需要的值（用下划线）
person = ("张三", 25, "北京", "工程师")
name, age, _, _ = person # 忽略城市和职业
print(name, age)

# 6. 遍历元组列表
points = [(1,2), (3,4), (5,6)]
for x, y in points:
print(f"x={x}, y={y}")

案例2：字典的基本操作——学生成绩管理

"""
student_scores.py
使用字典管理学生成绩
"""

# 学生成绩字典 {姓名: 分数}
scores = {
"张三": 85,
"李四": 92,
"王五": 78,
"赵六": 60,
"周七": 45
}

# 1. 查询学生分数（安全获取）
name = input("请输入学生姓名: ")
score = scores.get(name)
if score is None:
print(f"未找到学生: {name}")
# 添加新学生
new_score = int(input("请输入该学生分数: "))
scores[name] = new_score
else:
print(f"{name} 的成绩是: {score}")

# 2. 更新分数
update_name = input("要修改哪个学生的分数？")
if update_name in scores:
new_score = int(input("新分数: "))
scores[update_name] = new_score
print("更新成功")
else:
print("学生不存在")

# 3. 删除学生
del_name = input("要删除哪个学生？")
if del_name in scores:
deleted = scores.pop(del_name)
print(f"已删除 {del_name}，其分数为 {deleted}")
else:
print("学生不存在")

# 4. 统计信息
if scores:
avg = sum(scores.values()) / len(scores)
max_name = max(scores, key=scores.get) # 分数最高的学生
min_name = min(scores, key=scores.get)
print(f"平均分: {avg:.2f}")
print(f"最高分: {max_name} ({scores[max_name]})")
print(f"最低分: {min_name} ({scores[min_name]})")

# 5. 按分数显示等级
for name, score in scores.items():
if score >= 90:
grade = "A"
elif score >= 80:
grade = "B"
elif score >= 70:
grade = "C"
elif score >= 60:
grade = "D"
else:
grade = "F"
print(f"{name}: {score} -> {grade}")

案例3：字典的高级方法与技巧

"""
dict_advanced.py
字典高级方法实战
"""

# 1. setdefault的妙用：整理单词列表
words = ["apple", "banana", "apple", "cherry", "banana", "apple"]
index = {}
for pos, word in enumerate(words):
# 如果键不存在，则设置为空列表；然后无论如何返回该列表
index.setdefault(word, []).append(pos)
print("单词索引:", index)

# 2. defaultdict（collections模块）更优雅
from collections import defaultdict
index2 = defaultdict(list)
for pos, word in enumerate(words):
index2[word].append(pos)
print("defaultdict版本:", dict(index2))

# 3. Counter（计数）也是字典子类
from collections import Counter
word_counts = Counter(words)
print("单词计数:", word_counts)

# 4. 合并字典的多种方式
d1 = {"a": 1, "b": 2}
d2 = {"b": 3, "c": 4}

# 方法1：update修改原字典
d1.update(d2) # d1被修改
print("update:", d1)

# 方法2：解包（Python 3.5+）
d1 = {"a": 1, "b": 2}
merged = {**d1, **d2}
print("解包合并:", merged)

# 方法3：| 运算符（Python 3.9+）
d1 = {"a": 1, "b": 2}
merged2 = d1 | d2
print("| 合并:", merged2)

# 5. 从字典中过滤（字典推导）
original = {"a": 1, "b": 2, "c": 3, "d": 4}
filtered = {k: v for k, v in original.items() if v % 2 == 0}
print("过滤出偶数项:", filtered)

# 6. 字典的键类型限制与转换
# 将列表转换为元组作为键
data = [("a", 1), ("b", 2)]
d = {tuple(pair[:1]): pair[1] for pair in data} # 错误示例，仅为演示
# 更实际：使用元组键存储复合信息
inventory = {}
inventory[("apple", "red")] = 50
inventory[("apple", "green")] = 30
inventory[("banana", "yellow")] = 20
print("库存:", inventory)

案例4：字典底层哈希演示与性能

"""
hash_table_demo.py
演示哈希值与字典性能
"""

# 1. 查看对象的哈希值
print(hash(42)) # 整数哈希就是本身
print(hash("hello")) # 字符串哈希（每次运行可能因随机化不同）
print(hash((1,2,3))) # 元组哈希

# 列表不可哈希，会报错
# print(hash([1,2,3])) # TypeError

# 2. 自定义类的哈希（默认基于id）
class Person:
def __init__(self, name):
self.name = name

p1 = Person("张三")
p2 = Person("张三")
d = {p1: 1}
print(p1 in d) # True
print(p2 in d) # False（因为默认比较id）

# 如果需要基于内容比较，需定义__hash__和__eq__
class PersonHash:
def __init__(self, name):
self.name = name
def __hash__(self):
return hash(self.name)
def __eq__(self, other):
return self.name == other.name

p3 = PersonHash("张三")
p4 = PersonHash("张三")
d2 = {p3: 100}
print(p4 in d2) # True

# 3. 字典性能对比：O(1) vs 列表O(n)
import time
n = 100000

# 列表查找
lst = list(range(n))
target = n – 1
start = time.time()
found = target in lst
print(f"列表查找耗时: {time.time()–start:.6f}s")

# 字典查找
dct = {i: i for i in range(n)}
start = time.time()
found = target in dct
print(f"字典查找耗时: {time.time()–start:.6f}s")

案例5：字典实战——词频统计与文章分析

"""
word_frequency.py
统计一段文本中单词出现的频率
"""

text = """Python is an amazing programming language.
Python is widely used in data science, web development, and artificial intelligence.
Python's simple syntax makes it easy to learn for beginners.
Learn Python and you will love it!"""

# 1. 清洗文本：转小写，去除标点
import string
translator = str.maketrans('', '', string.punctuation) # 去除标点
cleaned = text.translate(translator).lower()
words = cleaned.split()

# 2. 词频统计（使用普通字典）
freq = {}
for word in words:
freq[word] = freq.get(word, 0) + 1

# 3. 按频率排序输出（前10）
sorted_words = sorted(freq.items(), key=lambda x: x[1], reverse=True)

print(f"总单词数: {len(words)}")
print("单词频率统计（前10）:")
for word, count in sorted_words[:10]:
print(f" {word}: {count}")

# 4. 找出最长单词
max_len = max(len(word) for word in words)
longest = [word for word in set(words) if len(word) == max_len]
print(f"最长单词: {longest} (长度{max_len})")

# 5. 找出只出现一次的单词
singles = [word for word, cnt in freq.items() if cnt == 1]
print(f"出现一次的词数: {len(singles)}")
print(f"示例: {singles[:5]}")

案例6：嵌套字典与复杂数据操作

"""
nested_dict.py
处理嵌套字典（常用于JSON数据）
"""

# 模拟一个公司员工信息（嵌套结构）
company = {
"HR": {
"manager": "张经理",
"employees": ["张三", "李四"],
"budget": 500000
},
"Tech": {
"manager": "王技术总监",
"employees": ["赵六", "钱七", "孙八"],
"budget": 1200000,
"projects": ["项目A", "项目B"]
},
"Sales": {
"manager": "李销售总监",
"employees": ["周九", "吴十"],
"budget": 800000
}
}

# 1. 安全访问深层嵌套（使用get链）
def get_nested(d, *keys, default=None):
for key in keys:
if isinstance(d, dict):
d = d.get(key, default)
else:
return default
return d

print("Tech部门的经理:", get_nested(company, "Tech", "manager"))
print("不存在的部门:", get_nested(company, "Finance", "manager", default="无"))

# 2. 遍历所有员工
all_employees = []
for dept, info in company.items():
for emp in info.get("employees", []):
all_employees.append((emp, dept))
print("所有员工:", all_employees)

# 3. 统计总预算
total_budget = sum(info["budget"] for info in company.values())
print(f"总预算: {total_budget}")

# 4. 扁平化嵌套字典（一层）
flat = {}
for dept, info in company.items():
flat[f"{dept}_manager"] = info["manager"]
flat[f"{dept}_budget"] = info["budget"]
print("扁平化字典:", flat)

# 5. 修改嵌套数据
company["Tech"]["projects"].append("项目C")
print("Tech项目:", company["Tech"]["projects"])

⚠️ 易错点避坑总结

📝 课后实战练习题

第1题：元组拆包练习

有一个元组data = (2024, "Python", 3.12, True)，分别使用四种方式：

第2题：字典基本操作

创建一个字典inventory = {"apple": 50, "banana": 30, "orange": 20}，执行：

第3题：字符统计器

输入一个字符串，统计每个字符（包括空格）出现的次数，输出按出现次数降序排列的前3个字符及其次数。不区分大小写？要求不区分大小写（将大写转为小写）。

第4题：合并字典与默认值

写一个函数merge_dicts(d1, d2)，合并两个字典，如果键冲突，则取两个值的和。例如merge_dicts({"a":1,"b":2}, {"b":3,"c":4})返回{"a":1,"b":5,"c":4}。不能使用collections.Counter，手动实现。

第5题：使用元组作为字典键

统计一个班级学生各科成绩。数据如下：[("张三","数学",85), ("张三","英语",90), ("李四","数学",78), ("李四","英语",88)]。要求输出每个学生的总分和平均分。提示：可以用字典键为学生姓名，值为[总分，科目数]。

第6题：嵌套字典与JSON处理

给定嵌套字典data，编写函数flatten_dict(d, parent_key='', sep='_')将嵌套字典扁平化。例如：

data = {"a": 1, "b": {"c": 2, "d": 3}}
flatten_dict(data) # {"a":1, "b_c":2, "b_d":3}

第7题：模拟投票系统

使用字典存储候选人得票数。程序循环接收用户输入候选人名字，输入’end’结束，然后输出每个候选人的得票数及胜出者（票数最高者）。如果平局，输出“平局”。

🔜 下节课预告

元组和字典让我们能够更灵活地组织数据。下一节课我们将学习集合（Set）以及数据类型转换，并综合前面所学的基础语法，通过大量案例巩固练习。

第10课：集合Set、数据类型转换与基础语法综合案例练习

内容包括：

• 集合的定义与特性（无序、不重复）
• 集合的数学运算（并集、交集、差集、对称差）
• 集合的常用方法（add、remove、discard等）
• 数据类型转换（str/list/tuple/dict/set之间的相互转换）
• 综合案例：学生选课系统、数据去重、多条件筛选
• 回顾前9课核心语法，综合性练习

学完本课，你将彻底掌握Python基础数据结构的全部内容，并能够独立完成小项目！

🌟 学习鼓励：元组和字典是Python的“精兵强将”。元组让不可变数据安全可靠，字典让数据检索如虎添翼。特别是字典的哈希表思想，是计算机科学中最优雅的设计之一。花时间理解底层原理，会让你写出更高效的代码。继续前进，你已经接近基础阶段的尾声了！

🔗《50节课 Python 从入门到精通》系列课程导航

去订阅

🌟 感谢您耐心阅读到这里！ 💡 如果本文对您有所启发欢迎： 👍 点赞📌 收藏 📤 分享给更多需要的伙伴。 🗣️ 期待在评论区看到您的想法, 共同进步。 🔔 关注我，持续获取更多干货内容～ 🤗 我们下篇文章见～