33解包

在 Python 中，**解包（Unpacking）** 是一种将**可迭代对象**（如列表、元组、字符串、字典等）中的元素 “拆分” 并赋值给变量或传递给函数的操作。

它的核心作用是**简化代码**，避免手动索引访问（如lst[0]、lst[1]），让数据处理更直观。

## 序列解包

序列解包（Sequence Unpacking）适用于所有**可迭代的序列类型**（列表、元组、字符串、range 对象等），核心是将序列中的元素按位置对应到变量。

**1. 基本用法：一一对应赋值**

当变量数量与序列元素数量**相等**时，直接按位置赋值：

```python
# 元组解包
t = (10, 20, 30)
a, b, c = t
print(a, b, c)  # 10 20 30

# 列表解包
lst = ["Alice", 25, "female"]
name, age, gender = lst
print(name, age, gender)  # Alice 25 female

# 字符串解包（按字符拆分）
s = "abc"
x, y, z = s
print(x, y, z)  # a b c

# range对象解包
r = range(3)  # 等价于0,1,2
p, q, r = r
print(p, q, r)  # 0 1 2
```

**2. 处理数量不匹配：* 收集多余元素**

当变量数量**少于**序列元素数量时，可用*修饰一个变量，用于**收集多个元素**（返回列表）：

```python
# 收集中间元素
numbers = [1, 2, 3, 4, 5]
first, *middle, last = numbers
print(first)   # 1
print(middle)  # [2, 3, 4]（多余元素被*收集为列表）
print(last)    # 5

# 收集开头元素
*head, tail = numbers
print(head)  # [1, 2, 3, 4]
print(tail)  # 5

# 收集所有元素（变量数量为1）
*all_elements, = numbers  # 注意尾部的逗号，避免被解析为元组
print(all_elements)  # [1, 2, 3, 4, 5]
```

**注意**：

- 一个赋值语句中**只能有一个\*变量**（否则会报错）；
- *变量可以收集 0 个或多个元素（返回空列表）：

```python
a, *b = [1]
print(a)  # 1
print(b)  # []（收集0个元素）
```

**3. 忽略不需要的元素**

用下划线_作为 “占位符变量”，忽略不需要的元素（_是合法变量名，但通常约定用于表示 “临时 / 无用” 的值）：

```python
data = ("Alice", 25, "female", "Python")
# 只需要姓名和年龄，忽略其他
name, age, _, _ = data
print(name, age)  # Alice 25

# 结合*忽略中间元素
info = [100, 200, 300, 400, 500]
first, *_, last = info
print(first, last)  # 100 500
```

## 字典解包

字典解包（Dictionary Unpacking）有两种方式，分别针对**键（key）** 和**键值对（key-value）**

**1. 用*解包字典的键**

*用于字典时，会解包字典的**所有键**（按插入顺序，Python 3.7+ 保证顺序）：

```python
d = {"name": "Bob", "age": 30, "gender": "male"}

# 解包所有键
*keys, = d  # 等价于 *keys, = d.keys()
print(keys)  # ['name', 'age', 'gender']

# 结合其他变量
first_key, *rest_keys = d
print(first_key)    # 'name'
print(rest_keys)    # ['age', 'gender']
```

**2. 用解包字典的键值对（作为关键字参数）**

**用于将字典的键值对解包为**关键字参数**（key=value形式），主要用于函数调用：

```python
def person_info(name, age, gender):
    print(f"姓名：{name}，年龄：{age}，性别：{gender}")

# 字典的键必须与函数参数名一致
person_dict = {"name": "Charlie", "age": 28, "gender": "male"}

# 用**解包字典作为关键字参数
person_info(** person_dict)  # 等价于 person_info(name="Charlie", age=28, gender="male")
# 输出：姓名：Charlie，年龄：28，性别：male
```

**注意**：**解包的字典键必须是字符串，且与接收方的参数名匹配（否则会报错）。

## 三、解包操作符*和**的高级用法

*和**不仅用于赋值，还可在**函数调用**、**数据结构创建**等场景中灵活使用。

**1. 函数调用中解包参数**

*用于解包序列为**位置参数**；

**用于解包字典为**关键字参数**。

```python
def add(a, b, c):
    return a + b + c

# 用*解包列表作为位置参数
nums = [1, 2, 3]
print(add(*nums))  # 等价于 add(1, 2, 3) → 6

# 用**解包字典作为关键字参数
params = {"a": 10, "b": 20, "c": 30}
print(add(** params))  # 等价于 add(a=10, b=20, c=30) → 60

# 混合使用
part1 = [100, 200]
part2 = {"c": 300}
print(add(*part1, **part2))  # 等价于 add(100, 200, c=300) → 600
```

输出结果：

```python
6
60
600
```

**2. 合并数据结构**

*可合并多个序列（列表、元组、字符串等）；

**可合并多个字典（键相同则后者覆盖前者）。

```python
# 用*合并序列
list1 = [1, 2, 3]
list2 = [4, 5, 6]
merged_list = [*list1, *list2]  # 合并列表
print(merged_list)  # [1, 2, 3, 4, 5, 6]

tuple1 = (10, 20)
tuple2 = (30, 40)
merged_tuple = (*tuple1, *tuple2, 50)  # 合并元组并添加新元素
print(merged_tuple)  # (10, 20, 30, 40, 50)

# 用**合并字典
dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}  # 键"b"重复，后者覆盖前者
merged_dict = {** dict1, **dict2}
print(merged_dict)  # {'a': 1, 'b': 3, 'c': 4}
```

输出结果：

```python
[1, 2, 3, 4, 5, 6]
(10, 20, 30, 40, 50)
{'a': 1, 'b': 3, 'c': 4}
```

**3. 嵌套解包**

处理嵌套的可迭代对象时，可通过多层解包直接获取深层元素：

```python
# 嵌套元组
nested = (1, (2, 3), 4)
a, (b, c), d = nested
print(a, b, c, d)  # 1 2 3 4

# 嵌套列表
nested_list = [10, [20, 30, [40, 50]], 60]
x, (y, z, (m, n)), p = nested_list
print(x, y, z, m, n, p)  # 10 20 30 40 50 60

# 结合*处理嵌套中的多个元素
data = ("Alice", [25, "female", "Engineer"], "Beijing")
name, (age, *details), city = data
print(name)    # Alice
print(age)     # 25
print(details) # ['female', 'Engineer']（收集列表中的剩余元素）
```

输出结果：
```python
1 2 3 4
10 20 30 40 50 60
Alice
25
['female', 'Engineer']
```

## 注意事项

1.**可迭代性要求**：解包的对象必须是可迭代的（如列表、元组、字典、字符串等），不可迭代对象（如整数、None）不能解包：

```python
# 错误示例：整数不可迭代
a, b = 100  # TypeError: cannot unpack non-iterable int object
```

2.**变量数量与元素数量的匹配 **：

- 无*时，变量数量必须与元素数量完全一致；
- 有*时，*变量可接收任意数量（包括 0）的元素，但一个赋值语句中只能有一个*。

3.**字典解包的特殊性 **：

- *解包字典时，实际是解包dict.keys()（键的视图）；
- **解包字典时，键必须是字符串且与目标参数兼容（如函数参数名）。

4.**函数定义中的解包（可变参数）**：
函数定义时，*args用于收集位置参数为元组，**kwargs用于收集关键字参数为字典，本质是解包的逆操作：

```python
def func(*args, **kwargs):
    print("位置参数：", args)    # 元组
    print("关键字参数：", kwargs)  # 字典

func(1, 2, a=3, b=4)
# 输出：
# 位置参数： (1, 2)
# 关键字参数： {'a': 3, 'b': 4}
```

## 总结

解包是 Python 中简化数据处理的重要特性，核心价值在于：

- **简化赋值 **：无需通过索引访问，直接将序列元素分配给变量；
- **灵活传参 **：在函数调用中轻松传递序列或字典作为参数；
- **合并数据 **：快速合并多个序列或字典，避免循环拼接；
- **处理嵌套结构 **：直接获取深层数据，减少代码层级。