火车司机

解包是指通过迭代，从一个集合（例如 list、tuple 或 dict）中提取元素的操作。 解包出来的值随后可以在同一条语句中赋给变量，这通常称为多重赋值。

特殊运算符 * 和 ** 常用于解包场景，也常用于多重赋值。

多重赋值

在多重赋值中，赋值运算符（=）左侧的变量数量必须与右侧的值的数量一致。 要用逗号 , 分隔这些值：

>>> a, b = 1, 2
>>> a
1

如果多重赋值中变量的数量与给定的值不符，就会抛出 ValueError：

>>> x, y, z = 1, 2

ValueError: too many values to unpack (expected 3, got 2)

多重赋值不限于一种数据类型：

>>> x, y, z = 1, "Hello", True
>>> x
1

>>> y
'Hello'

>>> z
True

多重赋值可以用来交换 lists 中的元素。 这种做法在排序算法中相当常见。 例如：

>>> numbers = [1, 2]
>>> numbers[0], numbers[1] = numbers[1], numbers[0]
>>> numbers
[2, 1]

由于 tuples 是不可变的，所以无法交换 tuple 中的元素。

解包

在 Python 中，可以把 list/tuple/dictionary 的元素解包到不同的变量中。 由于值在 lists/tuples 中按特定顺序排列，它们会按相同的顺序解包到变量中：

>>> fruits = ["apple", "banana", "cherry"]
>>> x, y, z = fruits
>>> x
"apple"

如果有不需要的值，可以用 _ 标记它们：

>>> fruits = ["apple", "banana", "cherry"]
>>> _, _, z = fruits
>>> z
"cherry"

深层解包

从一个嵌套在 list 或 tuple 内部的 list/tuple（也就是嵌套的 list/tuple）中解包并赋值，与浅层解包的方式相同，但通常需要限定符来明确上下文或位置：

>>> fruits_vegetables = [["apple", "banana"], ["carrot", "potato"]]
>>> [[a, b], [c, d]] = fruits_vegetables
>>> a
"apple"

>>> d
"potato"

你也可以只对嵌套 list/tuple 的一部分进行深层解包：

>>> fruits_vegetables = [["apple", "banana"], ["carrot", "potato"]]
>>> [a, [c, d]] = fruits_vegetables
>>> a
["apple", "banana"]

>>> c
"carrot"

如果解包时变量的位置不正确，或者值的数量不对，就会得到 ValueError：

>>> fruits_vegetables = [["apple", "banana"], ["carrot", "potato"]]
>>> [[a, b], [d]] = fruits_vegetables

ValueError: too many values to unpack (expected 1)

用 * 解包 list/tuple

解包 list/tuple时，可以用 * 运算符捕获“剩余”的值。 这比切片 list/tuple（在某些情况下可读性较差）更清晰。 例如，可以取出第一个元素，然后把剩下的值放进一个不含第一个元素的新 list 中：

>>> fruits = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
>>> x, *last = fruits
>>> x
"apple"

>>> last
["banana", "cherry", "orange", "kiwi", "melon", "mango"]

我们也可以取出 list 开头和结尾的值，同时把中间的所有值归为一组：

>>> fruits = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
>>> x, *middle, y, z = fruits
>>> y
"melon"

>>> middle
["banana", "cherry", "orange", "kiwi"]

我们还可以在深层解包中使用 *：

>>> fruits_vegetables = [["apple", "banana", "melon"], ["carrot", "potato", "tomato"]]
>>> [[a, *rest], b] = fruits_vegetables
>>> a
"apple"

>>> rest
["banana", "melon"]

解包字典

解包字典与解包 list/tuple 稍有不同。 对字典进行迭代时，默认取的是键。 因此解包 dict 时，只能解包键，而不能解包值：

>>> fruits_inventory = {"apple": 6, "banana": 2, "cherry": 3}
>>> x, y, z = fruits_inventory
>>> x
"apple"

如果想解包值，可以使用 <dict>.values() 方法：

>>> fruits_inventory = {"apple": 6, "banana": 2, "cherry": 3}
>>> x, y, z = fruits_inventory.values()
>>> x
6

如果键和值都需要，就使用 <dict>.items() 方法。 <dict>.items() 会生成一个包含键值对的可迭代视图。 这些键值对可以解包到 tuple 中：

>>> fruits_inventory = {"apple": 6, "banana": 2, "cherry": 3}
>>> x, y, z = fruits_inventory.items()
>>> x
("apple", 6)

打包

打包是指把多个值归组到一个赋给变量的 list 中的能力。 当你想要_解包_值、做些修改，再把结果_打包_回一个变量时，这个特性很有用。 它还使得对 2 个或更多 lists/tuples/dicts 执行合并成为可能。

用 * 打包 list/tuple

可以用 * 运算符打包 list/tuple。 这会把所有值打包进一个 list/tuple。

>>> fruits = ("apple", "banana", "cherry")
>>> more_fruits = ["orange", "kiwi", "melon", "mango"]

# fruits and more_fruits are unpacked and then their elements are packed into combined_fruits
>>> combined_fruits = *fruits, *more_fruits

# If there is no * on to the left of the "=" the result is a tuple
>>> combined_fruits
("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")

# If the * operator is used on the left side of "=" the result is a list.
# Note the trailing comma.
>>> *combined_fruits_too, = *fruits, *more_fruits
>>> combined_fruits_too
['apple', 'banana', 'cherry', 'orange', 'kiwi', 'melon', 'mango']

关于在左侧使用 * 的更多背景，参见 PEP 3132。

用 ** 打包字典

打包字典通过使用 ** 运算符来完成。 这会把一个字典中的所有键-值对打包进另一个字典，或者把两个字典合并在一起。

>>> fruits_inventory = {"apple": 6, "banana": 2, "cherry": 3}
>>> more_fruits_inventory = {"orange": 4, "kiwi": 1, "melon": 2, "mango": 3}

# fruits_inventory and more_fruits_inventory are unpacked into key-values pairs and combined.
>>> combined_fruits_inventory = {**fruits_inventory, **more_fruits_inventory}

# then the pairs are packed into combined_fruits_inventory
>>> combined_fruits_inventory
{"apple": 6, "banana": 2, "cherry": 3, "orange": 4, "kiwi": 1, "melon": 2, "mango": 3}

函数中 * 和 ** 的用法

用函数形参打包

当你创建一个接受任意数量实参的函数时，可以在函数定义中使用 *args 或 **kwargs。 *args 用于把任意数量的位置实参（非关键字实参）打包成一个 tuple，而 **kwargs 用于把任意数量的关键字实参打包成一个字典。

*args 的用法：

# This function is defined to take any number of positional arguments

>>> def my_function(*args):
...     print(args)

# Arguments given to the function are packed into a tuple

>>> my_function(1, 2, 3)
(1, 2, 3)

>>> my_function("Hello")
("Hello")

>>> my_function(1, 2, 3, "Hello", "Mars")
(1, 2, 3, "Hello", "Mars")

**kwargs 的用法：

# This function is defined to take any number of keyword arguments

>>> def my_function(**kwargs):
...   print(kwargs)

# Arguments given to the function are packed into a dictionary

>>> my_function(a=1, b=2, c=3)
{"a": 1, "b": 2, "c": 3}

*args 和 **kwargs 也可以互相结合使用：

>>> def my_function(*args, **kwargs):
...   print(sum(args))
...   for key, value in kwargs.items():
...       print(str(key) + " = " + str(value))

>>> my_function(1, 2, 3, a=1, b=2, c=3)
6
a = 1
b = 2
c = 3

你也可以在 *args 之前写形参，以支持特定的位置实参。 这样一来，单独的关键字实参就必须出现在 **kwargs 之前。

>>> def my_function(a, b, *args):
...   print(a)
...   print(b)
...   print(args)

>>> my_function(1, 2, 3, 4, 5)
1
2
(3, 4, 5)

按错误的顺序写实参会导致错误：

>>>def my_function(*args, a, b):
... print(args)

>>>my_function(1, 2, 3, 4, 5)
Traceback (most recent call last):
  File "c:\something.py", line 3, in <module>
    my_function(1, 2, 3, 4, 5)
TypeError: my_function() missing 2 required keyword-only arguments: 'a' and 'b'

解包到函数调用中

你可以用 * 把 list/tuple 中的实参解包到函数调用中。 这对不接受 iterable 的函数非常有用：

>>> def my_function(a, b, c):
...   print(c)
...   print(b)
...   print(a)

numbers = [1, 2, 3]
>>> my_function(*numbers)
3
2
1

把 * 解包与内置函数 zip() 一起使用是另一个常见用例。 zip() 函数接收多个可迭代对象，并返回一个由 tuples 组成的 list，其中把每个 iterable 中的值归为一组：

>>> values = (['x', 'y', 'z'], [1, 2, 3], [True, False, True])
>>> a, *rest = zip(*values)
>>> rest
[('y', 2, False), ('z', 3, True)]