Розпакування означає вилучення елементів колекції, як-от list, tuple чи dict, за допомогою ітерації.
Розпаковані значення потім можна присвоїти змінним у межах однієї інструкції, що зазвичай називають множинним присвоєнням.
Спеціальні оператори * та ** часто використовують у контексті розпакування та разом із множинним присвоєнням.
*<variable_name> і **<variable_name> не варто плутати з * та **. Якщо * та ** використовують для множення та піднесення до степеня відповідно, то *<variable_name> і **<variable_name> слугують операторами пакування та розпакування.
Множинне присвоєння
У множинному присвоєнні кількість змінних ліворуч від оператора присвоєння (=) має збігатися з кількістю значень праворуч.
Щоб розділити значення, використовуємо кому ,:
>>> a, b = 1, 2
>>> a
1
Якщо у множинному присвоєнні вказано неправильну кількість змінних для наведених значень, виникне ValueError:
>>> x, y, z = 1, 2
ValueError: too many values to unpack (expected 3, got 2)
Множинне присвоєння не обмежується одним типом даних:
>>> x, y, z = 1, "Hello", True
>>> x
1
>>> y
'Hello'
>>> z
True
Множинне присвоєння можна використати, щоб поміняти місцями елементи в lists.
Цей прийом досить поширений в алгоритмах сортування.
Наприклад:
>>> numbers = [1, 2]
>>> numbers[0], numbers[1] = numbers[1], numbers[0]
>>> numbers
[2, 1]
Оскільки tuples незмінні, поміняти місцями елементи в tuple не вдасться.
Розпакування
У прикладах нижче використано lists, але ті самі поняття стосуються й tuples.
У Python можна розпакувати елементи list/tuple/dictionary в окремі змінні.
Оскільки значення в lists/tuples мають певний порядок, їх розпаковують у змінні в тому самому порядку:
>>> fruits = ["apple", "banana", "cherry"]
>>> x, y, z = fruits
>>> x
"apple"
Якщо якісь значення не потрібні, їх можна позначити символом _:
>>> fruits = ["apple", "banana", "cherry"]
>>> _, _, z = fruits
>>> z
"cherry"
Глибоке розпакування
Розпакування й присвоєння значень із list/tuple, вкладеного в list або tuple (які ще називають вкладеними масивами/кортежами), працює так само, як і поверхневе розпакування, але часто потребує уточнень, щоб прояснити контекст або позицію:
>>> fruits_vegetables = [["apple", "banana"], ["carrot", "potato"]]
>>> [[a, b], [c, d]] = fruits_vegetables
>>> a
"apple"
>>> d
"potato"
Можна також глибоко розпакувати лише частину вкладеного list/tuple:
>>> fruits_vegetables = [["apple", "banana"], ["carrot", "potato"]]
>>> [a, [c, d]] = fruits_vegetables
>>> a
["apple", "banana"]
>>> c
"carrot"
Якщо під час розпакування змінні розташовані неправильно та/або кількість значень неправильна, виникне ValueError:
>>> fruits_vegetables = [["apple", "banana"], ["carrot", "potato"]]
>>> [[a, b], [d]] = fruits_vegetables
ValueError: too many values to unpack (expected 1)
Розпакування list/tuple за допомогою *
Коли ми розпаковуємо list/tuple, можна використати оператор *, щоб захопити «залишкові» значення.
Це зрозуміліше, ніж робити зріз list/tuple (що в деяких ситуаціях менш читабельно).
Наприклад, можна вилучити перший елемент, а потім помістити решту значень у новий list без першого елемента:
>>> fruits = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
>>> x, *last = fruits
>>> x
"apple"
>>> last
["banana", "cherry", "orange", "kiwi", "melon", "mango"]
Можна також вилучити значення на початку й у кінці list, згрупувавши всі значення посередині:
>>> fruits = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
>>> x, *middle, y, z = fruits
>>> y
"melon"
>>> middle
["banana", "cherry", "orange", "kiwi"]
Оператор * можна використати і під час глибокого розпакування:
>>> fruits_vegetables = [["apple", "banana", "melon"], ["carrot", "potato", "tomato"]]
>>> [[a, *rest], b] = fruits_vegetables
>>> a
"apple"
>>> rest
["banana", "melon"]
Розпакування словника
Розпакування словника дещо відрізняється від розпакування list/tuple.
Ітерація по словниках типово працює з ключами.
Тож розпаковуючи dict, можна розпакувати лише ключі, а не значення:
>>> fruits_inventory = {"apple": 6, "banana": 2, "cherry": 3}
>>> x, y, z = fruits_inventory
>>> x
"apple"
Якщо ми хочемо розпакувати значення, можна скористатися методом <dict>.values():
>>> fruits_inventory = {"apple": 6, "banana": 2, "cherry": 3}
>>> x, y, z = fruits_inventory.values()
>>> x
6
Якщо потрібні і ключі, і значення, використовуємо метод <dict>.items().
<dict>.items() створює ітероване подання, що містить пари ключ-значення.
Їх можна розпакувати в tuple:
>>> fruits_inventory = {"apple": 6, "banana": 2, "cherry": 3}
>>> x, y, z = fruits_inventory.items()
>>> x
("apple", 6)
Пакування
Пакування дає змогу згрупувати кілька значень в один list, який присвоюють змінній.
Це стає в пригоді, коли потрібно розпакувати значення, внести зміни, а потім запакувати результат назад у змінну.
Це також дає змогу зливати два чи більше lists/tuples/dicts.
Пакування list/tuple за допомогою *
Запакувати list/tuple можна за допомогою оператора *.
Він запакує всі значення в list/tuple.
>>> fruits = ("apple", "banana", "cherry")
>>> more_fruits = ["orange", "kiwi", "melon", "mango"]
# fruits and more_fruits are unpacked and then their elements are packed into combined_fruits
>>> combined_fruits = *fruits, *more_fruits
# If there is no * on to the left of the "=" the result is a tuple
>>> combined_fruits
("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")
# If the * operator is used on the left side of "=" the result is a list.
# Note the trailing comma.
>>> *combined_fruits_too, = *fruits, *more_fruits
>>> combined_fruits_too
['apple', 'banana', 'cherry', 'orange', 'kiwi', 'melon', 'mango']
Докладніше про використання * у лівій частині можна дізнатися з PEP 3132.
Пакування словника за допомогою **
Словник пакують за допомогою оператора **.
Він запакує всі пари ключ-значення з одного словника в інший або поєднає два словники.
>>> fruits_inventory = {"apple": 6, "banana": 2, "cherry": 3}
>>> more_fruits_inventory = {"orange": 4, "kiwi": 1, "melon": 2, "mango": 3}
# fruits_inventory and more_fruits_inventory are unpacked into key-values pairs and combined.
>>> combined_fruits_inventory = {**fruits_inventory, **more_fruits_inventory}
# then the pairs are packed into combined_fruits_inventory
>>> combined_fruits_inventory
{"apple": 6, "banana": 2, "cherry": 3, "orange": 4, "kiwi": 1, "melon": 2, "mango": 3}
Використання * та ** із функціями
Пакування за допомогою параметрів функції
Коли ми створюємо функцію, що приймає довільну кількість аргументів, у її визначенні можна використати *args або **kwargs.
*args використовують, щоб запакувати довільну кількість позиційних (неключових) аргументів у tuple, а **kwargs - щоб запакувати довільну кількість ключових аргументів у словник.
Використання *args:
# This function is defined to take any number of positional arguments
>>> def my_function(*args):
... print(args)
# Arguments given to the function are packed into a tuple
>>> my_function(1, 2, 3)
(1, 2, 3)
>>> my_function("Hello")
("Hello")
>>> my_function(1, 2, 3, "Hello", "Mars")
(1, 2, 3, "Hello", "Mars")
Використання **kwargs:
# This function is defined to take any number of keyword arguments
>>> def my_function(**kwargs):
... print(kwargs)
# Arguments given to the function are packed into a dictionary
>>> my_function(a=1, b=2, c=3)
{"a": 1, "b": 2, "c": 3}
*args і **kwargs можна також використовувати разом:
>>> def my_function(*args, **kwargs):
... print(sum(args))
... for key, value in kwargs.items():
... print(str(key) + " = " + str(value))
>>> my_function(1, 2, 3, a=1, b=2, c=3)
6
a = 1
b = 2
c = 3
Можна також записати параметри перед *args, щоб дозволити конкретні позиційні аргументи.
Тоді окремі ключові аргументи мають стояти перед **kwargs.
Аргументи мають бути структуровані так:
def my_function(<positional_args>, *args, <key-word_args>, **kwargs)
Якщо не дотриматися цього порядку, виникне помилка.
>>> def my_function(a, b, *args):
... print(a)
... print(b)
... print(args)
>>> my_function(1, 2, 3, 4, 5)
1
2
(3, 4, 5)
Якщо записати аргументи в неправильному порядку, виникне помилка:
>>>def my_function(*args, a, b):
... print(args)
>>>my_function(1, 2, 3, 4, 5)
Traceback (most recent call last):
File "c:\something.py", line 3, in <module>
my_function(1, 2, 3, 4, 5)
TypeError: my_function() missing 2 required keyword-only arguments: 'a' and 'b'
Розпакування у виклики функцій
Можна використати *, щоб розпакувати list/tuple аргументів у виклик функції.
Це дуже корисно для функцій, які не приймають iterable:
>>> def my_function(a, b, c):
... print(c)
... print(b)
... print(a)
numbers = [1, 2, 3]
>>> my_function(*numbers)
3
2
1
Ще один поширений випадок: розпакування * разом із вбудованою функцією zip().
Функція zip() приймає кілька ітерованих обʼєктів і повертає list із tuples, у якому значення з кожного iterable згруповано:
>>> values = (['x', 'y', 'z'], [1, 2, 3], [True, False, True])
>>> a, *rest = zip(*values)
>>> rest
[('y', 2, False), ('z', 3, True)]
Навчальна вправа
