解包,扩展解包和嵌套扩展解包
考虑这些表达式...请耐心等待...这是一个很长的名单...
(注意:一些表达式重复 - 这只是为了展示一个“上下文”)
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
你如何理解这种复杂性和混乱。 手工计算这些表达式的结果时如何总是正确。 或者,在阅读别人的代码时,我是否应该忽略它们,从不尝试去理解表达实际上在做什么?
我对这篇文章的长度表示歉意,但我决定选择完整性。
一旦你知道了一些基本规则,就不难概括它们。 我会尽我所能解释一些例子。 既然你说的是“手工评估”,我会提出一些简单的替代规则。 基本上,如果所有迭代器都以相同的方式进行格式化,则可能会更容易理解表达式。
仅为解包目的,以下替换在=
的右侧(即对于右值)是有效的:
'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')
,并覆盖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作为列表。 这是另一个愚蠢的例子,应该永远不会出现在工作代码中。
我发现Python 2元组解开相当简单。 左侧的每个名称对应于右侧序列中的整个序列或单个项目。 如果名称对应于任何序列的单个项目,则必须有足够的名称来覆盖所有项目。
然而,扩展拆包肯定会让人困惑,因为它非常强大。 现实情况是,你永远不应该做最后10个或更多有效的例子 - 如果数据是结构化的,它应该是dict
或类实例,而不是像列表那样的非结构化表单。
显然,新的语法可能会被滥用。 你的问题的答案是你不应该阅读这样的表达 - 他们是不好的做法,我怀疑他们会被使用。
仅仅因为你可以任意写出复杂的表达式并不意味着你应该这样做。 你可以编写像map(map, iterable_of_transformations, map(map, iterable_of_transformations, iterable_of_iterables_of_iterables))
这样的代码map(map, iterable_of_transformations, map(map, iterable_of_transformations, iterable_of_iterables_of_iterables))
但是你不能 。
我认为你的代码可能会误导用其他形式来表达它。
这就像在表达式中使用额外的括号来避免关于运算符优先级的问题。 我总是一个很好的投资,让你的代码可读。
我更喜欢使用解压仅用于简单的任务,如交换。
链接地址: http://www.djcxy.com/p/1567.html上一篇: Unpacking, extended unpacking, and nested extended unpacking