Для чего нужны специальные параметры Python Asterisk и Slash?

Оглавление

• Вкратце: Звездочка и косая черта Python управляют передачей значений функциям
• Можете ли вы написать функцию, которая принимает только аргументы по ключевым словам?
• Можете ли вы написать функцию, которая принимает только позиционные аргументы?
• Связана ли голая звездочка с *args?
• Можете ли Вы использовать Asterisk Без других Параметров?
• Можете ли вы использовать как звездочку, так и косую черту в определении функции?
• Можете ли вы использовать как *args, так и звездочку вместе?
• Зачем Вам использовать специальные параметры в Вашей функции?
• Заключение

Всякий раз, когда вы думаете об операторе asterisk в Python (*), скорее всего, вы думаете об умножении или возведении в степень. Аналогично, вы, вероятно, ассоциируете оператор прямой косой черты (/) с делением. Но вы также можете использовать звездочку и косую черту в качестве специальных параметров в заголовках функций. Они выполняют совершенно не связанные с математикой функции.

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

def strange_function(*, x, y):
    ...

def another_strange_function(a, b, /, c, *, d):
    ...

Оба этих определения функций могут показаться немного странными, но их функциональные параметры на самом деле абсолютно корректны. Итак, что именно означают звездочка и косая черта в определении функции Python?

Получите свой код: Нажмите здесь, чтобы загрузить бесплатный пример кода для использования звездочки и косой черты в качестве специальных параметров в ваших функциях Python .

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

Звездочка (*) и косая черта (/) определяют, можно ли передавать позиционное или ключевое слово аргументы для ваших функций.

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

Left side	Divider	Right side
Positional-only arguments	/	Positional or keyword arguments
Positional or keyword arguments	*	Keyword-only arguments

Вы также можете использовать оба символа вместе. Позже вы узнаете больше об этом последнем пункте, а пока рассмотрим использование обоих символов по отдельности.

Предположим, вы пишете функцию asterisk_usage() со звездочкой в качестве одного из ее параметров. Затем вы вызываете ее:

>>> def asterisk_usage(either, *, keyword_only):
...     print(either, keyword_only)
...
>>> asterisk_usage(either="Frank", keyword_only="Dean")
Frank Dean

>>> asterisk_usage("Frank", keyword_only="Dean")
Frank Dean

>>> asterisk_usage("Frank", "Dean")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: asterisk_usage() takes 1 positional argument but 2 were given

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

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

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

>>> def print_three_members(member1, member2, *):
  File "<stdin>", line 1
    def print_three_members(member1, member2, *):
                                              ^
SyntaxError: named arguments must follow bare *

Как вы можете видеть выше, вы не пройдете дальше строки определения функции.

Теперь предположим, что вы пишете функцию slash_usage() с косой чертой в заголовке. Попробуйте:

>>> def slash_usage(positional_only, /, either):
...     print(positional_only, either)
...
>>> slash_usage("Frank", either="Dean")
Frank Dean

>>> slash_usage(positional_only="Frank", either="Dean")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: slash_usage() got some positional-only arguments
passed as keyword arguments: 'positional_only'

>>> slash_usage("Frank", "Dean")
Frank Dean

На этот раз вы использовали косую черту, чтобы убедиться, что все предыдущие аргументы должны передаваться по позиции. Когда вы передаете positional_only по позиции, ваш вызов работает. Однако, когда вы передаете тот же аргумент по ключевому слову, ваш вызов завершается ошибкой. Ваш последний вызов функции показывает, что вы можете передать аргумент either либо по позиции, либо по ключевому слову.

Примечание: В документации Python * и / упоминаются как символы и специальные параметры. В этом руководстве вы увидите оба термина, где это уместно. Термин операторы будет относиться только к их использованию при умножении и делении. Кроме того, термин аргументы будет относиться к данным, которые вы передаете функции, в то время как параметры будут относиться к заполнителям заголовка функции, которые их получают.

PEP 3102 – Аргументы только для ключевых слов определяет использование звездочки в качестве аргумента, в то время как PEP 570 - Параметры только для позиции Python определяет косую черту в терминах параметра, хотя символ также отображается на короткое время. PEP 570 также использует слова параметр и аргумент как взаимозаменяемые.

Теперь вы знаете, как использовать звездочку и косую черту при определении вашей собственной функции. Но, возможно, у вас есть какие-то вопросы о том, какие функции они позволяют вам создавать, и, возможно, вы также думаете о звездочке в *args. Продолжайте читать, чтобы получить ответы!

Можете ли вы написать функцию, которая принимает аргументы только по ключевым словам?

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

В Python аргумент с ключевым словом — это аргумент, который вы передаете функции, используя имя ее параметра, например, first_name="Dean". Передача аргументов по ключевому слову делает ваш код более читабельным, а также делает использование функции более значимым для ваших пользователей. Вы можете передавать аргументы ключевых слов в любом порядке, но они должны располагаться после позиционных аргументов, если это применимо.

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

>>> def print_three_members(*, member1, member2, member3):
...     print(f"member1 is {member1}")
...     print(f"member2 is {member2}")
...     print(f"member3 is {member3}")
...
>>> print_three_members(member1="Frank", member2="Dean", member3="Sammy")
member1 is Frank
member2 is Dean
member3 is Sammy

>>> print_three_members(member1="Frank", member3="Dean", member2="Sammy")
member1 is Frank
member2 is Sammy
member3 is Dean

>>> print_three_members("Frank", "Dean", "Sammy")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: print_three_members() takes 0 positional arguments but 3 were given

>>> print_three_members("Frank", member3="Dean", member2="Sammy")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: print_three_members() takes 0 positional arguments
but 1 positional argument (and 2 keyword-only arguments) were given

Ваша функция print_three_members() принимает аргументы только по ключевым словам. Ваши первые два вызова успешно передают все аргументы по ключевым словам. Каждый из ваших последних двух вызовов приводит к TypeError, потому что вы передавали аргументы по позиции. Размещение звездочки в качестве первого параметра означает, что вы должны указать все аргументы в качестве ключевых слов. В сообщениях об ошибках указывается, где вы допустили ошибку.

Можете ли вы написать функцию, которая принимает только позиционные аргументы?

В Python любой аргумент, который не передается по ключевому слову, передается по позиции. Позиционные аргументы необходимо передавать в том же порядке, в котором вы определили их параметры в заголовке функции. Позиционные аргументы всегда передаются перед ключевыми аргументами. Некоторые встроенные функции Python требуют, чтобы вы передавали все аргументы по позиции. В Python 3.8 и более поздних версиях вы также можете применить это в своих собственных функциях.

Ранее вы видели, как вы должны передавать любые аргументы для параметров, определенных перед косой чертой, по позиции. Чтобы написать функцию, которая принимает только позиционные аргументы, вы определяете специальный параметр косой черты last:

>>> def print_three_members(member1, member2, member3, /):
...     print(f"member1 is {member1}")
...     print(f"member2 is {member2}")
...     print(f"member3 is {member3}")

>>> print_three_members("Frank", "Dean", "Sammy")
member1 is Frank
member2 is Dean
member3 is Sammy

>>> print_three_members(member1="Frank", member2="Sammy", member3="Dean")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: print_three_members() got some positional-only arguments
passed as keyword arguments: 'member1, member2, member3'

>>> print_three_members("Frank", "Dean", member3="Sammy")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: print_three_members() got some positional-only arguments
passed as keyword arguments: 'member3'

На этот раз вы можете пройти только member1, member2, и member3 по положению. Первый вызов соответствует этому критерию и работает, в то время как остальные завершаются неудачей, поскольку вы пытались использовать аргументы ключевого слова. И снова сообщения об ошибках указывают вам правильный путь.

Связана ли голая звездочка с *args?

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

 

Перед дальнейшим чтением вы, возможно, захотите ознакомиться со значением параметра *args функции. Предположим, вы пишете функцию get_average(), как показано ниже:

>>> def get_average(*args):
...     print(args)
...     return sum(args) / len(args)
...

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

Примечание: Звездочка является важной частью обозначения *args. Название args - это просто условное обозначение, которое обычно используется. Вы можете использовать любое имя переменной вместо args, если это улучшает читаемость вашего кода. Например, вы могли бы преобразовать get_average(), чтобы использовать *numbers и numbers вместо *args и args соответственно.

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

>>> get_average(1, 2, 3)
(1, 2, 3)
2.0

>>> get_average(1, 3, 5, 7, 9)
(1, 3, 5, 7, 9)
5.0

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

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

Предположим, вы решили поэкспериментировать с вашей функцией print_three_members(), заменив звездочку на *args и переименовав ее в print_varying_members():

>>> def print_varying_members(member1, member2, *args, member3):
...     print(f"member1 is {member1}")
...     print(f"member2 is {member2}")
...     print(f"member3 is {member3}")
...     print(f"*args contains {args}")

В этом примере вы можете передать аргументы, соответствующие параметрам member1 и member2 по позиции, и любое превышение будет помещено в кортеж args. Однако вы можете передавать аргументы только для member3 по ключевому слову:

>>> print_varying_members("Frank", member2="Dean", member3="Sammy")
member1 is Frank
member2 is Dean
member3 is Sammy
*args contains ()

Это работает, потому что, хотя параметры member1 и member2 содержат комбинацию позиционных аргументов и ключевых слов, вы сначала передали позиционные аргументы. Кортеж args пуст, потому что вы не передавали никаких дополнительных аргументов, кроме определенных параметров. Передача всего по ключевому слову также работает, как и раньше:

>>> print_varying_members(member1="Frank", member2="Dean", member3="Sammy")
member1 is Frank
member2 is Dean
member3 is Sammy
*args contains ()

На этот раз вы можете назначить первые два аргумента ключевого слова. Вы выполнили обязательное требование к аргументу ключевого слова для member3. По той же причине, что и ранее, кортеж args по-прежнему пуст. Однако, если вы немного отклонитесь, все пойдет совсем не так:

>>> print_varying_members(member1="Frank", "Dean", member3="Sammy")
  File "<stdin>", line 1
    print_varying_members(member1="Frank", "Dean", member3="Sammy")
                                                                ^
SyntaxError: positional argument follows keyword argument

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

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

>>> print_varying_members("Frank", "Dean", "Peter", "Joey", member3="Sammy")
member1 is Frank
member2 is Dean
member3 is Sammy
*args contains ('Peter', 'Joey')

На этот раз вы передали четыре позиционных аргумента, включая обязательный аргумент ключевого слова member3. Ваш код надежно упаковал два дополнительных позиционных аргумента в кортеж args. Попробуйте заменить четвертый позиционный аргумент именованным аргументом типа member4="Joey". Параметр *args не может хранить этот дополнительный именованный аргумент нигде, поэтому ваш код завершит работу с ошибкой.

Можете ли Вы использовать Asterisk Без других Параметров?

Звездочка предназначена для того, чтобы заставить вас передавать все последующие аргументы по ключевому слову. Если вы используете ее отдельно, то последующих параметров для приема этих аргументов не будет. Как вы можете видеть ниже, вы не пройдете дальше строки определения функции:

>>> def print_three_members(*):
  File "<stdin>", line 1
    def print_three_members(*):
                            ^
SyntaxError: named arguments must follow bare *

Если вы попытаетесь написать функцию, используя только звездочку, то все, что вам удастся сделать, - это создать SyntaxError. Забудь об этом!

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

Можете ли вы использовать как звездочку, так и косую черту в определении функции?

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

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

Чтобы увидеть это в действии, предположим, вы написали функцию с именем print_four_members(), которая содержит косую черту и звездочку в правильном порядке:

>>> def print_four_members(member1, member2, /, member3, *, member4):
...     print(f"member1 is {member1}")
...     print(f"member2 is {member2}")
...     print(f"member3 is {member3}")
...     print(f"member4 is {member4}")
...

В приведенном выше примере вы должны передать аргументы для member1 и member2 по позиции из-за косой черты. Вы можете передать аргумент member3 либо по ключевому слову, либо по позиции, в то время как вы должны передать member4 по ключевому слову. Далее вы выполняете различные тестовые примеры:

>>> print_four_members("Frank", "Dean", member3="Sammy", member4="Joey")
member1 is Frank
member2 is Dean
member3 is Sammy
member4 is Joey

Как вы можете видеть, все работает так, как ожидалось. Попробуйте передать аргумент "Sammy" по позиции для себя, и вы получите тот же результат.

Теперь попробуйте задать косую черту и звездочку наоборот. У вас получится SyntaxError:

>>> def print_four_members(member1, member2, *, member3, /, member4):
  File "<stdin>", line 1
    def print_four_members(member1, member2, *, member3, /, member4):
                                                         ^
SyntaxError: / must be ahead of *

Ваше определение функции здесь недопустимо, потому что звездочка заставляет вас передавать все последующие параметры по ключевому слову, в то время как / заставляет вас передавать предыдущие параметры по позиции. Возникает путаница в том, как вы собираетесь передавать member3. Python тоже не знает, поэтому отказывается от этого! Как напоминает вам сообщение об ошибке, косая черта должна стоять перед звездочкой.

Расположив оба специальных оператора вместе в правильном порядке, вы можете сделать все, что находится слева от косой черты, доступным только по позиции, а все, что находится справа от звездочки, доступным только по ключевому слову. Больше ничего не возможно:

>>> def print_three_members(member1, member2, /, *, member3):
...     print(f"member1 is {member1}")
...     print(f"member2 is {member2}")
...     print(f"member3 is {member3}")
...
>>> print_three_members("Frank", "Dean", member3="Sammy")
member1 is Frank
member2 is Dean
member3 is Sammy

>>> print_three_members("Frank", "Dean", "Sammy")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: print_three_members() takes 2 positional arguments but 3 were given

>>> print_three_members("Frank", member2="Dean", member3="Sammy")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: print_three_members() got some positional-only arguments
passed as keyword arguments: 'member2'

Когда вы экспериментируете с приведенным выше кодом, вы должны передать первые два аргумента по позиции, а третий - по ключевому слову. Как вы можете видеть, попытка любым другим способом просто не сработает.

Как и следовало ожидать, их повторное смешивание вызывает SyntaxError:

>>> def print_three_members(member1, member2, *, /, member3):
  File "<stdin>", line 1
    def print_three_members(member1, member2, *, /, member3):
                                                 ^
SyntaxError: / must be ahead of *

Почему бы не попробовать какие-нибудь другие комбинации, чтобы закрепить свое понимание этих правил?

Можете ли вы использовать и *args, и звездочку вместе?

Напомним, что параметр *args и простой параметр asterisk оба заставляют вас передавать все последующие аргументы по ключевому слову. Если вы попытаетесь использовать *args либо до, либо после звездочки, то появится SyntaxError:

>>> def print_three_members(member1, member2, *args, *, member3):
  File "<stdin>", line 1
    def print_three_members(member1, member2, *args, *, member3):
                                                     ^
SyntaxError: * argument may appear only once

>>> def print_three_members(member1, member2, *, *args, member3):
  File "<stdin>", line 1
    def print_three_members(member1, member2, *, *args, member3):
                                                 ^
SyntaxError: * argument may appear only once

Синтаксическая ошибка возникает из-за того, что Python недоволен тем, что ему приходится дважды указывать вам на передачу всех последующих аргументов по ключевому слову. В сообщении об ошибке напоминается, что необходимо использовать одну звездочку один раз.

Зачем Вам использовать специальные параметры в Вашей функции?

Существует несколько причин, по которым вам может потребоваться это сделать: чтобы компенсировать неправильно указанные параметры, обеспечить обратную совместимость и предоставить внутреннюю документацию.

Одно из общих преимуществ принудительного использования позиционных аргументов заключается в том, что имена параметров вашей функции не указывают четко на их назначение. Раскрытие этих имен пользователям, чтобы разрешить передачу ключевых слов, приведет к нечитаемому коду и запутает пользователя.

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

>>> def username(fn, ln, /):
...     return ln + fn[0]
...
>>> print(username("Frank", "Sinatra"))
SinatraF

>>> print(username(fn="Frank", ln="Sinatra"))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: username() got some positional-only arguments
passed as keyword arguments: 'fn, ln'

Чтобы убедиться, что ваша функция username() принимает аргументы только по позиции, вы используете косую черту в качестве последнего параметра. Как вы можете видеть, если вы попытаетесь передать аргументы по их ключевым словам, вызов завершится ошибкой. Сам вызов функции не очень понятен из-за неправильно выбранных параметров.

Но даже если у вашей функции есть два параметра с неправильными именами, они всегда скрыты от пользователя. Как настоящий читатель Python, который знает, что важна читаемость , вы, вероятно, воспользуетесь возможностью обновить их, но это может повлечь за собой множество обновлений и в теле функции. Это само по себе может привести к проблемам. Грамотное использование косой черты позволило избежать необходимости в этом.

Вторым распространенным вариантом использования является обратная совместимость. Предположим, что в большом количестве кода используется ваша исходная функция username(), но вы решили ее улучшить. В дополнение к неопределенным названиям параметров, теперь у вас есть проблема обеспечения обратной совместимости новой версии с предыдущей. Предположим, вы обновили свою функцию следующим образом:

>>> def username(fn, ln, /, *, initial_last=True):
...     if initial_last:
...         return ln + fn[0]
...     else:
...         return fn[0] + ln
...

В обновленной версии username() по-прежнему требуются два позиционных аргумента, но в ней предусмотрена возможность использования ключевого слова initial_last. К счастью, initial_last - это разумное название, поэтому пользователи не поймут его неправильно. Поскольку initial_last имеет значение по умолчанию, этот параметр необязателен. Однако, если вы не хотите использовать значение по умолчанию False, вы должны передать ему свой аргумент с помощью ключевого слова.

Сначала вы решаете протестировать функцию, чтобы убедиться, что она действительно обратно совместима:

>>> username("Frank", "Sinatra")
SinatraF

С облегчением вы видите, что ответ идентичен тому, который вы дали ранее. Мотивированный, вы решаете протестировать новую функциональность:

>>> username("Frank", "Sinatra", initial_last=False)
FSinatra

В качестве примера теста вы решили передать initial_last=False по ключевому слову. Опять же, оба результата выглядят нормально.

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

>>> username(fn="Frank", ln="Sinatra", initial_last=False)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: username() got some positional-only arguments
passed as keyword arguments: 'fn, ln'

На этот раз код завершает работу с ошибкой. Это хорошо, потому что вы все равно не хотели, чтобы ваши пользователи использовали вашу функцию таким образом.

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

Заключение

Из этого урока вы узнали, что косая черта (/) и звездочка (*) означают нечто большее, чем просто деление и умножение. Специальный параметр с косой чертой позволяет принудительно использовать определенные аргументы в соответствии с позицией, в то время как простая звездочка принудительно использует некоторые аргументы в соответствии с ключевым словом. Когда вы используете оба символа вместе, косая черта должна быть первой, а любые параметры, определенные между ними, могут принимать позиционные аргументы или аргументы ключевого слова.

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

Что вам больше всего понравилось из того, что вы узнали? Как вы собираетесь использовать свои новообретенные навыки? Оставьте комментарий ниже и сообщите об этом сообществу.

Получите свой код: Нажмите здесь, чтобы загрузить бесплатный пример кода для использования звездочки и косой черты в качестве специальных параметров в ваших функциях Python .

<статус завершения: article-slug="python-asterisk-and-slash-special-parameters" class="btn-group mb-0" data-api-article-bookmark-url="/api/v1/articles/python-asterisk-и-косая черта-специальные-параметры/закладка/" data-api-article-completion-status-url="/api/v1/articles/python-asterisk-and-slash-special-parameters/completion_status/"> <кнопка поделиться bluesky-текстом="Интересная статья на #Python от @realpython.com :" email-body="Ознакомьтесь с этой статьей о Python:%0A%0A Для чего нужны специальные параметры Python Asterisk и Slash?" email-subject="Статья о Python для вас" twitter-text="Интересная статья на #Python от @realpython:" url="https://realpython.com/python-asterisk-and-slash-special-parameters/" url-title="Для чего нужны специальные параметры Python Asterisk и Slash?">

Back to Top