解包、擴展解包和嵌套擴展解包

Question

考慮以下表達式。 請注意，某些表達式被重復以呈現“上下文”。

（這是一個很長的清單）

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

如何手動正確推導出此類表達式的結果？

Answer 1

對於這篇文章的長度，我深表歉意，但我決定選擇完整性。

一旦你知道了一些基本規則，就不難概括它們。 我會盡力用幾個例子來解釋。 由於您正在談論“手動”評估這些，我將建議一些簡單的替換規則。 基本上，如果所有可迭代對象的格式都相同，您可能會發現更容易理解表達式。

僅出於解包的目的，以下替換在=的右側有效（即對於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') ，並覆蓋括號中的裸逗號：

((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 作為列表。 這是另一個不應出現在工作代碼中的愚蠢示例。

Answer 2

我發現 Python 2 元組的解包非常簡單。 左側的每個名稱對應於整個序列或右側序列中的單個項目。 如果名稱對應於任何序列的單個項目，則必須有足夠的名稱來覆蓋所有項目。

然而，擴展解包肯定會令人困惑，因為它非常強大。 現實情況是，你永遠不應該做你給出的最后 10 個或更多有效示例——如果數據是結構化的，它應該在dict或類實例中，而不是像列表這樣的非結構化形式。

顯然，新語法可能會被濫用。 你的問題的答案是你不應該閱讀這樣的表達——它們是不好的做法，我懷疑它們會被使用。

僅僅因為您可以編寫任意復雜的表達式並不意味着您應該這樣做。 你可以寫像map(map, iterable_of_transformations, map(map, iterable_of_transformations, iterable_of_iterables_of_iterables))但你沒有。

Answer 3

我你認為你的代碼可能會誤導使用其他形式來表達它。

這就像在表達式中使用額外的括號來避免有關運算符優先級的問題。 我並不總是讓你的代碼可讀的好投資。

我更喜歡僅對交換等簡單任務使用解包。

Answer 4

lhs的starred表達式的初衷是為了提高iterable解包的可讀性，如下：

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

2. 為了收集“rest”元素，必須將帶星號的表達式與強制目標一起使用。 尾隨逗號用於表示強制目標不存在

*a = range(5) # wrong
*a, = range(5) # right

我相信如果你掌握了這兩個規則，你可以在 lhs 上推斷出任何加星表達式的結果。