dict 字典
一、底层与基础特性
- 键（key）：必须是不可变数据类型（int、str、float、tuple）；列表、字典、集合这类可变类型不能作为键；键具备唯一性，同一个字典不能出现重复 key，重复赋值会覆盖旧值。
- 值（value）：无限制，可以存放任意 Python 数据类型（数字、字符串、列表、字典、对象等）。
二、字典三种遍历方式
假设字典 d = {"a":1, "b":2, "c":3}
1. 遍历所有键
代码示例：
for k in d.keys():
print(k)
运行结果：
a
b
c
简写：for k in d: 默认遍历键。
2. 遍历所有值
代码示例：
for v in d.values():
print(v)
运行结果：
1
2
3
3. 同时遍历键和值（最常用）
代码示例：
for k, v in d.items():
print(k, v)
运行结果：
a 1
b 2
c 3
三、字典常用内置方法详解
1. 查询：dict.get(key, default)
- 作用：获取 key 对应的值。
- 区别于 d[key]：
- d[key]：key 不存在直接报错。
- d.get(key, 默认值)：key 不存在不会报错，返回给定的默认值；不写默认值则返回None。
代码示例：
d = {"a":10}
print(d.get("a")) # 10
print(d.get("b", 0)) # 键b不存在，返回0
2. 删除操作
代码示例：
val = d.pop("a")
3. 新增 / 修改键值对
- key 存在：覆盖原有 value（修改）。
- key 不存在：新增一组键值对。
- key 存在：不修改原有 value，直接返回旧值。
- key 不存在：新增 key:value，返回 value。
对比 d[key]=value：setdefault 不会覆盖已有数据。
4. 合并字典 dict.update(其他字典)
将参数字典里所有键值对合并进原字典；
- 如果键重复：参数字典的值覆盖原字典的值。
代码示例：
d1 = {"a":1}
d2 = {"b":2, "a":99}
d1.update(d2)
print(d1) # {'a': 99, 'b': 2}
5. 快速创建字典 dict.fromkeys(可迭代对象, value)
- 作用：构建全新字典。
- 规则：可迭代对象内所有元素作为字典的键，所有键共用同一个 value。
代码示例：
d = dict.fromkeys(["a","b","c"], 0)
print(d) # {'a':0, 'b':0, 'c':0}
⚠️ 坑提醒：value 如果是列表等可变对象，所有键共享同一个列表，修改一处全部变动。
四、拓展高频考点（思维导图没有但是必考）
代码示例：
d = {"a":1}
print("a" in d) # True
print(1 in d) # False
五、方法速记区分
| d[key] = val | 覆盖原值 | 新增 |
| setdefault(key,val) | 不修改原值 | 新增 |
| get(key,val) | 返回值 | 返回默认值，不新增键 |
tuple 元组
一、核心特性
注意：如果元组内嵌套列表 t = (1, [2,3])，元组本身不可变，但是内部列表里的元素可以修改。
二、元组声明（重点易错点）
1. 字面量创建
t1 = () # 空元组
t2 = (10,) # 只有单个元素，末尾逗号【不能省略】
t3 = (1, 2, 3, "abc") # 多个元素，括号可以省略，逗号才是元组标识
t4 = 1,2,3 # 等价 (1,2,3)
高频： t = (5) 这不是元组！只是一个数字； t = (5,) 才是单元素元组。
2. 类型转换 tuple(可迭代对象)
把列表、字符串、集合等可迭代类型转为元组
lst = [1,2,3]
t = tuple(lst) # (1,2,3)
s = "hello"
t2 = tuple(s) # ('h','e','l','l','o')
三、基础通用操作（思维导图未标出，必掌握）
t = (10,20,30)
print(t[0]) # 10
print(t[-1]) # 30
t[1:]
t[::-1] # 元组反转
# 方式1 直接遍历元素
for item in t:
pass
# 方式2 通过索引遍历
for i in range(len(t)):
print(t[i])
四、元组内置方法（仅有 2 个！）
元组不可变，没有增删改方法，只有两个查询方法：
1. tuple.count(元素)
统计指定元素在元组中出现的次数
t = (1,2,2,3)
print(t.count(2)) # 2
2. tuple.index(元素)
- 功能：返回第一次匹配元素对应的索引下标
- 风险：如果元素不存在，直接抛出 ValueError 报错
t = (10,20,30)
print(t.index(20)) # 1
# t.index(99) 报错！
五、拓展
1. 元组不可变的深层理解
t = (1, [2,3])
# t[0] = 100 ❌ 报错，不能替换元组内元素
t[1].append(4) # ✅ 合法！
print(t) # (1, [2, 3, 4])
原理：元组保存的是元素内存地址；地址不变就不算修改元组。列表地址没变，只是列表内部内容变化。
2. 元组常用场景
def func():
return 10,20 # 等价 return (10,20)
3. 元组和列表相互转换
t = (1,2,3)
lst = list(t) # 元组 → 列表
t2 = tuple(lst) # 列表 → 元组
六、元组 与 列表核心对比速记
| 可变性 | 可变，可以增删改元素 | 不可变，无法直接修改元素 |
| 符号 | [] | ()，单元素必须带逗号 |
| 内置方法 | 大量增删改查方法 | 仅 count、index 两个查询方法 |
| 能否做字典 key | ❌ 不可以 | ✅ 可以 |
set 集合
一、核心基础特性
二、集合定义与创建
s = {1,2,3}
易错点：{} 是空字典！空集合必须使用 set() 创建
empty_set = set() # 空集合
empty_dict = {} # 空字典
lst = [1,2,2,3]
s = set(lst) # {1,2,3}
三、可变集合常用增删方法
新增元素
s.add(5)
s.update([4,5,6])
删除元素（重点区分 4 种删除）
四、集合数学运算（核心考点）
设两个集合：s1 = {1,2,3,4}，s2 = {3,4,5,6}
不带_update：返回新集合，原集合不变 带_update：原地修改原集合，无返回值
| 交集 | intersection() | 同时存在于两个集合的元素 |
| 交集更新 | intersection_update() | 原地保留交集，修改自身 |
| 并集 | union() | ` |
| 差集 | difference() | 存在于 A，不存在于 B 的元素 |
| 差集更新 | difference_update() | 原地保留差集 |
| 对称差集 | symmetric_difference() | 只在其中一侧出现的元素 |
| 对称差更新 | symmetric_difference_update() | 原地修改为对称差集 |
示例：
s1 = {1,2,3,4}
s2 = {3,4,5,6}
print(s1.intersection(s2)) # {3,4}
print(s1 & s2)
print(s1.difference(s2)) # {1,2}
print(s1 – s2)
五、其他常用基础操作
3 in {1,2,3} # True
for item in s:
print(item)
六、高频应用场景
lst = [1,1,2,3]
new_lst = list(set(lst))
缺陷：集合无序，会打乱原有顺序；需要保序去重要换其他方案。 2. 数据对比：求交集（共同数据）、差集（独有数据）
