考虑一下这些表达方式......请耐心等待...这是一个很长的清单......
(注意:重复一些表达式 - 这只是为了呈现“上下文”)
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
你如何理解这种复杂性和混乱 . 在手动计算这些表达式的结果时,如何总是正确的 . 或者,在阅读别人的代码时,我应该忽略它们,而不是试图理解表达式实际上在做什么吗?
3 回答
我对这篇文章的篇幅感到抱歉,但我决定选择完整性 .
一旦你了解了一些基本规则,就不难概括它们 . 我会尽力用一些例子来解释 . 既然你正在谈论“手动”评估这些,我会建议一些简单的替换规则 . 基本上,如果所有迭代都以相同的方式格式化,您可能会发现理解表达式更容易 .
仅出于解包的目的,以下替换在
=
的右侧有效(即对于rvalues):如果您发现某个值未解压缩,那么您将撤消替换 . (有关详细说明,请参见下文 . )
此外,当你看到"naked"逗号时,假装有一个顶级元组 . 在左侧和右侧执行此操作(即对于左值和右值):
考虑到这些简单的规则,这里有一些例子:
应用上述规则,我们将
"XY"
转换为('X', 'Y')
,并覆盖parens中的裸逗号:这里的视觉对应使得任务的工作方式非常明显 .
这是一个错误的例子:
按照上述替换规则,我们得到以下内容:
这显然是错误的;嵌套结构不匹配 . 现在让我们看看它如何适用于一个稍微复杂的例子:
应用上述规则,我们得到
但现在从结构中可以清楚地看出
'this'
不会被解压缩,而是直接分配给c
. 所以我们撤消替换 .现在让我们看看当我们在一个元组中包装
c
时会发生什么:变
同样,错误是显而易见的 .
c
不再是裸变量,而是序列中的变量,因此右侧的相应序列被解压缩到(c,)
中 . 但序列的长度不同,因此存在错误 .现在使用
*
运算符进行扩展解包 . 这有点复杂,但它仍然相当简单 . 以*
开头的变量将成为一个列表,其中包含未分配给变量名的相应序列中的任何项 . 从一个相当简单的例子开始:这变成了
分析这个的最简单方法是从最终开始工作 .
'X'
分配给a
,'Y'
分配给c
. 序列中的其余值将放入列表中并分配给b
.像
(*a, b)
和(a, *b)
这样的左值只是上述特例 . 在一个左值序列中不能有两个*
运算符,因为它不明确 . Value 会在哪里(a, *b, *c, d)
- 在b
或c
?我马上就会考虑嵌套的情况 .这里的错误是相当不言自明的 . 目标(
*a
)必须位于元组中 .这是有效的,因为有一个裸露的逗号 . 应用规则......
由于除了
*a
之外没有其他变量,*a
会覆盖右值序列中的所有值 . 如果用单个值替换(1, 2)
怎么办?变
同样,这里的错误是不言自明的 . 您可以't unpack something that isn' t序列,
*a
需要解压缩 . 所以我们把它按顺序排列哪个是等价的
最后,这是一个常见的混淆点:
(1)
与1
相同 - 您需要一个逗号来区分元组和算术语句 .现在进行嵌套 . 实际上这个例子不在你的“NESTED”部分;也许你没有意识到它是嵌套的?
变
顶级元组中的第一个值被分配,顶级元组中的剩余值(
2
和3
)被分配给c
- 正如我们所期望的那样 .我已经解释了为什么第一行会抛出错误 . 第二行很傻这就是它的工作原理:
如前所述,我们从最终开始工作 .
3
分配给c
,然后将剩余的值分配给前面带有*
的变量,在本例中为(a, b)
. 所以这相当于(a, b) = (1, 2)
,这恰好有效,因为有合适数量的元素 . 我想不出有任何理由会出现在工作代码中 . 同样的,变
从末尾开始,
's'
分配给c
,('t', 'h', 'i')
分配给(a, *b)
. 再次从末尾开始,'t'
被分配给a
,('h', 'i')
被分配给b作为列表 . 这是另一个不应该出现在工作代码中的愚蠢示例 .我发现Python 2元组拆包非常简单 . 左侧的每个名称对应于整个序列或右侧序列中的单个项目 . 如果名称对应于任何序列的单个项目,则必须有足够的名称来涵盖所有项目 .
然而,扩展拆包肯定会令人困惑,因为它非常强大 . 实际情况是你永远不应该做你给出的最后10个或更多有效的例子 - 如果数据是结构化的,它应该在
dict
或类实例中,而不是像列表那样的非结构化形式 .显然,新语法可能被滥用 . 你的问题的答案是,你不应该阅读这样的表达 - 他们将被使用're bad practice and I doubt they' .
仅仅因为你可以编写任意复杂的表达式并不意味着你应该这样做 . 您可以编写类似
map(map, iterable_of_transformations, map(map, iterable_of_transformations, iterable_of_iterables_of_iterables))
的代码但是 don't .我认为您的代码可能会误导使用其他形式来表达它 .
这就像在表达式中使用额外的括号来避免运算符优先级的问题 . 为了使您的代码可读,我总是一项很好的投资 .
我更喜欢只使用swap这样的简单任务来解压缩 .