Переменное количество аргументов Функции в Python

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

Содержание статьи

Для чего используется *args в Python
Для чего используется **kwargs в Python
Порядок аргументов внутри функции в Python
Использование *args и **kwargs при вызове функции

При написании программы вы можете не знать заранее всех вариантов использования кода. Возможно, в будущем захотите предложить больше возможностей для программистов, работающих с модулем, или для пользователей, взаимодействующих с вашим кодом. Используя в коде *args и **kwargs, можно передать разное число аргументов для функции.

Для чего используется *args в Python?

В Python форма *args с одной звездочкой используется в качестве параметра для отправки функциями списка аргументов, которые не являются ключевыми словами с переменной длиной. Стоит отметить, что звездочка (*) является важным элементом, так как args представляет собой общепринятую идиому, хотя она и не принуждается к использованию языком.

Есть вопросы по Python?

На нашем форуме вы можете задать любой вопрос и получить ответ от всего нашего сообщества!

Python Форум Помощи

Telegram Чат & Канал

Вступите в наш дружный чат по Python и начните общение с единомышленниками! Станьте частью большого сообщества!

Чат

Канал

Паблик VK

Одно из самых больших сообществ по Python в социальной сети ВК. Видео уроки и книги для вас!

Посмотрим на типичную функцию, которая использует два аргумента:

def multiply(x, y):
    print (x * y)

1 2	def multiply(x, y): print (x * y)

В коде выше создается функция с аргументами х и y, и затем при вызове функции нам нужно использовать числа соответствующие х и y. В данном случае мы передаем числа типа integer — 5 для х и 4 для у:

def multiply(x, y):
    print (x * y)

multiply(5, 4)

def multiply(x, y):

print (x * y)

multiply(5, 4)

Сейчас мы можем запустить код:

python lets_multiply.py

1	python lets_multiply.py

Мы получим следующий результат, показывающий, что целые числа 5 и 4 были умножены функцией multiply(x,y):

20

Что, если позже мы решим умножить три числа, а не два? Если мы попытаемся добавить к функции дополнительное число, как показано ниже, мы получим ошибку TypeError.

def multiply(x, y):
    print (x * y)

multiply(5, 4, 3)

def multiply(x, y):

print (x * y)

multiply(5, 4, 3)

Вывод:

TypeError: multiply() takes 2 positional arguments but 3 were given

1	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)

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)

При запуске данного кода мы получим результат вызова каждой функции:

900

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

С помощью параметра *args вы можете создать более гибкий код, который принимает разное количество аргументов без ключевых слов внутри функции.

Для чего используется **kwargs в Python?

Форма **kwargs с двумя звездочками используется в качестве параметра для отправки в функции списка аргументов переменной длины без ключевого слова. Две звездочки (**) также являются важным элементом, так как kwargs представляет собой общепринятую идиому, хотя она и не принуждается к использованию языком.

Как и *args, **kwargs может принимать столько аргументов, сколько вам нужно. Однако **kwargs отличается от *args тем, что здесь требуется назначить ключевые слова.

Сначала просто выведем аргументы из **kwargs, которые мы передаем функции. Создаем для этого короткую функцию:

def print_kwargs(**kwargs):
        print(kwargs)

1 2	def print_kwargs(**kwargs): print(kwargs)

Затем мы вызываем функцию с разными аргументами которые передаются в функцию:

def print_kwargs(**kwargs):
        print(kwargs)

print_kwargs(kwargs_1="Shark", kwargs_2=4.5, kwargs_3=True)

def print_kwargs(**kwargs):

print(kwargs)

print_kwargs(kwargs_1="Shark", kwargs_2=4.5, kwargs_3=True)

Запустим код и посмотрим на результат вывода:

python print_kwargs.py

1	python print_kwargs.py

Вывод:

{'kwargs_1': 'Shark', 'kwargs_2': 4.5, 'kwargs_3': True}

1	{'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")

def print_values(**kwargs):

for key, value in kwargs.items():

print("Значение для {} является {}".format(key, value))

print_values(my_name="Sammy", your_name="Casey")

Теперь мы можем запустить программу и посмотреть на результат вывода:

python print_values.py

1	python print_values.py

Вывод:

Значение для my_name является Sammy
Значение для your_name является Casey

1 2	Значение для 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"
        )

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

Значение для 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):
    ...

1 2	def example(arg_1, arg_2, args, *kwargs): ...

При работе с позиционными параметрами вместе с именованными параметрами с ключевыми словами в дополнение к *args и **kwargs, ваша функция должна выглядеть следующим образом:

def example2(arg_1, arg_2, *args, kw_1="shark", kw_2="blobfish", **kwargs):
    ...

1 2	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)

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

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)

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

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)

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)

Запустим программу выше с помощью команды python some_kwargs.py:

kwarg_1: Val
kwarg_2: Harper
kwarg_3: Remy

kwarg_1: Val

kwarg_2: Harper

kwarg_3: Remy

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

Заключение

Мы можем использовать специальный синтаксис *args и **kwargs внутри функции для передачи переменного количества аргументов.

Создание функций, которые принимают *args и **kwargs, лучше используется в ситуациях, где ожидается, что число вводных данных внутри списка аргументов остается относительно небольшим.

Использование *args и **kwargs по сути обеспечивает читабельность и удобство, но их следует использовать с осторожностью.

Vasile Buldumac

Являюсь администратором нескольких порталов по обучению языков программирования Python, Golang и Kotlin. В составе небольшой команды единомышленников, мы занимаемся популяризацией языков программирования на русскоязычную аудиторию. Большая часть статей была адаптирована нами на русский язык и распространяется бесплатно.

E-mail: vasile.buldumac@ati.utm.md

Образование
Universitatea Tehnică a Moldovei (utm.md)

2014 — 2018 Технический Университет Молдовы, ИТ-Инженер. Тема дипломной работы «Автоматизация покупки и продажи криптовалюты используя технический анализ»
2018 — 2020 Технический Университет Молдовы, Магистр, Магистерская диссертация «Идентификация человека в киберпространстве по фотографии лица»