При написании программы вы можете не знать заранее всех вариантов использования кода. Возможно, в будущем захотите предложить больше возможностей для программистов, работающих с модулем, или для пользователей, взаимодействующих с вашим кодом. Используя в коде *args и **kwargs, можно передать разное число аргументов для функции.
В Python форма *args с одной звездочкой используется в качестве параметра для отправки функциями списка аргументов, которые не являются ключевыми словами с переменной длиной. Стоит отметить, что звездочка (*) является важным элементом, так как args представляет собой общепринятую идиому, хотя она и не принуждается к использованию языком.
Посмотрим на типичную функцию, которая использует два аргумента:
def multiply(x, y):
print (x * y)
В коде выше создается функция с аргументами х и y, и затем при вызове функции нам нужно использовать числа соответствующие х и y. В данном случае мы передаем числа типа integer — 5 для х и 4 для у:
def multiply(x, y):
print (x * y)
multiply(5, 4)
Сейчас мы можем запустить код:
Мы получим следующий результат, показывающий, что целые числа 5 и 4 были умножены функцией multiply(x,y):
Результат: 20
Что, если позже мы решим умножить три числа, а не два? Если мы попытаемся добавить к функции дополнительное число, как показано ниже, мы получим ошибку TypeError.
def multiply(x, y):
print (x * y)
multiply(5, 4, 3)
Вывод:
TypeError: multiply() takes 2 positional arguments but 3 were given
Итак, если вам позже нужно будет использовать больше аргументов, вы можете использовать *args в качестве параметра.
По сути, мы можем создать ту же функцию и код, которые показали в первом примере, убрав x и y как параметры функции и вместо этого заменив их на *args:
def multiply(*args):
z = 1
for num in args:
z *= num
print(z)
multiply(4, 5)
multiply(10, 9)
multiply(2, 3, 4)
multiply(3, 5, 10, 6)
При запуске данного кода мы получим результат вызова каждой функции:
20
90
24
900
Поскольку мы использовали параметр *args для функции, мы можем передать столько аргументов, сколько хотим, при вызове функции.
С помощью параметра *args вы можете создать более гибкий код, который принимает разное количество аргументов без ключевых слов внутри функции.
Для чего используется **kwargs в Python?
Форма **kwargs с двумя звездочками используется в качестве параметра для отправки в функции списка аргументов переменной длины без ключевого слова.
Две звездочки (**) также являются важным элементом, так как kwargs представляет собой общепринятую идиому, хотя она и не принуждается к использованию языком.
Как и *args, **kwargs может принимать столько аргументов, сколько вам нужно. Однако **kwargs отличается от *args тем, что здесь требуется назначить ключевые слова.
Сначала просто выведем аргументы из **kwargs, которые мы передаем функции. Создаем для этого короткую функцию:
def print_kwargs(**kwargs):
print(kwargs)
Затем мы вызываем функцию с разными аргументами которые передаются в функцию:
def print_kwargs(**kwargs):
print(kwargs)
print_kwargs(kwargs_1="Shark", kwargs_2=4.5, kwargs_3=True)
Запустим код и посмотрим на результат вывода:
{‘kwargs_1’: ‘Shark’, ‘kwargs_2’: 4.5, ‘kwargs_3’: True}
В зависимости от используемой версии Python 3, словарь может быть неупорядоченным. В Python 3.6 и более поздних версиях вы будете получать пары ключ-значение по порядку в котором они были переданы функции, но в более ранних версиях пары будут выводиться в случайном порядке.
Стоит отметить, что здесь создается словарь под названием kwargs, и мы можем работать с ним так же, как и с другими словарями.
Создадим еще одну короткую программу, чтобы показать, как можно использовать **kwargs. Здесь мы создадим функцию приветствия для словаря с именами. Начнем со словаря с двумя именами:
def print_values(**kwargs):
for key, value in kwargs.items():
print("Значение для {} является {}".format(key, value))
print_values(my_name="Sammy", your_name="Casey")
Теперь мы можем запустить программу и посмотреть на результат вывода:
Значение для my_name является Sammy
Значение для your_name является Casey
Так как словари могут быть в хаотичном порядке, ваш вывод может начинаться с имени Casey вместо Sammy.
Передадим дополнительные аргументы для функции, чтобы показать, что **kwargs примет столько аргументов, сколько вам нужно:
def print_values(**kwargs):
for key, value in kwargs.items():
print("Значение для {} является {}".format(key, value))
print_values(
name_1="Alex",
name_2="Gray",
name_3="Harper",
name_4="Phoenix",
name_5="Remy",
name_6="Val"
)
Сейчас при запуске программы мы получим следующий вывод, порядок которого у вас может отличаться:
Значение для name_1 является Alex Значение для name_2 является Gray Значение для name_3 является Harper Значение для name_4 является Phoenix Значение для name_5 является Remy Значение для name_6 является Val
Использование параметра **kwargs предоставляет гибкость при использовании аргументов с ключевыми словами в программе. Когда мы используем **kwargs в качестве параметра, нам не нужно знать, сколько аргументов в конечном итоге будет передано функции.
Порядок аргументов внутри функции в Python
При упорядочивании аргументов внутри функции или вызове функции, аргументы должны располагаться в определенном порядке:
- Формально позиционные аргументы;
*args;- Аргументы с ключевыми словами;
**kwargs.
На практике при работе с явными позиционными параметрами вместе с *args и **kwargs ваша функция будет выглядеть следующим образом:
def example(arg_1, arg_2, *args, **kwargs):
...
При работе с позиционными параметрами вместе с именованными параметрами с ключевыми словами в дополнение к *args и **kwargs, ваша функция должна выглядеть следующим образом:
def example2(arg_1, arg_2, *args, kw_1="shark", kw_2="blobfish", **kwargs):
...
Важно помнить о порядке аргументов при создании функции, чтобы не получить ошибку синтаксиса Python.
Использование *args и **kwargs при вызове функции
Мы также можем использовать *args и **kwargs для передачи аргументов в функции.
Сначала рассмотрим пример с *args.
def some_args(arg_1, arg_2, arg_3):
print("arg_1:", arg_1)
print("arg_2:", arg_2)
print("arg_3:", arg_3)
args = ("Sammy", "Casey", "Alex")
some_args(*args)
В функции выше есть три параметра, определенные как arg_1, arg_2 и arg_3. Функция выводит каждый из этих трех аргументов. Затем мы создаем переменную, для которой задается итерация (в данном случае кортеж), и можем передать эту переменную в функцию с синтаксисом со звездочкой.
При запуске программы с помощью команды python some_args.py мы получим следующий результат:
arg_1: Sammy
arg_2: Casey
arg_3: Alex
Мы также можем изменить программу выше для итерации списка с другим названием переменной. Давайте также объединим синтаксис *args с именованным параметром:
def some_args(arg_1, arg_2, arg_3):
print("arg_1:", arg_1)
print("arg_2:", arg_2)
print("arg_3:", arg_3)
my_list = [2, 3]
some_args(1, *my_list)
При запуске программы будет получен следующий результат:
arg_1: 1
arg_2: 2
arg_3: 3
Аналогичным образом аргументы **kwargs с ключевыми словами можно использовать для вызова функции. Мы создадим переменную, равную словарю с 3 парами ключ-значение (здесь мы будем использовать kwargs, но его можно называть как угодно) и передадим ее функции с 3 аргументами:
def some_kwargs(kwarg_1, kwarg_2, kwarg_3):
print("kwarg_1:", kwarg_1)
print("kwarg_2:", kwarg_2)
print("kwarg_3:", kwarg_3)
kwargs = {"kwarg_1": "Val", "kwarg_2": "Harper", "kwarg_3": "Remy"}
some_kwargs(**kwargs)
Запустим программу:
kwarg_1: Val
kwarg_2: Harper
kwarg_3: Remy
При вызове функции вы можете использовать *args и **kwargs для передачи аргументов.
Заключение
Мы можем использовать специальный синтаксис *args и **kwargs внутри функции для передачи переменного количества аргументов.
Создание функций, которые принимают *args и **kwargs, лучше используется в ситуациях, где ожидается, что число вводных данных внутри списка аргументов остается относительно небольшим.
Использование *args и **kwargs по сути обеспечивает читабельность и удобство, но их следует использовать с осторожностью.