Операторы * и ** для упаковки и распаковки коллекций в Python

• 26.04.2022
• 11468
• Основы Python
• Операторы

Разберем префиксные операторы * и **, которые ставятся перед переменными для распаковки или упаковки коллекций.

Распаковка в переменные

Распаковка кортежей

Кортеж можно распаковать в отдельные элементы:

a, b = (1, 2)
print(a)
print(b)
#1
#2

Но если в кортеже будет больше значений, чем переменных, то будет ошибка:

a, b = (1, 2, 3, 4)
print(a)
print(b)
#ValueError: too many values to unpack (expected 2)

Можно воспользоваться оператором распаковки *:

a, *b = (1, 2, 3, 4)
print(a)
print(b)
#1
#[2, 3, 4]

В результате первый элемент кортежа будет присвоен первой переменной a, а все остальные элементы (уже в виде списка) — переменной b.

Также можно сделать и наоборот:

*a, b = (1, 2, 3, 4)
print(a)
print(b)
#[1, 2, 3]
#4

Переменной b будет присвоен последний элемент кортежа, а все остальные будут присвоены переменной a в виде списка.

Или так:

a, *b, c = (1, 2, 3, 4)
print(a)
print(b)
print(c)
#1
#[2, 3]
#4

Крайние элементы кортежа присваиваются переменным a и c, а все остальное попадает в переменную b.

Распаковка списков

a, *b = [1, 'два', 3, False]
print(a)
print(b)
#1
#['два', 3, False]

Распаковка строк

a, *b, c = 'fullstacker.ru'
print(a)
print(b)
print(c)
#f
#['u', 'l', 'l', 's', 't', 'a', 'c', 'k', 'e', 'r', '.', 'r']
#u

Распаковка множеств

s = {1, 2, 4}
a, *b = s
print(a)
print(b)
#1
#[2, 4]

Распаковка словарей

d1 = {'key1': 'val1', 'key2': 'val2', 'key3': 'val3'}
a, *b = d1
print(a)
print(b)
#key1
#['key2', 'key3']

Получим ключи словаря.

Для получения значений, следует использовать метод values:

d1 = {'key1': 'val1', 'key2': 'val2', 'key3': 'val3'}
a, *b = d1.values()
print(a)
print(b)
#val1
#['val2', 'val3']

Для получения кортежей с ключами и значениями — метод items:

d1 = {'key1': 'val1', 'key2': 'val2', 'key3': 'val3'}
a, *b = d1.items()
print(a)
print(b)
#('key1', 'val1')
#[('key2', 'val2'), ('key3', 'val3')]

Распаковка кортежей без переменных

d = 5, 10
print(*d)
#5 10

Зачем это вообще может понадобиться?

К примеру, нам нужно получить числовой диапазон из значений кортежа.

Создадим кортеж из двух значений:

d = 5, 10
print(d)
#(5, 10)

Если мы в функцию range() передадим кортеж d, то получим ошибку:

d = 5, 10
print(range(d))
#TypeError: 'tuple' object cannot be interpreted as an integer

Поскольку range() ожидает в качестве аргументов 2 значения, а не кортеж из двух значений.

Но мы можем распаковать кортеж с помощью оператора *:

d = 5, 10
print(range(*d))
#range(5, 10)

Преобразовав в список, получим числовой диапазон из переданного кортежа:

d = 5, 10
print(list(range(*d)))
#[5, 6, 7, 8, 9]

Или таким образом:

d = 5, 10
print([*range(*d)])
#[5, 6, 7, 8, 9]

Распаковка словарей

d = {'key1': 'val1', 'key2': 'val2', 'key3': 'val3'}
print(*d)
#key1 key2 key3

Мы получили ключи словаря.

А если использовать метод values:

d = {'key1': 'val1', 'key2': 'val2', 'key3': 'val3'}
print(*d.values())
#val1 val2 val3

Получим значения словаря.

Если же использовать метод items:

d = {'key1': 'val1', 'key2': 'val2', 'key3': 'val3'}
print(*d.items())
#('key1', 'val1') ('key2', 'val2') ('key3', 'val3')

Получим кортежи из ключей и значений словаря.

Распаковка списков

lst = [1, 2, 3, 4]
print(*lst)
#1 2 3 4

Объединение итерируемых объектов

С помощью оператора *, можно не только распаковывать, но и объединять итерируемые объекты:

d = 5, 10
e = ('один', 'два', 'три')
f = [True, False]
print([*range(*d), *e, *f])
#[5, 6, 7, 8, 9, 'один', 'два', 'три', True, False]

Точно также объединение работает и с другими типами данных:

my_tuple = (1, 2, 3)
print((0, *my_tuple, 4))
my_set = {1, 2, 3}
print({0, *my_set, 4})
#(0, 1, 2, 3, 4)
#{0, 1, 2, 3, 4}

Объединили в один список — числовой диапазон, кортеж и список.

Объединение двух словарей с помощью **

d1 = {'key1': 'val1', 'key2': 'val2'}
d2 = {'key4': 'val4', 'key5': 'val5'}
d3 = {**d1, **d2}
print(d3)
#{'key1': 'val1', 'key2': 'val2', 'key4': 'val4', 'key5': 'val5'}

В итоге получился словарь, который содержит элементы и первого и второго словаря.

Упаковка в функциях

Операторами * и ** также удобно пользоваться и в функциях. Это дает возможность вызывать функцию с произвольным количеством позиционных аргументов и именованных аргументов.

def my_function(*args, **kwargs):
    print(args)
    print(kwargs)
    
my_function(1, 2, 3, a=10, b=20)
#(1, 2, 3)
#{'a': 10, 'b': 20}

После вызова функции мы получили кортеж args позиционных аргументов и словарь kwargs именованных аргументов.