一、拆包核心概念

拆包（Unpacking）：将可迭代对象（列表、元组、字典等）中的元素，一次性赋值给多个变量。这是一种快速提取数据的方式。

最简单的例子：

# 有一个元组，想快速提取每个元素
nums = (11, 22, 33, 44)
num1, num2, num3, num4 = nums   # 一次性拆包赋值

---

二、基础拆包（元组 & 列表）

这是最常见的场景，适用于元组和列表。

# 元组拆包
a = (10, 20)
x, y = a
print(x)  # 10
print(y)  # 20

# 列表拆包
a = [10, 20]
x, y = a  # 数量必须相同
print(x)  # 10
print(y)  # 20

关键注意：左边的变量数量必须和右边的元素数量一致，否则会报 ValueError。

---

三、进阶拆包：* 号的使用

当元素数量较多，而你只需要其中一部分时，使用 * 来收集剩余的元素。

1. 收集剩余元素（Rest）

numbers = [1, 2, 3, 4, 5]

# 只要第一个，剩下的打包成列表
one, *values = numbers
print(one)     # 1
print(values)  # [2, 3, 4, 5]

# 只要头和尾，去掉中间
one, *names, values = numbers
print(one)     # 1
print(names)   # [2, 3, 4]
print(values)  # 5

*变量 会把剩余的元素打包成一个列表。

2. 丢弃不需要的变量

如果你对某些返回值不感兴趣，可以用 *_ 或 _ 来忽略它们。

numbers = (1, 2, 3, 4, 5)

# 只要头和尾，中间的全部忽略
one, *_, values = numbers
print(one)     # 1
print(values)  # 5

# 只要第1个和第3个，忽略第2个和第4个
numbers = (1, 2, 3, 4)
one, _, values, _ = numbers
print(one)     # 1
print(values)  # 3

_ 是一个约定俗成的变量名，表示“这个值我不关心，丢掉它”。

---

四、字典拆包

字典的拆包稍特殊，默认是对**键（Keys）**进行操作。

1. 默认拆包（拿到键）

data = {'a': 5, 'b': 15}

a, b = data
print(a)  # a
print(b)  # b

2. 拆包键值对（使用 items()）

data = {'a': 5, 'b': 15}

a, b = data.items()
print(a)  # ('a', 5)
print(b)  # ('b', 15)

# 更常用的方式：直接在for循环中拆包
for k, v in data.items():
    print(k, v)  # a 5 → b 15

3. 单独拆包值（使用 values()）

data = {'a': 5, 'b': 15}

a, b = data.values()
print(a)  # 5
print(b)  # 15

---

五、函数调用中的拆包（最实用场景之一）

拆包经常用于给函数传递参数。

1. 用 * 传递列表/元组（位置参数）

def add(x, y):
    return x + y

nums = [3, 5]

# 不用拆包（繁琐）
print(add(nums[0], nums[1]))  # 8

# 用 * 拆包（简洁）
print(add(*nums))             # 8

*列表 会把列表中的每个元素作为独立的参数传入函数。

2. 用 ** 传递字典（关键字参数）

def print_info(name, age):
    print(f"name: {name}, age: {age}")

info = {"name": "xx", "age": 18}
print_info(**info)  # name: xx, age: 18

**字典 会把字典中的键值对作为关键字参数传入函数，键对应参数名，值对应参数值。

---

六、嵌套拆包

如果数据结构是嵌套的（如元组里包含元组），可以通过匹配结构来拆包。

data = ("iod", (10, 20, 30))

# 外层拆包 + 内层拆包
name, (n1, n2, n3) = data
print(name)       # iod
print(n1, n2, n3) # 10 20 30

拆包的变量结构要和数据结构一一对应。

---

七、常用场景

1. 交换变量（Python独有的一行写法）

a = 1
b = 2
a, b = b, a
print(a, b)  # 2, 1

2. 遍历多个序列（结合 zip）

name = ["xx", 'yy', 'zz']
age = [18, 19, 20]

# zip打包 + 拆包赋值
for n, a in zip(name, age):
    print(n, a)
# xx 18
# yy 19
# zz 20

3. 处理函数返回多个值

def add():
    return 100, 200

x, y = add()
print(x)  # 100
print(y)  # 200

---

今日核心总结

1. 拆包 = 一次性赋值：将可迭代对象中的元素同时赋给多个变量，语法为 x, y = iterable。

2. 三种拆包方式：

方式	语法	说明
基础拆包	x, y = (10, 20)	左右数量必须一致
* 号拆包	one, *rest = nums	收集剩余元素为列表
_ 忽略	one, _, three = nums	丢弃不需要的值

3. 字典拆包三类：

   • 默认拆包拿到的是键：a, b = dict
   • 用 .items() 拿到键值对：a, b = dict.items()
   • 用 .values() 拿到值：a, b = dict.values()

4. 函数参数拆包（重点）：

   • *列表/元组 → 将元素作为位置参数传入
   • **字典 → 将键值对作为关键字参数传入

5. 常见应用：

   • 交换变量：a, b = b, a
   • 遍历多个序列：for n, a in zip(names, ages):
   • 接收函数多返回值：x, y = func()
   • 嵌套拆包：name, (n1, n2) = data
   • 注:已经使用DeepSeek进行整理精简核心内容，些许不理解的配合个人笔记进行理解。
     -今日只学一个知识点，因为后续的知识点是第二大模块