考虑这些表达方式......请耐心等待......这是一个很长的清单...
（注意：重复一些表达式 - 这只是为了呈现“上下文”）
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
你如何理解这种复杂性和混乱。在手动计算这些表达式的结果时，如何总是正确的。或者，在阅读别人的代码时，我应该忽略它们，而不是试图理解表达式实际上在做什么吗？
答案 0 :(得分：100)
我对这篇文章的篇幅感到抱歉，但我决定选择完整性。
一旦你了解了一些基本规则，就不难概括它们。我会尽力用一些例子来解释。既然你正在谈论“手动”评估这些，我会建议一些简单的替换规则。基本上，如果所有迭代都以相同的方式格式化，您可能会发现理解表达式更容易。
仅出于解包的目的，以下替换在=的右侧有效（即 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')，并覆盖parens中的裸逗号：
((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
现在进行嵌套。实际上这个例子不在你的“NESTED”部分;也许你没有意识到它是嵌套的？
(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作为列表。这是另一个不应该出现在工作代码中的愚蠢示例。
答案 1 :(得分：7)
我发现Python 2元组拆包非常简单。左侧的每个名称对应于整个序列或右侧序列中的单个项目。如果名称对应于任何序列的单个项目，则必须有足够的名称来涵盖所有项目。
然而，扩展解包可能会让人感到困惑，因为它非常强大。实际情况是你永远不应该做你给出的最后10个或更多有效的例子 - 如果数据是结构化的，它应该在dict或类实例中，而不是像列表这样的非结构化形式。
显然，新语法可能会被滥用。你的问题的答案是你不应该必须阅读这样的表达 - 它们是不好的做法，我怀疑它们会被使用。
仅仅因为你可以写任意复杂的表达并不意味着你应该这样做。您可以编写map(map, iterable_of_transformations, map(map, iterable_of_transformations, iterable_of_iterables_of_iterables))之类的代码，但不。
答案 2 :(得分：3)
我认为您的代码可能会误导使用其他形式来表达它。
这就像在表达式中使用额外的括号来避免运算符优先级的问题。 为了使您的代码可读，我总是一项很好的投资。
我更喜欢仅对像swap这样的简单任务使用解包。
答案 3 :(得分：0)
lhs 的starred 表达式的初衷是为了提高iterable unpacking 的可读性，如下：
first_param, rest_param, third_param = param[0], param[1:-1], param[-1]
此声明等同于
first_param, *rest_param, third_param = param
在上面的语句中，starred 表达式用于“捕获”所有未分配给“强制目标”的元素（在此示例中为 first_param 和 third_param）
在 lhs 处使用带星号的表达式有以下规则：
*a,b,*c = range(5) # wrong
*a,b,c = range(5) # right
a,*b,c = range(5) # right
*a = range(5) # wrong
*a, = range(5) # right
我相信如果你掌握了这两个规则，你可以在 lhs 上推导出任何加星表达式的结果。