Распаковка, расширенная распаковка и вложенная расширенная распаковка

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.

L-значения, такие как (*a, b) и (a, *b), являются лишь частными случаями из вышеперечисленного.Вы не можете иметь два * оператора внутри одной последовательности lvalue, потому что это было бы неоднозначно.Куда бы значения пошли примерно так: (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 в виде списка. Это еще один глупый пример, который никогда не должен появляться в рабочем коде.

Answer 2

Я считаю, что кортеж Python 2 распаковывается довольно просто. Каждое имя слева соответствует либо всей последовательности, либо одному элементу в последовательности справа. Если имена соответствуют отдельным элементам любой последовательности, тогда должно быть достаточно имен, чтобы охватить все элементы.

Расширенная распаковка, однако, может сбить с толку, потому что она очень мощная. Реальность такова, что вы никогда не должны делать последние 10 или более правильных примеров, которые вы дали - если данные структурированы, они должны быть в dict или экземпляре класса, а не в неструктурированных формах, таких как списки.

Понятно, что новым синтаксисом можно злоупотреблять. Ответ на ваш вопрос заключается в том, что вы не должны читать такие выражения - это плохая практика, и я сомневаюсь, что они будут использованы.

То, что вы можете писать произвольно сложные выражения, не означает, что вы должны это делать. Вы могли бы написать код вроде map(map, iterable_of_transformations, map(map, iterable_of_transformations, iterable_of_iterables_of_iterables)), но вы не .

Answer 3

Если вы считаете, что ваш код может вводить в заблуждение, используйте другую форму для его выражения.

Это похоже на использование дополнительных выражений в выражениях, чтобы избежать вопросов о приоритете операторов.Я всегда делаю хорошие инвестиции, чтобы сделать ваш код читабельным.

Я предпочитаю использовать распаковку только для простых задач, таких как swap.