拆包、扩展拆包和嵌套扩展拆包
考虑以下表达式。请注意，一些表达式被重复来表示“上下文”。
(这是一个很长的列表)
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如何用手正确地推导出这样的表达式的结果？
回答 4
Stack Overflow用户
发布于 2011-08-07 01:30:57
很抱歉这篇文章太长了，但我决定选择完整。
一旦你知道了一些基本规则，就不难推广它们了。我将尽我所能用几个例子来解释。既然您正在谈论“手动”评估这些，我将建议一些简单的替换规则。基本上，如果所有的可迭代变量都以相同的方式格式化，您可能会发现更容易理解一个表达式。
仅出于解包的目的，以下替换在=的右侧有效(即对于右值)：
'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只是上面的特例。在一个左值序列中不能有两个*操作符，因为它是不明确的。在这样的(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。这是另一个愚蠢的例子，永远不应该出现在工作代码中。
Stack Overflow用户
发布于 2011-08-06 23:13:59
我发现解压Python2元组非常简单。左侧的每个名称对应于整个序列或右侧序列中的单个项目。如果名称对应于任何序列的单个项目，则必须有足够的名称来覆盖所有项目。
然而，扩展解包肯定会让人感到困惑，因为它太强大了。实际情况是，您永远不应该重复您给出的最后10个或更多有效示例--如果数据是结构化的，那么它应该在dict或类实例中，而不是像列表这样的非结构化形式。
显然，新语法可能会被滥用。您的问题的答案是，您不应该阅读这样的表达式--它们是糟糕的实践，我怀疑它们是否会被使用。
您可以编写任意复杂的表达式，但这并不意味着您应该这样做。你可以写像map(map, iterable_of_transformations, map(map, iterable_of_transformations, iterable_of_iterables_of_iterables))这样的代码，但是你不。
Stack Overflow用户
发布于 2011-08-06 23:08:05
你认为你的代码可能有误导性，使用其他形式来表达它。
这就像在表达式中使用额外的括号来避免有关运算符优先级的问题。我总是一个很好的投资，使你的代码可读。
我只喜欢使用解包来完成简单的任务，比如交换。
https://stackoverflow.com/questions/6967632
复制相似问题
腾讯云开发者
