解包装，扩展解包装和嵌套扩展解包装

考虑下面的表达式。注意，有些表达式是重复出现的“上下文”。

(这是一个很长的名单)

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

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

43332 次浏览
小开

我认为你的代码可能是误导使用其他形式来表达它。

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

我喜欢只对交换之类的简单任务使用解压缩。

小开

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

然而，扩展解包肯定会令人困惑，因为它是如此强大。实际上，您不应该执行您给出的最后10个或更多的有效示例——如果数据是那种结构化的，那么它应该在 dict或类实例中，而不是像列表这样的非结构化表单中。

显然，新语法可能会被滥用。你的问题的答案是，你必须阅读这样的表达式-他们是不好的做法，我怀疑他们将使用。

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

小开
最佳答案

我为这篇文章的长度感到抱歉，但我决定选择完整性。

一旦你知道了一些基本规则，就不难推广它们。我将尽力用几个例子来解释。既然您谈到了“手工”评估这些问题，那么我将提出一些简单的替换规则。基本上，如果所有可迭代文件都以相同的方式格式化，您可能会发现理解表达式更容易。

为了便于拆箱，以下替代品在 =的右侧有效(即 Rvalue) :

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

如果您发现某个值没有被解压缩，那么您将撤消替换

另外，当你看到“裸”逗号时，假设有一个顶级元组。在左侧和右侧(即 价值观和 Rvalue)这样做:

'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会快速处理 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

现在来看嵌套。实际上，这个示例不在您的“ 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。这是另一个不应该出现在工作代码中的愚蠢示例。

小开

在 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 中使用带星号的表达式有以下规则:

  1. 在 lhs 上最多只有一个带星号的表达式，否则解包将不是唯一的
*a,b,*c = range(5) # wrong
*a,b,c = range(5) # right
a,*b,c = range(5) # right
  1. 为了收集“ rest”元素，必须将带星号的表达式与强制目标一起使用。后面的逗号用于表示不存在强制目标
*a = range(5) # wrong
*a, = range(5) # right

我相信如果你掌握了这两条规则，你就可以推断出任何在 lhs 处的星状表达式的结果。


提交答案