Как использовать необязательные параметры в Python?

[

Использование необязательных аргументов Python при определении функций

Автор: Stephen Gruppetta

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

В этом руководстве вы узнаете:

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

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

Создание функций в Python для повторного использования кода

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

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

Использование функций позволяет расширить ваш словарный запас Python. Это позволяет вам выразить решение вашей проблемы более ясно и лаконично.

В Python по соглашению вы должны именовать функцию с использованием строчных букв с словами, разделенными подчеркиванием, например сделать_что-то(). Эти соглашения описаны в PEP 8, который является руководством по стилю Python. После имени функции вам нужно добавить скобки при ее вызове. Поскольку функции представляют собой действия, является хорошей практикой начинать их имена с глагола, чтобы ваш код был более читаемым.

Определение функций без передаваемых параметров

Начнем с создания списка покупок:

shopping_list = {
    "Хлеб": 1,
    "Молоко": 2,
    "Шоколад": 1,
    "Масло": 1,
    "Кофе": 1,
}

Чтобы определить функцию, которая напечатает ваш список покупок, вам понадобится использовать конструкцию def, а затем указать имя функции и параметры, если они есть. Мы начнем с определения функции print_shopping_list, которая не будет принимать никаких параметров:

def print_shopping_list():
    for item, quantity in shopping_list.items():
        print(f"Товар: {item}, количество: {quantity}")

print_shopping_list()

Вывод:

Товар: Хлеб, количество: 1
Товар: Молоко, количество: 2
Товар: Шоколад, количество: 1
Товар: Масло, количество: 1
Товар: Кофе, количество: 1

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

Определение функций с обязательными аргументами

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

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

def greet(name):
    print(f"Привет, {name}!")

greet("Алексей") # Привет, Алексей!

Все, что вы передаете в качестве аргумента при вызове функции, помещается в соответствующий параметр в самой функции. В нашем случае имя “Алексей” выполнит функцию greet, и она напечатает “Привет, Алексей!”

Использование необязательных аргументов Python с значениями параметров по умолчанию

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

Давайте рассмотрим пример функции greet с необязательным аргументом age, который имеет значение по умолчанию None. Если значение age не будет передано при вызове функции, оно будет равно None. В противном случае, функция будет использовать переданное ей значение.

def greet(name, age=None):
    if age:
        print(f"Привет, {name}! Тебе {age} лет.")
    else:
        print(f"Привет, {name}!")

greet("Алексей") # Привет, Алексей!
greet("Мария", 28) # Привет, Мария! Тебе 28 лет.

В первом вызове функции мы не передаем аргумент age, поэтому он использует значение по умолчанию и печатает “Привет, Алексей!“. Во втором вызове мы передаем аргумент age, поэтому он использует переданное значение и печатает “Привет, Мария! Тебе 28 лет.”

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

Значения параметров по умолчанию

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

def greet(name, age=None, city=None):
    if age and city:
        print(f"Привет, {name}! Тебе {age} лет. Ты из города {city}.")
    elif age:
        print(f"Привет, {name}! Тебе {age} лет.")
    elif city:
        print(f"Привет, {name}! Ты из города {city}.")
    else:
        print(f"Привет, {name}!")

greet("Алексей") # Привет, Алексей!
greet("Мария", 28) # Привет, Мария! Тебе 28 лет.
greet("Иван", city="Москва") # Привет, Иван! Ты из города Москва.
greet("Катя", 25, "Санкт-Петербург") # Привет, Катя! Тебе 25 лет. Ты из города Санкт-Петербург.

В этом примере функция greet принимает три аргумента: name, age и city. name является обязательным аргументом, который всегда должен быть передан при вызове функции. age и city - необязательные аргументы с значениями по умолчанию None.

Функция проверяет, какие аргументы были переданы, и в зависимости от этого выводит соответствующее приветствие.

Типы данных, которые не следует использовать в качестве значений аргументов по умолчанию

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

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

Рассмотрим пример функции, которая принимает числовой аргумент multiplier и список numbers, который имеет значение по умолчанию [1, 2, 3]. Функция умножает каждое число в списке на multiplier и возвращает новый список с результатами:

def multiply_numbers(multiplier, numbers=[1, 2, 3]):
    return [num * multiplier for num in numbers]

print(multiply_numbers(2)) # [2, 4, 6]
print(multiply_numbers(3)) # [3, 6, 9]

В первом вызове функции мы передаем только аргумент multiplier, поэтому список numbers остается равным [1, 2, 3]. Во втором вызове мы передаем значения multiplier и новый список [3, 4, 5], и возвращается новый список с умноженными значениями.

Однако, если мы вызовем функцию несколько раз без передачи нового списка numbers, он будет использовать значение по умолчанию [1, 2, 3]. В результате у нас может возникнуть нежелательное поведение, так как список изменяемого типа сохраняется между вызовами функции.

Наилучшей практикой является использование неизменяемых типов данных, таких как строки или числа, в качестве значений аргументов по умолчанию.

Сообщения об ошибках, связанные с аргументами

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

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

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

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

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

Использование args и kwargs

Кроме того, Python предоставляет возможность определять функции, которые могут принимать любое количество аргументов или любое количество аргументов-ключевых слов. Для этого используются args и kwargs.

Функции, принимающие любое количество аргументов

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

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

def sum_all_numbers(*args):
    result = 0
    for num in args:
        result += num
    return result

print(sum_all_numbers(1, 2, 3)) # 6
print(sum_all_numbers(10, 20, 30, 40)) # 100

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

Функции, принимающие любое количество аргументов-ключевых слов

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

Рассмотрим пример функции print_person_info, которая принимает любое количество аргументов-ключевых слов, содержащих информацию о человеке, и выводит эту информацию:

def print_person_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_person_info(name="John", age=30, city="New York")

Вывод:

name: John
age: 30
city: New York

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

Заключение

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

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