Что такое args и kwargs
Что такое *args и **kwargs в Python?
Функции — это жизнь. Правда? Если вы только начали осваивать Python, неважно — первый ли это ваш язык программирования, или вы пришли в Python из другого языка, то вы уже знаете о том, что количество параметров в объявлении функции соответствует количеству аргументов, которые передают функции при вызове.
Не позволяйте всяким значкам загонять себя в ступор. Тут нет ничего архисложного. В общем-то, если эти конструкции вам незнакомы — предлагаю с ними разобраться.
Позиционные и именованные аргументы
Сначала поговорим о том, чем они отличаются. В простейшей функции мы просто сопоставляем позиции аргументов и параметров. Аргумент №1 соответствует параметру №1, аргумент №2 — параметру №2 и так далее.
Для вызова функции необходимы все три аргумента. Если пропустить хотя бы один из них — будет выдано сообщение об ошибке.
Если при объявлении функции назначить параметру значение по умолчанию — указывать соответствующий аргумент при вызове функции уже необязательно. Параметр становится опциональным.
Опциональные параметры, кроме того, можно задавать при вызове функции, используя их имена.
В следующем примере установим три параметра в значение по умолчанию None и взглянем на то, как их можно назначать, используя их имена и не обращая внимания на порядок следования аргументов, применяемых при вызове функции.
Оператор «звёздочка»
Оператор * чаще всего ассоциируется у людей с операцией умножения, но в Python он имеет и другой смысл.
Этот оператор позволяет «распаковывать» объекты, внутри которых хранятся некие элементы. Вот пример:
Как пользоваться *args и **kwargs
Итак, мы знаем о том, что оператор «звёздочка» в Python способен «вытаскивать» из объектов составляющие их элементы. Знаем мы и о том, что существует два вида параметров функций. Вполне возможно, что вы уже додумались до этого сами, но я, на всякий случай, скажу об этом. А именно, *args — это сокращение от «arguments» (аргументы), а **kwargs — сокращение от «keyword arguments» (именованные аргументы).
Каждая из этих конструкций используется для распаковки аргументов соответствующего типа, позволяя вызывать функции со списком аргументов переменной длины. Например — создадим функцию, которая умеет выводить результаты, набранные учеником в тесте:
Итоги
Вот несколько советов, которые помогут вам избежать распространённых проблем, возникающих при работе с функциями, и расширить свои знания:
Что такое *args и **kwargs в Python?
Функции — жизнь, не так ли? Не важно, новичок вы в программировании в целом или пришли из другого языка: осваивая Python, вы узнаете, что число параметров, указанных в определении функции, совпадает с числом передаваемых аргументов.
Не позволяйте синтаксису вас напугать. Это никакие не особые параметры. Они вообще не особо вычурны, и мы сейчас научимся их правильно использовать.
Позиционные аргументы против именованных
Для понимания *args и **kwargs нам потребуется разобраться с двумя принципами, а точнее понять разницу между позиционными и именованными аргументами. В самых простых функциях мы играем в игру сопоставления — аргумент 1 сопровождает параметр 1, аргумент 2 сопровождает параметр 2 и т.д.
Все три аргумента необходимы. Упущение любого из них вызовет ошибку.
Если мы назначим параметру в определении функции значение по умолчанию, тогда он станет опциональным.
Помимо этого, опциональные параметры получают возможность именования. То есть вы можете определить имя параметра в вызове функции, чтобы потом отобразить его.
Давайте назначим всем трем переменным значения по умолчанию none и посмотрим, как мы при этом сможем отобразить их независимо от последовательности.
Оператор *
Я могу описать его как оператор расширения, распаковывающий наборы домино, чтобы потом выстроить из них одну единую огромную последовательность. Однако звездочка представляет еще более мощную аналогию. Вот простой пример:
Как использовать *args и **kwargs
Итак, нам известно, что оператор * распаковывает множественные значения и существует два типа параметров функции. Если вы до сих пор не догадались, то *args — это сокращение от arguments (аргументы), а **kwargs — это сокращение от keyword arguments (именованные аргументы).
Каждый из них используется для распаковки соответствующих им типов аргументов, определенных вызовами функции, согласно списку аргументов переменной длины.
Например, давайте создадим функцию для печати баллов для тестирования студента:
Заключение
Немного мудрых слов в напутствие вам для избежания распространенных ошибок и расширения знаний:
Хватит злоупотреблять *args и **kwargs в Python
Да будет холивар! Использовать args/kwargs или не использовать, это показатель профессионализма или базовые знания, без которых должно быть стыдно? Часто листая github различных проектов натыкаешься на наличие данных аргументов в функциях просто потому что. И данная статья натолкнула на пообщаться на эту тему. Вообще, стараюсь не использовать неконтролируемое аргументирование на практике, но на сколько это вообще распространенный метод программирования? Делитесь в комментариях. И приятного чтения.
В Интернете полно обучалок, которые научат вас использовать *args и **kwargs при определении функции в Python. Возможно, вы уже часами пытаетесь понять, как раскрыть их потенциал. Может быть, после всего этого исследования вы теперь чувствуете в них уверенность.
Мощные инструменты опасны. Вы могли облегчить свою жизнь, но запомните мои слова, они вскоре вернутся, чтобы преследовать вас.
Немного основ
Параметры в Python функции могут принимать два типа аргументов:
Позиционные аргументы, которые передаются позиционно.
Именованные аргументы, которые передаются с ключевыми словами.
С другой стороны, **kwargs позволяет передавать вашей функции произвольное количество аргументов с ключевыми словами. Поскольку у каждого именованного аргумента есть ключевое слово и значение, он сгруппирован как итерируемый словарь внутри функции.
Photo by Susan Holt Simpson on Unsplash
Проблема
Код гораздо сложнее отлаживать, если вы злоупотребляете в нем подобными решениями, потому что вы позволяете передавать произвольное количество аргументов функции, и функция может вести себя непредсказуемо.
Когда всё-таки использовать аргументы?
Если кратко: используйте их, когда они вам действительно нужны. Например, функция с множеством необязательных полей, и некоторые из них используются только в редких ситуациях. Скажем, функция строит график, и вы можете передавать различные необязательные аргументы, чтобы изменить его цвет, стиль, размер и т.д.
Есть один сценарий, в котором их использование может быть неизбежным. Если вы создаете оболочку для функции с неизвестными аргументами, вам нужно будет принять произвольное количество позиционных и именованных аргументов, а затем передать их функции.
Например, декораторы в Python работают как оболочки, которые изменяют поведение кода, не изменяя сам код функции, тем самым расширяя дополнительные функции.
Photo by Alexander Schimmeck on Unsplash
Выводы
По возможности избегайте их.
Обратите внимание, что args и kwargs так называются просто по соглашению. Вы можете называть их как хотите. Именно звездочки * и ** дают функциям ту самую мощь.
Использование *args и **kwargs в Python 3
В определениях функций параметрами называются объекты, которые указывают аргумент, который может принимать данная функция.
При разработке кода вы можете не знать обо всех возможных вариантах его использования и, возможно, захотите предложить программистам и пользователям, взаимодействующим с кодом, больше опций. Чтобы передать переменное количество аргументов функции в коде, используйте *args и **kwargs.
Что такое *args?
В Python параметр *args используется для передачи списка аргументов переменной длины без указания ключевого слова. Стоит отметить, что звездочка (*) является важным элементом параметра, так как слово args – установленная условная идиома.
Рассмотрим типичную функцию, которая использует два аргумента (файл lets_multiply.py):
def multiply(x, y):
print (x * y)
В этом примере функция использует x и y в качестве аргументов. Далее, при вызове функции, нужно использовать числа, соответствующие x и y. Передайте целые числа: 5 для x и 4 для y:
def multiply(x, y):
print (x * y)
multiply(5, 4)
Вы получите результат функции multiply(x,y) с заданными значениями:
К примеру, теперь нужно умножить три числа, а не два. Если вы попытаетесь добавить в функцию ещё одно число (как показано ниже), вы получите сообщение об ошибке.
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)
Запустите код, вы увидите:
Поскольку список аргументов переменной длины был отправлен с помощью *args, вы можете передавать функции любое количество аргументов.
Параметр *args позволяет создавать более гибкий код функции, который принимает любое количество аргументов без ключевого слова.
Что такое **kwargs?
Параметр **kwargs передаёт функции словарь аргументов переменной длины с ключевым словом.
Примечание: Опять же, звездочки (**) важны, поскольку без них kwargs используется в документации.
Как и *args, **kwargs может принимать любое количество аргументов. Однако **kwargs отличается от *args тем, что требует присваивать ключевое слово.
Для примера создайте простую программу print_kwargs.py. Попробуйте просто вывести аргументы **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 можно так же, как и с другими словарями.
Создайте другую простую программу print_values.py, чтобы научиться работать с **kwargs. Поместите в файл функцию, которая будет выводить на экран приветствие и подставлять имя пользователя.
def print_values(**kwargs):
for key, value in kwargs.items():
print(«The value of <> is <>«.format(key, value))
print_values(my_name=»8host», your_name=»Casey»)
python print_values.py
The value of your_name is Casey
The value of my_name is 8host
Теперь передайте функции дополнительные аргументы (чтобы убедиться, что **kwargs может принимать любое количество аргументов).
def print_values(**kwargs):
for key, value in kwargs.items():
print(«The value of <> is <>«.format(key, value))
print_values(
name_1=»Alex»,
name_2=»Gray»,
name_3=»Harper»,
name_4=»Phoenix»,
name_5=»Remy»,
name_6=»Val»
)
Теперь программа вернёт такой неупорядоченный вывод:
The value of name_2 is Gray
The value of name_6 is Val
The value of name_4 is Phoenix
The value of name_5 is Remy
The value of name_3 is Harper
The value of name_1 is Alex
** kwargs обеспечивает гибкость в использовании аргументов с ключевыми словами. Используя ** 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):
…
При написании функции очень важно соблюдать порядок аргументов. Иначе при запуске программы будут возникать ошибки.
*args и **kwargs в вызовах функций
*args и **kwargs можно использовать для передачи аргументов в функцию.
Создайте файл some_args.py. Рассмотрим такой код (поместите его в новый файл):
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 = («8host», «Casey», «Alex»)
some_args(*args)
В функции есть три параметра: arg_1, arg_2 и arg_3. Функция выведет каждый из этих аргументов. Затем мы создаем переменную, которой присваивается итерируемый тип (в данном случае кортеж). Эту переменную можно передать в функцию с помощью звездочки.
Читайте также: Кортежи в Python 3
python some_args.py
arg_1: 8host
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 могут использоваться для вызова функции аналогичным образом. В файле some_kwargs.py создайте переменную, присвойте ей словарь с тремя парами «ключ-значение» (здесь используется 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
Заключение
Специальный синтаксис *args и **kwargs можно использовать в определении функции для передачи переменных или аргументов.
Функции с *args и **kwargs лучше всего использовать в ситуациях, когда количество входных данных в списке аргументов останется относительно небольшим. Использование *args и **kwargs обеспечивает гибкость и читабельность кода, но работать с этим синтаксисом нужно очень внимательно.
Python: *args, **kwargs и декораторы для начинающих
Python имеет много конструкций, которые достаточно просты для изучения и использования в нашем коде. Тогда как есть некоторые конструкции, которые всегда смущают нас, когда мы сталкиваемся с ними в нашем коде.
Я думаю, что многие из моих друзей по Data Scientists сталкивались с ними тоже.
Большинство функций seaborn так или иначе используют *args и **kwargs.
Или как насчет декораторов?
В этой серии статей под названием « Python Shorts » я объясню некоторые простые конструкции, предоставляемые Python, некоторые важные советы и некоторые примеры использования, которые я регулярно придумываю в своей работе.
Этот пост посвящен объяснению некоторых сложных концепций в доступной для понимания форме.
Что такое *args?
Проще говоря, вы можете использовать, *args чтобы дать произвольное количество входных аргументов для вашей функции.
Простой пример:
Допустим, мы должны создать функцию, которая добавляет два числа. Мы можем сделать это легко в Python следующим образом.
Что если мы хотим создать функцию для добавления трех переменных?
Что если мы хотим, чтобы одна и та же функция добавила неизвестное количество переменных? Обратите внимание, что мы можем использовать *args или *argv или *anyOtherName чтобы сделать это.
Теперь вы можете использовать ту же функцию следующим образом:
Что такое **kwargs?
Проще говоря, вы можете использовать, **kwargs чтобы дать произвольное количество ключевых слов для вашей функции и получить к ним доступ, используя словарь.
Простой пример:
Допустим, вы хотите создать функцию печати, которая может принимать имя и возраст в качестве входных данных и печатать их.
Давайте теперь скажем, что вы хотите, чтобы одна и та же функция принимала два имени и два возраста.
Вы правильно догадались, что мой следующий вопрос: что если я не знаю, сколько аргументов мне понадобится?
Вы можете вызвать эту функцию используя:
Помните, что мы никогда не определяли Sansa, Arya или Tyrion в качестве аргументов наших методов.
Это довольно мощная концепция. И многие программисты используют это довольно умно, когда пишут библиотеки-обертки.
Это может сэкономить много усилий при написании кода, а также делает код на будущее. Если в какой-либо момент в будущем plt.scatter будет принимать какие-либо новые аргументы, функция seaborn.Scatterplot все равно будет работать.
Что такое декораторы?
Простой пример:
Допустим, мы хотим добавить пользовательские функции к некоторым из наших функций. Функциональность заключается в том, что всякий раз, когда вызывается функция, печатается « function name begins», а всякий раз, когда функция заканчивается, печатаются « function name ends» и время, затраченное функцией.
Давайте предположим, что наша функция:
Мы можем добавить несколько строк с print для всех наших функций, чтобы достичь этого.
Вот где декораторы нам пригодятся. Мы можем использовать декораторы, чтобы обернуть любую функцию.
Теперь мы можем использовать этот декоратор timer для украшения нашей функции somefunc
Теперь, вызывая эту функцию, мы получаем:
Теперь мы можем добавить @timer к каждой нашей функции, для которой мы хотим, чтобы печаталось время.
Соединяя все части
Что если наша функция принимает три аргумента? Или много аргументов?
Именно здесь соединяется все, что мы узнали до сих пор. Мы используем *args и **kwargs
Мы меняем нашу функцию декоратора так:
Теперь наша функция может принимать любое количество аргументов, и наш декоратор все равно будет работать.
На мой взгляд, декораторы могут быть очень полезными. Я предоставил только один вариант использования декораторов, но есть несколько способов их использования.
Вы можете использовать декоратор для отладки кода, проверяя, какие аргументы входят в функцию. Или декоратор может быть использован для подсчета количества вызовов конкретной функции. Это может помочь с подсчетом рекурсивных вызовов.
Заключение
В этом посте я рассказал о некоторых конструкциях, которые вы можете найти в исходном коде Python, и о том, как вы можете их понять.
Не обязательно, чтобы вы в конечном итоге использовали их в своем коде. Но я предполагаю, что понимание того, как эти вещи работают, помогает смягчить некоторую путаницу и панику, с которой сталкиваются каждый раз, когда появляются эти конструкции.