📦 Python Containers 学习笔记 —— Dict（字典）【详细版】

---

1. Dict 是什么？

Dict 是一种通过 key → value 映射来存储数据的可变容器

核心特性

• 键值对（key : value）结构

• 通过 key 查找 value

• key 必须可哈希（hashable）

• value 可以是任意类型

• dict 本身可修改（mutable）

d = {"a": 1, "b": 2}

---

2. Dict 的基本结构

{ key1: value1, key2: value2, ... }

📌 类比理解：

• key：名字 / 标签 / 索引

• value：对应的数据

---

3. 创建 Dict 的方式

3.1 直接创建

student = { "name": "Tom", "age": 20, "score": 85 }

---

3.2 空字典

d = {}

---

3.3 使用 dict() 创建

d = dict(a=1, b=2)

⚠️ 这种方式的 key 必须是合法变量名（字符串）

---

3.4 从键值对序列创建

pairs = [("a", 1), ("b", 2)] d = dict(pairs)

---

4. Dict 的访问（非常重要）

4.1 使用 [] 访问

d = {"a": 1, "b": 2} d["a"] # 1

⚠️ key 不存在会报错：

d["c"] # ❌ KeyError

---

4.2 使用 get()（安全访问）

d.get("a") # 1 d.get("c") # None d.get("c", 0) # 0（默认值）

📌 工程中强烈推荐 get

---

5. 添加与修改元素

5.1 添加新键值对

d["grade"] = "A"

---

5.2 修改已有键

d["age"] = 21

📌 dict：

• key 存在 → 修改

• key 不存在 → 新增

---

6. 删除元素

6.1 del

del d["age"]

⚠️ key 不存在 → KeyError

---

6.2 pop(key)

x = d.pop("age")

• 删除并返回 value

• key 不存在 → KeyError

---

6.3 pop(key, default)

d.pop("age", None)

📌 安全删除

---

6.4 clear()

d.clear()

---

7. Dict 的核心方法（必须会）

7.1 keys() / values() / items()

d.keys() # 所有 key d.values() # 所有 value d.items() # (key, value) 对

📌 返回的是 视图对象，不是 list

---

7.2 遍历 dict（非常重要）

for k in d: print(k, d[k])

for k, v in d.items(): print(k, v)

📌 最推荐：items() 解包

---

8. Dict 的更新：update

8.1 用另一个 dict 更新

d.update({"a": 100, "c": 3})

规则：

• key 存在 → 覆盖

• key 不存在 → 新增

---

8.2 用键值对序列更新

d.update([("x", 1), ("y", 2)])

---

9. Dict 中 key 的规则（⚠️重点）

9.1 key 必须可哈希

d = {(1, 2): "ok"} # ✅ d = {[1, 2]: "no"} # ❌

---

9.2 常见合法 key

• int / float / bool

• str

• tuple（内部元素也必须可哈希）

• None

• frozenset

---

9.3 不合法 key

• list

• dict

• set

---

10. Dict 的常用操作表达式

10.1 成员判断（判断 key）

"a" in d

📌 只判断 key，不判断 value

---

10.2 长度

len(d)

---

10.3 复制

d2 = d.copy()

---

11. Dict 的嵌套（非常常见）

data = { "student1": {"name": "Tom", "age": 20}, "student2": {"name": "Amy", "age": 21} }

访问：

data["student1"]["name"]

---

12. Dict 的典型应用场景（工程直觉）

• 对象属性（JSON 风格）

• 配置参数

• 计数器 / 统计

• 映射关系（ID → 信息）

• 状态机 / 缓存

---

13. Dict vs Set（对照理解）

对比	dict	set
存储内容	key → value	只有元素
是否可变	✅	✅
是否无序	逻辑无序	无序
成员判断	判断 key	判断元素
是否去重	key 唯一	元素唯一

---

14. 常见坑总结（必看）

1️⃣ d[key] vs d.get(key)
2️⃣ in d 判断的是 key
3️⃣ key 必须可哈希
4️⃣ update 会覆盖已有 key
5️⃣ items() 才能同时拿 key 和 value

---

📦 Python 学习笔记 —— Shallow Copy & Deep Copy（浅拷贝与深拷贝）

---

1. 先一句话说清楚（必须背）

浅拷贝：只复制“外壳”，内部对象还是共用
深拷贝：外壳 + 内部对象全部复制

---

2. 什么是“拷贝”？

假设你有一个对象：

a = [1, 2, 3]

你想要一个 “和 a 一样，但互不影响的副本”，这就涉及拷贝。

---

3. 赋值 ≠ 拷贝（⚠️最容易犯错）

a = [1, 2, 3] b = a

此时：

• a 和 b 指向同一个对象

• 改 a，b 一起变

a[0] = 100 # b 也变成 [100, 2, 3]

📌 这只是“起了两个名字”，不是拷贝

---

4. Shallow Copy（浅拷贝）

4.1 定义

浅拷贝会创建一个新的容器对象，但容器内部的元素仍然指向原来的对象

---

4.2 常见浅拷贝方式

list

b = a.copy() b = a[:]

dict

b = d.copy()

set

b = s.copy()

通用方式

import copy b = copy.copy(a)

---

4.3 浅拷贝示例（⚠️重点）

a = [[1, 2], [3, 4]] b = a.copy()

内存关系：

a ──┐ ├──> [1, 2] b ──┘

---

4.4 修改“内部对象”的后果

a[0][0] = 100

结果：

a == [[100, 2], [3, 4]] b == [[100, 2], [3, 4]]

📌 浅拷贝没救：内部对象是共享的

---

4.5 修改“外层对象”的后果

a.append([5, 6])

结果：

a != b

📌 外壳不同 → append 不会影响 b

---

5. Deep Copy（深拷贝）

5.1 定义

深拷贝会递归复制所有层级的对象

---

5.2 使用方式（唯一标准）

import copy b = copy.deepcopy(a)

---

5.3 深拷贝示例

a = [[1, 2], [3, 4]] b = copy.deepcopy(a) a[0][0] = 100

结果：

a == [[100, 2], [3, 4]] b == [[1, 2], [3, 4]]

📌 完全隔离，互不影响

---

6. dict + copy 的经典坑（必考）

d1 = { "a": [1, 2], "b": [3, 4] } d2 = d1.copy() # 浅拷贝

d1["a"].append(100)

结果：

d2["a"] == [1, 2, 100]

📌 dict.copy() 也是浅拷贝

---

正确做法（需要隔离内部）

import copy d2 = copy.deepcopy(d1)

---

7. tuple 的特殊情况（容易误解）

t = ([1, 2], [3, 4])

• tuple 本身不可变

• 但内部 list 可变

t[0][0] = 100 # ✅ 合法

📌 tuple 的 shallow / deep copy 只影响内部元素

---

8. 如何判断是否“真的拷贝”？

8.1 用 is 判断是否同一对象

a is b

• True → 同一对象

• False → 不同对象

---

8.2 用 id() 看内存地址（调试用）

id(a) id(b)

---

9. 什么时候用 shallow？什么时候用 deep？

✅ 用浅拷贝（效率高）

• 内部元素都是不可变对象（int / str / tuple）

• 你只关心外层结构

✅ 用深拷贝（安全）

• 内部包含 list / dict / set

• 你需要完全隔离的数据副本

---

10. 常见错误总结（必背）

1️⃣ b = a 不是拷贝
2️⃣ list.copy() / dict.copy() 是 浅拷贝
3️⃣ 浅拷贝共享内部可变对象
4️⃣ copy.deepcopy() 才是真正独立副本
5️⃣ tuple 不可变 ≠ 内部元素不可变

---

11. 一句话终极总结（考试版）

浅拷贝复制容器，深拷贝复制容器及其所有内容。

Dict 是以可哈希 key 为索引、映射到任意 value 的可变容器，是 Python 最核心的数据结构。