Розпакування, розширене розпакування та вкладене розширене розпакування

Розглянемо наступні вирази. Зауважте, що деякі вирази повторюються, щоб представити "контекст".

(це довгий список)

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

Як правильно вивести результат таких виразів вручну?

Вибачте за тривалість цієї публікації, але я вирішив обрати повноту.

Коли ви знаєте кілька основних правил, їх важко узагальнити. Я зроблю все можливе, щоб пояснити на кількох прикладах. Оскільки ви говорите про оцінку "вручну", я запропоную кілька простих правил заміни. В основному, вам може бути легше зрозуміти вираз, якщо всі ітерабелі відформатовані однаково.

Для розпакування лише цілі заміни праворуч =(тобто для значень 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.

Lvalues , як (*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 

Тепер для гніздування. Насправді цього прикладу не було у вашому розділі "НАДАЛЕНО"; можливо ви не усвідомлювали, що це вкладено?

(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))але цього не робите .

Я думаю, ваш код може ввести в оману, використовуйте іншу форму, щоб висловити його.

Це як використовувати додаткові дужки у виразах, щоб уникнути питань щодо переваги операторів. Я завжди хороша інвестиція, щоб зробити ваш код читабельним.

Я вважаю за краще використовувати розпакування тільки для простих завдань, таких як своп.