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

Posted 2023-02-16

【中文标题】解包、扩展解包和嵌套扩展解包

【英文标题】：Unpacking, extended unpacking and nested extended unpacking

【发布时间】：2011-10-21 12:15:31

【问题描述】：

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

（这是一个很长的列表）

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

如何手动正确推导出此类表达式的结果？

【问题讨论】：

老实说，其中大多数都比您每天在代码中看到的要复杂得多。学习解包列表/元组的基础知识，你会没事的。

请注意，这些是递归的。所以，如果你理解了前几个，你就可以处理所有事情。尝试将 *( *a, b) 替换为 *x，找出 x 解包的内容，然后将 (*a, b) 重新插入 x 等。

@greengit 我认为自己对 Python 有深入的了解，我只知道一般规则 :) 你不必知道每一个极端情况，你只是有时需要启动一个解释器然后测试一些东西。

很棒的清单。我真的不知道a, *b = 1, 2, 3 那种拆包。但这是 Py3k 对吧？

【参考方案1】：

我认为您的代码可能具有误导性，请使用其他形式来表达它。

这就像在表达式中使用额外的括号来避免有关运算符优先级的问题。 让您的代码具有可读性始终是一项不错的投资。

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

【参考方案2】：

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

然而，扩展解包肯定会令人困惑，因为它是如此强大。现实情况是，您永远不应该做您给出的最后 10 个或更多有效示例 - 如果数据是结构化的，它应该在 dict 或类实例中，而不是像列表这样的非结构化形式。

显然，新语法可能会被滥用。您的问题的答案是您不应该必须阅读这样的表达方式——它们是不好的做法，我怀疑它们会被使用。

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

【讨论】：

注意：我写过类似的代码，除了几个更复杂的级别。它只是作为一个练习，并且完全知道三个月后它对我来说毫无意义，而且它永远不会被其他任何人理解。如果我没记错的话，它实现了多边形测试中的点，进行了一些坐标变换，并制作了一些 SVG、html 和 javascript。

【参考方案3】：

对于这篇文章的篇幅深表歉意，但我决定选择完整性。

一旦您了解了一些基本规则，就不难概括它们。我会尽力用几个例子来解释。由于您正在谈论“手动”评估这些，我将建议一些简单的替换规则。基本上，如果所有可迭代对象的格式都相同，您可能会发现更容易理解表达式。

仅出于解包的目的，= 右侧的以下替换有效（即对于 rvalues）：

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

如果您发现某个值没有被解包，那么您将撤消替换。 （更多解释见下文。）

另外，当您看到“裸”逗号时，假装有一个***元组。在左侧和右侧执行此操作（即对于 lvalues 和 rvalues）：

'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) 这样的左值只是上述情况的特例。一个左值序列中不能有两个 * 运算符，因为它会模棱两可。像(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 会吞噬右值序列中的所有值。如果将(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。这是另一个不应该出现在工作代码中的愚蠢示例。

【讨论】：

既然 OP 给出了一长串示例，那么你给出一长串解释是合适的。

【参考方案4】：

lhs 加星号的初衷是为了提高可迭代解包的可读性，如下：

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 使用星号表达式有以下规则：

在 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

我相信如果你掌握了这两条规则，你可以在lhs处推导出任何加星表示的结果。