解包、扩展解包和嵌套扩展解包

Question

考虑以下表达式。请注意，为了呈现“上下文”，有些表达式会重复出现。

（这是一个很长的列表）

a, b = 1, 2                          # simple sequence assignment
a, b = ['green', 'blue']             # list asqignment
a, b = 'XY'                          # string assignment
a, b = range(1,5,2)                  # any iterable will do


                                     # nested sequence assignment

(a,b), c = "XY", "Z"                 # a = 'X', b = 'Y', c = 'Z' 

(a,b), c = "XYZ"                     # ERROR -- too many values to unpack
(a,b), c = "XY"                      # ERROR -- need more than 1 value to unpack

(a,b), c, = [1,2],'this'             # a = '1', b = '2', c = 'this'
(a,b), (c,) = [1,2],'this'           # ERROR -- too many values to unpack


                                     # extended sequence unpacking

a, *b = 1,2,3,4,5                    # a = 1, b = [2,3,4,5]
*a, b = 1,2,3,4,5                    # a = [1,2,3,4], b = 5
a, *b, c = 1,2,3,4,5                 # a = 1, b = [2,3,4], c = 5

a, *b = 'X'                          # a = 'X', b = []
*a, b = 'X'                          # a = [], b = 'X'
a, *b, c = "XY"                      # a = 'X', b = [], c = 'Y'
a, *b, c = "X...Y"                   # a = 'X', b = ['.','.','.'], c = 'Y'

a, b, *c = 1,2,3                     # a = 1, b = 2, c = [3]
a, b, c, *d = 1,2,3                  # a = 1, b = 2, c = 3, d = []

a, *b, c, *d = 1,2,3,4,5             # ERROR -- two starred expressions in assignment

(a,b), c = [1,2],'this'              # a = '1', b = '2', c = 'this'
(a,b), *c = [1,2],'this'             # a = '1', b = '2', c = ['this']

(a,b), c, *d = [1,2],'this'          # a = '1', b = '2', c = 'this', d = []
(a,b), *c, d = [1,2],'this'          # a = '1', b = '2', c = [], d = 'this'

(a,b), (c, *d) = [1,2],'this'        # a = '1', b = '2', c = 't', d = ['h', 'i', 's']

*a = 1                               # ERROR -- target must be in a list or tuple
*a = (1,2)                           # ERROR -- target must be in a list or tuple
*a, = (1,2)                          # a = [1,2]
*a, = 1                              # ERROR -- 'int' object is not iterable
*a, = [1]                            # a = [1]
*a = [1]                             # ERROR -- target must be in a list or tuple
*a, = (1,)                           # a = [1]
*a, = (1)                            # ERROR -- 'int' object is not iterable

*a, b = [1]                          # a = [], b = 1
*a, b = (1,)                         # a = [], b = 1

(a,b),c = 1,2,3                      # ERROR -- too many values to unpack
(a,b), *c = 1,2,3                    # ERROR - 'int' object is not iterable
(a,b), *c = 'XY', 2, 3               # a = 'X', b = 'Y', c = [2,3]


                                     # extended sequence unpacking -- NESTED

(a,b),c = 1,2,3                      # ERROR -- too many values to unpack
*(a,b), c = 1,2,3                    # a = 1, b = 2, c = 3

*(a,b) = 1,2                         # ERROR -- target must be in a list or tuple
*(a,b), = 1,2                        # a = 1, b = 2

*(a,b) = 'XY'                        # ERROR -- target must be in a list or tuple
*(a,b), = 'XY'                       # a = 'X', b = 'Y'

*(a, b) = 'this'                     # ERROR -- target must be in a list or tuple
*(a, b), = 'this'                    # ERROR -- too many values to unpack
*(a, *b), = 'this'                   # a = 't', b = ['h', 'i', 's']

*(a, *b), c = 'this'                 # a = 't', b = ['h', 'i'], c = 's'

*(a,*b), = 1,2,3,3,4,5,6,7           # a = 1, b = [2, 3, 3, 4, 5, 6, 7]

*(a,*b), *c = 1,2,3,3,4,5,6,7        # ERROR -- two starred expressions in assignment
*(a,*b), (*c,) = 1,2,3,3,4,5,6,7     # ERROR -- 'int' object is not iterable
*(a,*b), c = 1,2,3,3,4,5,6,7         # a = 1, b = [2, 3, 3, 4, 5, 6], c = 7
*(a,*b), (*c,) = 1,2,3,4,5,'XY'      # a = 1, b = [2, 3, 4, 5], c = ['X', 'Y']

*(a,*b), c, d = 1,2,3,3,4,5,6,7      # a = 1, b = [2, 3, 3, 4, 5], c = 6, d = 7
*(a,*b), (c, d) = 1,2,3,3,4,5,6,7    # ERROR -- 'int' object is not iterable
*(a,*b), (*c, d) = 1,2,3,3,4,5,6,7   # ERROR -- 'int' object is not iterable
*(a,*b), *(c, d) = 1,2,3,3,4,5,6,7   # ERROR -- two starred expressions in assignment


*(a,b), c = 'XY', 3                  # ERROR -- need more than 1 value to unpack
*(*a,b), c = 'XY', 3                 # a = [], b = 'XY', c = 3
(a,b), c = 'XY', 3                   # a = 'X', b = 'Y', c = 3

*(a,b), c = 'XY', 3, 4               # a = 'XY', b = 3, c = 4
*(*a,b), c = 'XY', 3, 4              # a = ['XY'], b = 3, c = 4
(a,b), c = 'XY', 3, 4                # ERROR -- too many values to unpack

如何手动正确推导这些表达式的结果？

- treecoder

---

老实说，大部分情况下这些内容比你日常代码中看到的要复杂得多。学习解包列表/元组的基础知识就可以了。 - Rafe Kettler

注意这些是递归的。因此，如果您理解前几个，您就可以处理所有内容。尝试将*( a, b)替换为x，找出x的展开方式，然后将(*a, b)插回x中，以此类推。 - Peteris

我认为自己对Python有高级了解，只知道一般规则 :) 你不必了解每个角落的情况，只需有时启动解释器并测试一些东西即可。 - Rafe Kettler

哇，太棒了。我真的不知道 a, *b = 1, 2, 3 这种解包方式。但这是 Py3k 对吧？ - Niklas R

Answer 1

很抱歉这篇文章有点长，但我决定全面而详细地讲述。

一旦你掌握了一些基本规则，就不难推广它们。我将尽力通过几个例子来解释。由于你要手动评估这些内容，我建议使用一些简单的替换规则。基本上，如果所有可迭代对象都采用相同的格式进行排列，那么你可能会发现更容易理解表达式。

仅用于展开目的的，以下替换在等号=右侧（即rvalues）是有效的：

'XY' -> ('X', 'Y')
['X', 'Y'] -> ('X', 'Y')

如果您发现某个值没有被解包，那么您需要撤销替换操作。（有关更多详细说明，请参见下文。）

此外，当您看到“裸露”的逗号时，请假装有一个顶级元组。这应该在左侧和右侧（即对于左值和右值）都要做。

'X', 'Y' -> ('X', 'Y')
a, b -> (a, b)

考虑到这些简单的规则，以下是一些例子：

(a,b), c = "XY", "Z"                 # a = 'X', b = 'Y', c = 'Z'

应用上述规则，我们将 "XY" 转换成 ('X', 'Y')，并且在括号中覆盖裸露的逗号。

((a, b), c) = (('X', 'Y'), 'Z')

这里的视觉对应关系很明显，它使得赋值操作的工作方式变得相当明显。

这是一个错误的例子：

(a,b), c = "XYZ"

根据上述替换规则，我们得到以下结果：

((a, b), c) = ('X', 'Y', 'Z')

这显然是错误的，嵌套结构不匹配。现在让我们看一个稍微复杂一些的例子：

(a,b), c, = [1,2],'this'             # a = '1', b = '2', c = 'this'

应用上述规则，我们得到：

((a, b), c) = ((1, 2), ('t', 'h', 'i', 's'))

但是现在从结构上来看，'this'不会被解包，而是直接赋值给c。因此我们撤销了替换。

((a, b), c) = ((1, 2), 'this')

现在让我们看看当我们将c装入元组中会发生什么：

(a,b), (c,) = [1,2],'this'           # ERROR -- too many values to unpack

变成

((a, b), (c,)) = ((1, 2), ('t', 'h', 'i', 's'))

再次强调，错误很明显。变量c不再是裸变量，而是一个序列内的变量，因此右侧对应的序列被解包为(c,)。但是这些序列长度不同，所以会出现错误。

现在讲一下使用*运算符进行扩展解包。这有点复杂，但仍然相当简单。由*前缀的变量变成列表，其中包含未分配给变量名的相应序列中的任何项目。从一个相当简单的例子开始：

a, *b, c = "X...Y"                   # a = 'X', b = ['.','.','.'], c = 'Y'

这将变成

(a, *b, c) = ('X', '.', '.', '.', 'Y')

这个问题最简单的分析方法是从两端入手。将 'X' 赋给 a，将 'Y' 赋给 c。剩余的值放在一个列表中，并赋给 b。

像 (*a, b) 和 (a, *b) 这样的 Lvalue 只是上述情况的特例。你不能在一个 Lvalue 序列中有两个 * 操作符，因为那会产生歧义。在 (a, *b, *c, d) 这样的情况下，值会被放在哪里呢？是在 b 还是在 c 中？稍后我会考虑嵌套的情况。

*a = 1                               # ERROR -- target must be in a list or tuple

这里的错误相当明显。目标（*a）必须在一个元组中。

*a, = (1,2)                          # a = [1,2]

这是因为有一个裸逗号，所以才能生效。应用规则...

(*a,) = (1, 2)

由于除了*a之外没有其他变量，因此*a会吞掉rvalue序列中的所有值。如果您用单个值替换(1, 2)会怎样呢？

*a, = 1                              # ERROR -- 'int' object is not iterable

变成

(*a,) = 1

这里的错误很明显。你无法解包一个不是序列的东西，而*a需要解包的对象必须是一个序列。因此，我们将其放入一个序列中。

*a, = [1]                            # a = [1]

这相当于

(*a,) = (1,)

最后，这是一个常见的困惑点：(1)和1是相同的--你需要一个逗号来区分元组和算术语句。

*a, = (1)                            # ERROR -- 'int' object is not 

现在来谈嵌套。实际上，这个例子并不在你的“嵌套”部分中；也许你没有意识到它是嵌套的？

(a,b), *c = 'XY', 2, 3               # a = 'X', b = 'Y', c = [2,3]

变成

((a, b), *c) = (('X', 'Y'), 2, 3)

顶层元组中的第一个值被分配，而顶层元组中剩余的值 (2 和 3) 被分配给 c -- 这正是我们所期望的。

(a,b),c = 1,2,3                      # ERROR -- too many values to unpack
*(a,b), c = 1,2,3                    # a = 1, b = 2, c = 3

我已经在上面解释了为什么第一行会出错。第二行看起来很傻，但是它能够工作的原因如下：

(*(a, b), c) = (1, 2, 3)

如之前所述，我们从末尾开始处理。 3 被分配给变量 c，然后其余的值被分配给带有 * 的变量，在这种情况下是 (a, b)。因此，这等同于 (a, b) = (1, 2)，这恰好有效，因为元素数量正确。我想不出任何理由，这会在实际代码中出现。类似地，

*(a, *b), c = 'this'                 # a = 't', b = ['h', 'i'], c = 's'

变成

(*(a, *b), c) = ('t', 'h', 'i', 's')

从结尾开始，'s' 被赋值给 c，('t', 'h', 'i') 被作为一个元组赋值给 (a, *b)。再次从结尾开始，'t' 被赋值给 a，('h', 'i') 以列表形式被赋值给 b。这是另一个愚蠢的例子，不应该出现在工作代码中。

- senderle

---

由于原帖提供了大量例子，因此您需要提供一长串的解释，以配合原帖。 - John Y

非常好的解释，我刚开始学习Python，但这让很多事情变得清晰了。 - Itope84

如果在变量前面加上 * 就可以将其转换为列表，那么为什么在以下语句中裸逗号是必需的 *b, = '...'？ - Quazi Irfan

此外，在给函数参数赋值时，上述解释是否有任何不同？ - Quazi Irfan

Answer 2

我认为Python 2中的元组解包非常简单。左边的每个名称对应右边序列中的整个序列或单个项目。如果名称对应于任何序列的单个项目，则必须有足够的名称来覆盖所有项目。

然而，扩展解包可能会让人感到困惑，因为它非常强大。事实上，您不应该执行您提供的最后10个或更多个有效示例--如果数据是那么结构化的话，它应该是一个字典或类实例，而不是像列表这样的非结构化形式。

显然，新语法可以被滥用。回答你的问题是，你不应该阅读那样的表达式--它们是不好的实践，我怀疑它们会被使用。

仅仅因为你可以编写任意复杂的表达式并不意味着你应该这样做。你可以编写像map(map, iterable_of_transformations, map(map, iterable_of_transformations, iterable_of_iterables_of_iterables))这样的代码，但你不应该这样做。

- agf

---

注意：我写过类似的代码，只不过比这个复杂几个层次。这只是为了练习而已，我完全知道三个月后它对我来说毫无意义，而且它永远不会被任何人理解。如果我没记错的话，它实现了点在多边形内的测试，进行了一些坐标转换，并创建了一些SVG、HTML和JavaScript。 - agf

Answer 3

如果你认为你的代码可能会误导他人，请使用其他形式表达它。

这就像在表达式中使用额外的括号来避免有关运算符优先级的问题。使你的代码易读永远是一项好的投资。

我更喜欢仅将解包用于简单任务，如交换。

- Michał Šrajer

Answer 4

星号表达式在左侧的最初想法是改进可迭代对象拆包的可读性，如下所示：

first_param, rest_param, third_param = param[0], param[1:-1], param[-1]

这句话的意思是等同于：

first_param, *rest_param, third_param = param

在上述语句中，星号表达式用于“捕获”所有未分配给“强制目标”（本例中的first_param和third_param）的元素。 lhs处使用星号表达式有以下规则：

1. lhs处最多只能有一个星号表达式，否则解包将不是唯一的。

*a,b,*c = range(5) # wrong
*a,b,c = range(5) # right
a,*b,c = range(5) # right

为了收集“rest”元素，必须使用带有强制目标的星号表达式。尾随逗号用于表示不存在强制目标。

*a = range(5) # wrong
*a, = range(5) # right

我相信如果你掌握了这两个规则，就能推导出左侧星号表达式的任何结果。

- Karuse Tang