Упаковка и распаковка в 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