Упаковка и распаковка в Python
Обновлено:
Символ:
*
мы уже использовали как оператор умножения:
10 * 5
Но в Python у * есть и другое применение — распаковка и упаковка элементов.
В этой теме пока не рассматриваем:
*args
**kwargs
Они будут изучаться отдельно.
1. Распаковка итерируемого объекта
Предположим, есть кортеж:
numbers = (
10,
20,
30,
)
Если передать его в print() обычным способом:
print(numbers)
получим:
(10, 20, 30)
В функцию был передан один аргумент — объект tuple.
Если поставить перед кортежем:
*
print(
*numbers
)
получим:
10 20 30
Кортеж был распакован.
Упрощённо:
print(
*numbers
)
превращается по смыслу в:
print(
10,
20,
30,
)
То есть каждый элемент итерируемого объекта становится отдельным позиционным аргументом функции.
2. Хорошо видно через sep
numbers = (
10,
20,
30,
)
print(
*numbers,
sep=' | ',
)
Результат:
10 | 20 | 30
Параметр:
sep
разделяет разные аргументы print().
Поэтому хорошо видно, что после:
*numbers
в функцию были переданы три отдельных аргумента.
3. Можно распаковывать разные итерируемые объекты
Например, список:
numbers = [
10,
20,
30,
]
print(
*numbers
)
Результат:
10 20 30
Строку:
text = 'Python'
print(
*text,
sep='-',
)
Результат:
P-y-t-h-o-n
Потому что строка тоже является итерируемым объектом.
Где можно использовать *
4. Функция должна принимать такое количество аргументов
Сам факт того, что объект можно распаковать, ещё не означает, что получившийся набор аргументов подходит функции.
Например, print() принимает произвольное количество позиционных аргументов:
print(
10,
20,
30,
40,
50,
)
Поэтому:
print(
*numbers
)
для него естественно работает.
5. max() и min()
Функции:
max()
min()
тоже умеют принимать несколько отдельных значений.
Например:
print(
max(
10,
50,
20,
)
)
Результат:
50
Поэтому можно:
numbers = [
10,
50,
20,
]
print(
max(
*numbers
)
)
Получим:
50
Но здесь распаковка обычно не нужна.
max() умеет принимать и один итерируемый объект:
print(
max(numbers)
)
Результат будет тем же:
50
Поэтому:
max(*numbers)
в такой ситуации обычно только усложняет запись.
То же самое относится к:
min()
Распаковка особенно полезна со своими функциями
6. Функция ожидает несколько отдельных аргументов
Создадим функцию:
def show_user(
name,
age,
city,
):
print(
name,
age,
city,
sep=' | ',
)
Обычный вызов:
show_user(
'Alex',
30,
'Tbilisi',
)
Результат:
Alex | 30 | Tbilisi
Но данные могут уже находиться в списке:
user = [
'Alex',
30,
'Tbilisi',
]
Так написать нельзя:
show_user(user)
Потому что функция ожидает:
3 позиционных аргумента
а мы передали:
1 аргумент — список
7. Распаковываем список
show_user(
*user
)
По смыслу получится:
show_user(
'Alex',
30,
'Tbilisi',
)
И функция успешно выполнится.
8. Количество элементов должно подходить
Функция:
def show_user(
name,
age,
city,
):
...
ожидает три обязательных аргумента.
Если:
user = [
'Alex',
30,
]
и выполнить:
show_user(
*user
)
аргументов будет недостаточно.
Возникнет:
TypeError
Если:
user = [
'Alex',
30,
'Tbilisi',
'Python',
]
после распаковки получится слишком много аргументов:
show_user(
'Alex',
30,
'Tbilisi',
'Python',
)
И снова возникнет:
TypeError
Таким образом:
*только распаковывает элементы. Подходят ли получившиеся аргументы функции — определяется самой функцией.
Множественное присваивание
9. Обычная распаковка
Мы уже умеем:
numbers = [
10,
20,
30,
]
first, second, third = numbers
print(first)
print(second)
print(third)
Результат:
10
20
30
Здесь количество переменных совпало с количеством элементов.
10. Если элементов слишком много
Например:
numbers = [
10,
20,
30,
40,
50,
]
first, second, third = numbers
получим:
ValueError
Потому что пять элементов невозможно обычной распаковкой распределить по трём переменным.
Звёздочка при присваивании
11. Забираем оставшиеся элементы
Можно поставить * перед одной из переменных:
numbers = [
10,
20,
30,
40,
50,
]
first, second, *others = numbers
Получим:
print(first)
# 10
print(second)
# 20
print(others)
# [30, 40, 50]
Переменная со звёздочкой забирает все оставшиеся элементы.
12. Результат упаковки — список
Даже если исходный объект является кортежем:
numbers = (
10,
20,
30,
40,
)
после:
first, *others = numbers
получим:
print(
type(others)
)
<class 'list'>
Starred-переменная при такой распаковке получает:
list
Звёздочка в конце
13. Первые значения отдельно, остальные вместе
numbers = [
10,
20,
30,
40,
50,
]
first, second, *others = numbers
Получаем:
first → 10
second → 20
others → [30, 40, 50]
Звёздочка в начале
14. Последние значения отдельно
numbers = [
10,
20,
30,
40,
50,
]
*others, second_last, last = numbers
Получаем:
others → [10, 20, 30]
second_last → 40
last → 50
Python сначала должен оставить элементы для обычных переменных справа, а всё оставшееся попадёт в:
others
Звёздочка посередине
15. Первый и последний элементы отдельно
numbers = [
10,
20,
30,
40,
50,
]
first, *middle, last = numbers
Результат:
first → 10
middle → [20, 30, 40]
last → 50
Это часто бывает удобно, когда отдельно интересуют:
первый элемент
последний элемент
а всё между ними можно собрать вместе.
16. Другой пример
user_data = [
'Alex',
'Brown',
30,
'Tbilisi',
'Python',
]
first_name, last_name, *other_data = (
user_data
)
print(first_name)
print(last_name)
print(other_data)
Результат:
Alex
Brown
[30, 'Tbilisi', 'Python']
Только одна starred-переменная
17. Нельзя поставить две * на одном уровне распаковки
Такой код:
*first, *second = numbers
некорректен.
В одной такой конструкции распаковки может быть только одна переменная со звёздочкой.
* и словари
18. Обычная итерация словаря даёт ключи
Возьмём:
user = {
'name': 'Alex',
'age': 30,
'city': 'Tbilisi',
}
Мы уже знаем:
for element in user:
print(element)
выводит:
name
age
city
Потому что обычная итерация dict происходит по ключам.
19. Распаковка самого dict
Поэтому:
print(
*user
)
равносильно распаковке его ключей.
Результат:
name age city
Условно можно представить:
print(
'name',
'age',
'city',
)
values()
20. Распаковываем значения
Если нужны именно значения:
print(
*user.values()
)
Результат:
Alex 30 Tbilisi
Метод:
values()
возвращает итерируемое представление значений, а * распаковывает его.
items()
21. Распаковываем пары
print(
*user.items()
)
Результат будет примерно таким:
('name', 'Alex') ('age', 30) ('city', 'Tbilisi')
Почему?
Метод:
items()
при итерации отдаёт пары:
('name', 'Alex')
('age', 30)
('city', 'Tbilisi')
А:
*
распаковывает внешний итерируемый объект.
Каждая пара при этом остаётся отдельным кортежем.
22. Важное различие
print(
*user
)
даёт:
ключи
print(
*user.values()
)
даёт:
значения
print(
*user.items()
)
даёт:
пары (ключ, значение)
Распаковка и упаковка — два разных применения *
23. Распаковка при вызове функции
numbers = [
10,
20,
30,
]
print(
*numbers
)
Здесь * говорит:
Возьми итерируемый объект и передай его элементы отдельно.
Условно:
[10, 20, 30]
↓
10, 20, 30
24. Упаковка при множественном присваивании
first, *others = numbers
Здесь направление по смыслу противоположное:
10, 20, 30
↓
first = 10
others = [20, 30]
Звёздочка собирает оставшиеся элементы в один список.
Когда * действительно полезна
* особенно удобна, когда данные уже находятся в некотором итерируемом объекте:
coordinates = [
10,
20,
30,
]
а функция ожидает отдельные позиционные аргументы:
def show_coordinates(
x,
y,
z,
):
print(x, y, z)
Вместо:
show_coordinates(
coordinates[0],
coordinates[1],
coordinates[2],
)
можно написать:
show_coordinates(
*coordinates
)
Так код становится компактнее и напрямую показывает:
элементы этой последовательности нужно использовать как отдельные аргументы.
Главное по теме
* может использоваться для распаковки итерируемого объекта:
print(
*numbers
)
Например:
[10, 20, 30]
превращается при вызове функции в отдельные аргументы:
10
20
30
Это удобно только тогда, когда функция способна принять соответствующее количество позиционных аргументов.
Например:
def show_point(
x,
y,
z,
):
...
point = [
10,
20,
30,
]
show_point(
*point
)
В множественном присваивании * работает наоборот — собирает оставшиеся элементы:
first, *middle, last = (
numbers
)
Например:
numbers = [10, 20, 30, 40, 50]
first → 10
middle → [20, 30, 40]
last → 50
Переменная со звёздочкой получает именно:
list
Для dict:
*dictionary
распаковывает ключи.
*dictionary.values()
распаковывает значения.
*dictionary.items()
распаковывает пары:
(key, value)
В следующей теме это же обозначение:
*
будет использоваться при определении собственных функций:
*args
а также познакомимся с:
**kwargs