Рассмотрим следующие выражения. Обратите внимание, что некоторые выражения повторяются для представления «контекста».
(это длинный список)
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
Как вручную правильно вывести результат таких выражений?
python
python-3.x
iterable-unpacking
argument-unpacking
древокодер
источник
источник
a, *b = 1, 2, 3
распаковывать. Но это же Py3k, верно?Ответы:
Приношу свои извинения за объем этого сообщения, но я решил сделать выбор в пользу полноты.
Зная несколько основных правил, нетрудно их обобщить. Я постараюсь объяснить это на нескольких примерах. Поскольку вы говорите об их оценке «вручную», я предлагаю несколько простых правил замены. В принципе, вам будет легче понять выражение, если все итерации отформатированы одинаково.
Только для целей распаковки в правой части
=
(т.е. для значений r ) действительны следующие замены :Если вы обнаружите, что значение не распаковывается, вы отмените замену. (Подробнее см. Ниже.)
Кроме того, когда вы видите «голые» запятые, представьте, что это кортеж верхнего уровня. Сделайте это как с левой, так и с правой стороны (т.е. для lvalues и rvalues ):
Имея в виду эти простые правила, вот несколько примеров:
Применяя приведенные выше правила, мы конвертируем
"XY"
в('X', 'Y')
и закрываем голые запятые скобками:Визуальное соответствие здесь делает довольно очевидным, как работает задание.
Вот ошибочный пример:
Следуя приведенным выше правилам замены, мы получаем следующее:
Это явно ошибочно; вложенные структуры не совпадают. Теперь давайте посмотрим, как это работает, на более сложном примере:
Применяя указанные выше правила, получаем
Но теперь из структуры понятно, что
'this'
распаковывать не будем, а назначить напрямуюc
. Итак, мы отменяем замену.Теперь посмотрим, что происходит, когда мы оборачиваем
c
кортеж:Становится
Опять же, ошибка очевидна.
c
больше не голая переменная, а переменная внутри последовательности, и поэтому соответствующая последовательность справа распаковывается(c,)
. Но последовательности имеют разную длину, поэтому возникает ошибка.Теперь о расширенной распаковке с помощью
*
оператора. Это немного сложнее, но все же довольно просто. Переменная, которой предшествует,*
становится списком, который содержит любые элементы из соответствующей последовательности, не присвоенные именам переменных. Начнем с довольно простого примера:Это становится
Самый простой способ проанализировать это - работать с концов.
'X'
назначенa
и'Y'
назначенc
. Остальные значения в последовательности заносятся в список и присваиваются имb
.L-значения вроде
(*a, b)
и(a, *b)
являются лишь частным случаем вышеперечисленного. У вас не может быть двух*
операторов внутри одной последовательности lvalue, потому что это было бы неоднозначно. Где бы значения помещались примерно так(a, *b, *c, d)
- вb
илиc
? Я сейчас рассмотрю вложенный случай.Здесь ошибка довольно очевидна. Target (
*a
) должен быть в кортеже.Это работает, потому что есть голая запятая. Применение правил ...
Поскольку нет , кроме переменных
*a
,*a
хлебает все значения в последовательности RValue. Что если вы замените(1, 2)
одно значение?становится
Опять же, ошибка здесь не требует пояснений. Вы не можете распаковать то, что не является последовательностью, и вам
*a
нужно что-то распаковать. Итак, мы поместили это в последовательностьЧто эквивалентно
Наконец, это обычная путаница:
(1)
то же самое, что и1
- вам нужна запятая, чтобы отличить кортеж от арифметического оператора.Теперь о вложении. На самом деле этого примера не было в вашем разделе «ВСТАВЛЕННЫЕ»; возможно, вы не осознавали, что это вложено?
Становится
Присваивается первое значение в кортеже верхнего уровня, а остальные значения в кортеже верхнего уровня (
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
экземпляре класса или класса, а не в неструктурированных формах, таких как списки.Ясно, что новым синтаксисом можно злоупотреблять. Ответ на ваш вопрос заключается в том, что вам не следует читать подобные выражения - это плохая практика, и я сомневаюсь, что они будут использоваться.
То, что вы можете писать произвольно сложные выражения, не означает, что вы должны это делать. Вы могли бы написать такой код,
map(map, iterable_of_transformations, map(map, iterable_of_transformations, iterable_of_iterables_of_iterables))
но вы этого не сделаете .источник
Я думаю, что ваш код может вводить в заблуждение, используйте другую форму для его выражения.
Это похоже на использование дополнительных скобок в выражениях, чтобы избежать вопросов о приоритете операторов. Это всегда хорошее вложение, чтобы сделать ваш код читабельным.
Я предпочитаю использовать распаковку только для простых задач, таких как свопинг.
источник