智泊Python–Day6

  Day6 是三类容器/集合类型与拷贝机制。元组（tuple）是「不可变列表」，适合放固定结构的数据；字典（dict）用「键-值」存储，是处理结构化数据（如接口 JSON）的主力；集合（set）靠「去重 + 集合运算」吃饭。最后是浅拷贝 vs 深拷贝——这是 Python 里极易踩坑的点，理解了它才算真正搞懂「变量到底存的是值还是引用」。

 

1.元组

  元组用圆括号，一旦创建元素不可改（所以没有 append/remove）。创建时有一个经典坑：单元素元组必须加逗号 t = (1,)，否则 t = (1) 只是个整数。元组支持索引、切片、遍历、+/*、in 判断，sorted() 会返回一个列表（不是元组）。还常用「解包」x, y = 3, 4 一次取出多个值，用 _ 占位不想要的元素。

# 创建
t = (1, 2, 3, 4, 5)
t1 = (1)        # 注意：这是 int，不是元组
t2 = ()         # 空元组
t3 = (1,)       # 单元素元组必须加逗号
print(t, type(t))

# 索引 / 长度 / 遍历（同列表）
print(t[0], t[-1])
print(len(t))
for i in t:
    print(i)

# 切片 / 合并 / 成员
print(t[:3], t[3:], t[2:5], t[0:5:2])
print((1, 2, 3) + (4, 5, 6))
print((1, 2, 3) * 3)
print(3 in (1, 2, 3, 4, 5))

# 排序/转换/查找
print(sorted((3, 1, 2)))     # [1, 2, 3]（返回列表）
print(list((1, 2, 3)))       # [1, 2, 3]
print((1, 3, 5, 7, 9).index(3))   # 1
print((1, 3, 3, 4, 3).count(3))   # 3

# 快速解包
x, y = 3, 4
x1, y1 = [3, 4]
x2, y2 = (3, 4)
z, _ = (3, 4)     # _ 占位
_, w = (3, 4)
print(x, y, z, w)

 

2.字典

  字典是「键-值」映射：键唯一、键必须是不可变类型（一般用字符串）、无序。取值用 d["key"]（不存在会报错）或 d.get("key", 默认值)（更安全的写法）。遍历推荐 for key in d 或 for k, v in d.items()。改值用 d["key"] = 新值（key 本身不可改，只能改对应的值）；update() 合并另一个字典，重复键会被覆盖；pop(key) 删除键值对。

# 创建
d = {"name": "张三丰", "age": 100, "sex": "男"}
print(d)

# 取值：[] 会报错，get 可带默认值
print(d["name"])                  # 张三丰
print(d.get("name"), d.get("name2"))        # 张三丰 None
print(d.get("jor", "太极传人"))   # 太极传人（key 不存在时返回默认值）

# 长度与遍历
print(len(d))
print(list(d.keys()))            # 所有 key
print(list(d.values()))          # 所有 value
print(list(d.items()))           # 所有 (key, value) 对
for key in d:
    print(key, d[key])
for key, value in d.items():
    print(key, value)

# 改值（key 不可改，值可改）
d["name"] = "李四"
print(d)

# 合并：重复 key 被覆盖
d2 = {"name": "王二", "jor": "太极传人"}
d.update(d2)
print(d)        # {'name': '王二', 'age': 100, 'sex': '男', 'jor': '太极传人'}

# 增 / 删
d = {"name": "张三丰", "age": 100}
d["sex"] = "男"          # 增
d.pop("age")            # 删
print(d)
# d.clear() 清空；d.popitem() 随机删一个键值对

 

3.字典练习（嵌套数据提取）

  真实接口数据往往是「字典套列表套字典」的嵌套结构（如斗鱼接口）。提取思路：先按层级 douyu["data"]["rl"] 拿到主播列表，再遍历每个元素取 nickname / avatar。第二个练习是「列表推导式」的雏形——筛选成绩 ≥70 的字典组成新列表。

# 练习1：从嵌套接口数据中提取每个主播的 nickname 和 avatar
douyu = {
    "code": 0,
    "msg": "",
    "data": {
        "ct": 1,
        "rl": [
            {"rid": 1345550, "nickname": "努力的Lorre",
             "avatar": "https://apic.douyucdn.cn/.../big.jpg", "hn": 8970},
            {"rid": 1345551, "nickname": "努力的one",
             "avatar": "https://apic.douyucdn.cn/.../big.jpg", "hn": 8970},
        ]
    }
}
rl_list = douyu["data"]["rl"]
for a in rl_list:
    print(a["nickname"], a["avatar"])

# 练习2：去除成绩 < 70 的字典
dict_list = [
    {"科目": "数学", "成绩": 98},
    {"科目": "英语", "成绩": 85},
    {"科目": "物理", "成绩": 92},
    {"科目": "化学", "成绩": 88},
    {"科目": "生物", "成绩": 60},
]
dict_list2 = []
for a in dict_list:
    if a["成绩"] >= 70:
        dict_list2.append(a)
print(dict_list2)

 

4.集合

  集合的特点是唯一（自动去重）+ 无序（无索引），元素必须不可变。两个坑：

• ① {} 是空字典不是空集合，空集合要写 set()
• ② 去重后顺序会变（集合不保序）

  集合真正强大的是集合运算：& 交集、| 并集、- 差集、^ 对称差集、>= 判断超集。

# 创建（自动去重）
s = {1, 2, 2, 3, 2, 4}
print(s)

# 空集合：{} 是字典，set() 才是集合
print(type({}), type(set()))

# 遍历 / 长度 / 成员
for i in s:
    print(i)
print(len(s), 1 in s, 5 in s)

# 增删：add / remove(不存在报错) / discard(不存在不报错) / pop(随机删) / clear
s.remove(2); print(s)
s.add(2); print(s)

# 集合运算
s1, s2 = {1, 2, 3, 4, 5}, {3, 4, 5, 6, 7}
print(s1 & s2)    # 交集 {3, 4, 5}
print(s1 | s2)    # 并集 {1, 2, 3, 4, 5, 6, 7}
print(s1 - s2)    # 差集 {1, 2}（s1 有 s2 无）
print(s1 >= s2)   # False（s1 是否包含 s2 全部）
print(s1 ^ s2)    # 对称差集 {1, 2, 6, 7}

# 用集合去重（注意：顺序会变）
nums = [1, 3, 3, 2, 2, 2, 3, 2, 4]
nums_set = set(nums)
print(nums_set, type(nums_set))
print(list(nums_set), type(list(nums_set)))

 

5.浅拷贝与深拷贝

  理解拷贝前先分两类类型：不可变（int/float/str/tuple/bool/None）赋值互不影响；可变（list/dict/set）赋值是「两个变量指向同一个对象」，改一个另一个也变。.copy() 是浅拷贝——只复制第一层，如果元素里还嵌套可变对象（如列表里的列表），内层仍是共享引用；deepcopy()（来自 copy 模块）则完全独立，改谁都不影响谁。推荐用 pythontutor.com 可视化每一步的内存变化。

# 不可变类型：赋值互不干扰
a, b = 10, a = 10
b = a
b = 20
print(a, b)    # 10 20

# 可变类型：赋值共享同一对象
a = [1, 2, 3]
b = a
b[0] = 100
print(a, b)    # [100, 2, 3] [100, 2, 3]

# 浅拷贝 copy()：只复制第一层
a = [1, 2, 3]
b = a.copy()
b[0] = 100
print(a, b)    # [1, 2, 3] [100, 2, 3]（第一层独立）

a = [1, 2, [2, 3]]
b = a.copy()
b[0] = 666
b[2][0] = 999
print(a, b)    # [1, 2, [999, 3]] [666, 2, [999, 3]]（嵌套层仍共享）

# 深拷贝 deepcopy()：完全独立
from copy import deepcopy
a = [1, 2, [2, 3]]
c = deepcopy(a)
c[0] = 666
c[2][0] = 999
print(a, c)    # [1, 2, [2, 3]] [666, 2, [999, 3]]（互不影响）