Как сделать значение по умолчанию python
Обновлено: 04.07.2024
В этой статье я планирую рассказать о функциях, именных и анонимных, инструкциях def, return и lambda, обязательных и необязательных аргументах функции, функциях с произвольным числом аргументов.
Именные функции, инструкция def
Функция в python - объект, принимающий аргументы и возвращающий значение. Обычно функция определяется с помощью инструкции def.
Определим простейшую функцию:
Инструкция return говорит, что нужно вернуть значение. В нашем случае функция возвращает сумму x и y.
Теперь мы ее можем вызвать:
Функция может быть любой сложности и возвращать любые объекты (списки, кортежи, и даже функции!):
Функция может и не заканчиваться инструкцией return, при этом функция вернет значение None:
Аргументы функции
Функция может принимать произвольное количество аргументов или не принимать их вовсе. Также распространены функции с произвольным числом аргументов, функции с позиционными и именованными аргументами, обязательными и необязательными.
Функция также может принимать переменное количество позиционных аргументов, тогда перед именем ставится *:
Как видно из примера, args - это кортеж из всех переданных аргументов функции, и с переменной можно работать также, как и с кортежем.
Функция может принимать и произвольное число именованных аргументов, тогда перед именем ставится **:
В переменной kwargs у нас хранится словарь, с которым мы, опять-таки, можем делать все, что нам заблагорассудится.
Анонимные функции, инструкция lambda
Анонимные функции могут содержать лишь одно выражение, но и выполняются они быстрее. Анонимные функции создаются с помощью инструкции lambda. Кроме этого, их не обязательно присваивать переменной, как делали мы инструкцией def func():
lambda функции, в отличие от обычной, не требуется инструкция return, а в остальном, ведет себя точно так же:
Для определения функции нужно всего лишь написать ключевое слово def перед ее именем, а после — поставить двоеточие. Следом идет блок инструкций.
Последняя строка в блоке инструкций может начинаться с return , если нужно вернуть какое-то значение. Если инструкции return нет, тогда по умолчанию функция будет возвращать объект None . Как в этом примере:
Функция инкрементирует глобальную переменную i и возвращает None (по умолчанию).
Вызовы
Для вызова функции, которая возвращает переменную, нужно ввести:
Для вызова функции, которая ничего не возвращает:
Функцию можно записать в одну строку, если блок инструкций представляет собой простое выражение:
Функции могут быть вложенными:
Функции — это объекты, поэтому их можно присваивать переменным.
Инструкция return
Возврат простого значения
Аргументы можно использовать для изменения ввода и таким образом получать вывод функции. Но куда удобнее использовать инструкцию return , примеры которой уже встречались ранее. Если ее не написать, функция вернет значение None .
Возврат нескольких значений
Пока что функция возвращала только одно значение или не возвращала ничего (объект None). А как насчет нескольких значений? Этого можно добиться с помощью массива. Технически, это все еще один объект. Например:
Аргументы и параметры
В функции можно использовать неограниченное количество параметров, но число аргументов должно точно соответствовать параметрам. Эти параметры представляют собой позиционные аргументы. Также Python предоставляет возможность определять значения по умолчанию, которые можно задавать с помощью аргументов-ключевых слов.
Параметр — это имя в списке параметров в первой строке определения функции. Он получает свое значение при вызове. Аргумент — это реальное значение или ссылка на него, переданное функции при вызове. В этой функции:
x и y — это параметры, а в этой:
При определении функции параметры со значениями по умолчанию нужно указывать до позиционных аргументов:
Если использовать необязательный параметр, тогда все, что указаны справа, должны быть параметрами по умолчанию.
Выходит, что в следующем примере допущена ошибка:
Для вызовов это работает похожим образом. Сначала нужно указывать все позиционные аргументы, а только потом необязательные:
На самом деле, следующий вызов корректен (можно конкретно указывать имя позиционного аргумента), но этот способ не пользуется популярностью:
А этот вызов некорректен:
При вызове функции с аргументами по умолчанию можно указать один или несколько, и порядок не будет иметь значения:
Можно не указывать ключевые слова, но тогда порядок имеет значение. Он должен соответствовать порядку параметров в определении:
Если ключевые слова не используются, тогда нужно указывать все аргументы:
Второй аргумент можно пропустить:
Чтобы обойти эту проблему, можно использовать словарь:
Значение по умолчанию оценивается и сохраняется только один раз при определении функции (не при вызове). Следовательно, если значение по умолчанию — это изменяемый объект, например, список или словарь, он будет меняться каждый раз при вызове функции. Чтобы избежать такого поведения, инициализацию нужно проводить внутри функции или использовать неизменяемый объект:
Еще один пример изменяемого объекта, значение которого поменялось при вызове:
Дабы не допустить изменения оригинальной последовательности, нужно передать копию изменяемого объекта:
Указание произвольного количества аргументов
Позиционные аргументы
Иногда количество позиционных аргументов может быть переменным. Примерами таких функций могут быть max() и min() . Синтаксис для определения таких функций следующий:
При вызове функции нужно вводить команду следующим образом:
Python обрабатывает позиционные аргументы следующим образом: подставляет обычные позиционные аргументы слева направо, а затем помещает остальные позиционные аргументы в кортеж (*args), который можно использовать в функции.
Если лишние аргументы не указаны, значением по умолчанию будет пустой кортеж.
Произвольное количество аргументов-ключевых слов
Как и в случае с позиционными аргументами можно определять произвольное количество аргументов-ключевых слов следующим образом (в сочетании с произвольным числом необязательных аргументов из прошлого раздела):
При вызове функции нужно писать так:
Python обрабатывает аргументы-ключевые слова следующим образом: подставляет обычные позиционные аргументы слева направо, а затем помещает другие позиционные аргументы в кортеж (*args), который можно использовать в функции (см. предыдущий раздел). В конце концов, он добавляет все лишние аргументы в словарь (**kwargs), который сможет использовать функция.
Важно, что пользователь также может использовать словарь, но перед ним нужно ставить две звездочки (**):
Порядок вывода также не определен, потому что словарь не отсортирован.
Документирование функции
Если изучить ее, обнаружатся два скрытых метода (которые начинаются с двух знаков нижнего подчеркивания), среди которых есть __doc__ . Он нужен для настройки документации функции. Документация в Python называется docstring и может быть объединена с функцией следующим образом:
Команда docstring должна быть первой инструкцией после объявления функции. Ее потом можно будет извлекать или дополнять:
Методы, функции и атрибуты, связанные с объектами функции
Если поискать доступные для функции атрибуты, то в списке окажутся следующие методы (в Python все является объектом — даже функция):
И несколько скрытых методов, функций и атрибутов. Например, можно получить имя функции или модуля, в котором она определена:
Есть и другие. Вот те, которые не обсуждались:
Рекурсивные функции
Рекурсия — это не особенность Python. Это общепринятая и часто используемая техника в Computer Science, когда функция вызывает сама себя. Самый известный пример — вычисление факториала n! = n * n — 1 * n -2 * … 2 *1. Зная, что 0! = 1, факториал можно записать следующим образом:
Другой распространенный пример — определение последовательности Фибоначчи:
Важно, чтобы в ней было была конечная инструкция, иначе она никогда не закончится. Реализация вычисления факториала выше, например, не является надежной. Если указать отрицательное значение, функция будет вызывать себя бесконечно. Нужно написать так:
Важно!
Рекурсия позволяет писать простые и элегантные функции, но это не гарантирует эффективность и высокую скорость исполнения.
Если рекурсия содержит баги (например, длится бесконечно), функции может не хватить памяти. Задать максимальное значение рекурсий можно с помощью модуля sys .
Глобальная переменная
Вот уже знакомый пример с глобальной переменной:
Здесь функция увеличивает на 1 значение глобальной переменной i . Это способ изменять глобальную переменную, определенную вне функции. Без него функция не будет знать, что такое переменная i . Ключевое слово global можно вводить в любом месте, но переменную разрешается использовать только после ее объявления.
За редкими исключениями глобальные переменные лучше вообще не использовать.
Присвоение функции переменной
С существующей функцией func синтаксис максимально простой:
Переменным также можно присваивать встроенные функции. Таким образом позже есть возможность вызывать функцию другим именем. Такой подход называется непрямым вызовом функции.
Менять название переменной также разрешается:
В этом примере a1, a2 и func имеют один и тот же id. Они ссылаются на один объект.
Практический пример — рефакторинг существующего кода. Например, есть функция sq , которая вычисляет квадрат значения:
Позже ее можно переименовать, используя более осмысленное имя. Первый вариант — просто сменить имя. Проблема в том, что если в другом месте кода используется sq , то этот участок не будет работать. Лучше просто добавить следующее выражение:
Последний пример. Предположим, встроенная функция была переназначена:
Теперь к ней нельзя получить доступ, а это может стать проблемой. Чтобы вернуть ее обратно, нужно просто удалить переменную:
Анонимная функция: лямбда
Лямбда-функция — это короткая однострочная функция, которой даже не нужно имя давать. Такие выражения содержат лишь одну инструкцию, поэтому, например, if , for и while использовать нельзя. Их также можно присваивать переменным:
В отличие от функций, здесь не используется ключевое слово return . Результат работы и так возвращается.
С помощью type() можно проверить тип:
На практике эти функции редко используются. Это всего лишь элегантный способ записи, когда она содержит одну инструкцию.
Изменяемые аргументы по умолчанию
Напомним, что аргумент может быть необязательным. У такого аргумента есть значение по умолчанию.
Например, функция parent_for() , которую вы использовали в некоторых упражнениях, принимает имя ребёнка первым аргументом, а вторым — строку 'mother' или 'father' . Второй аргумент — необязательный, и если не указывать его, то автоматически по умолчанию будет использоваться 'mother' .
Эти два вызова равнозначны:
Каким образом там сделаны аргументы по умолчанию? Давайте заглянем в определение этой функции:
Первый аргумент указан привычно — просто название переменной. Это делает аргумент обязательным.
Второй аргумент указан со значением в формате аргумент=какое_то_значение . Точно так же, как при создании переменной. Этот фрагмент =какое_то_значение делает аргумент необязательным, и задаёт ему значение по умолчанию.
Аргументов по умолчанию может быть любое количество, но все они должны быть в конце списка аргументов. То есть такие строчки кода синтаксически некорректны:
- def parent_for(child_name='Jon', who):
- def calculate(a, b=90, c):
- def get_prices(code=4161, quantity, place):
Задание
Реализуйте функцию get_hidden_card() , которая принимает на вход номер кредитки (состоящий из 16 цифр) в виде строки и возвращает его скрытую версию, которая может использоваться на сайте для отображения. Если исходная карта имела номер 2034399002125581, то скрытая версия выглядит так ****5581. Другими словами, функция заменяет первые 12 символов, на звездочки. Количество звездочек регулируется вторым необязательным параметром. Значение по умолчанию — 4.
Для выполнения задания вам понадобится метод строки .rjust(), который заполняет строку указанным наполнителем.
Если вы столкнулись с трудностями и не знаете, что делать, задайте вопрос в нашем большом и дружном сообществе
В предыдущих разделах мы уже часто сталкивались с встроенными функция ( int, float, print, type, len ) Каждая функция в Python предназначена для выполнения одной конкретной задачи. Использование функции упрощает написание и чтение кода.
1. Функция в Python
Если какая то задача выполняется многократно в программе, то не обязательно эту задачу расписывать во всех разделах программы, достаточно поместить код в функцию и в последующем вызывать эту функцию по мере необходимости.
Напишем функцию, которая вычисляет квадрат своего аргумента и выводит на экран:
>>> def square ( number ):
. """Вычисление квадрата числа"""
. print(number ** 2)
.
>>> square (5)
25
>>> square (124.45)
15487.802500000002
Определение функции начинается с ключевого слова def , за которым следует имя функции - square . Имя функции, как и имена переменных рекомендуется писать с букв нижнего регистра, а в именах, состоящих из нескольких слов, составляющие должны разделяться символами подчеркивания. Далее в круглых скобках записываются параметры (аргументы) функции, разделенные запятыми. Функция square имеет только один аргумент с именем number - значение, возводимое в квадрат. В случае отсутствия параметров у функции пустые круглые скобки обязательны. В конце строки за параметрами всегда ставится двоеточие ( : ).
После двоеточия новая строка должна идти с отступом (4 пробела). Все строки с отступом образуют тело или блок функции. В "Руководстве по стилю кода Python" указано, что первой строкой блока функции должна быть doc-строка, кратко поясняющая назначение функции: """Вычисление квадрата числа""" . Сам код в теле функции состоит всего из одной строки print(number ** 2).
Команда squre(5) вызывает функции square() и передает ей значение аргумента, для выполнения команды print. Функция возводит число в квадрат и выводит на экран.
2. Передача аргументов функции в Python
2.1. Позиционные аргументы
Функция может иметь несколько параметров и при её вызове должно передаваться сразу несколько аргументов. Напишем функцию, которая выводит название автомобиля, модель и его пробег:
>>> def car (car_brend, car_model, mileage):
. """Выводит информацию о автомобиле"""
. print(f"Продается с пробегом км.")
.
>>> car ('bmw', 'x5', 51345)
Продается Bmw X5 с пробегом 51345 км.
В данной функции видно, что должно передаваться три аргумента название автомобиля ( car_brend), модель (car_model) и пробег (mileage) . При вызове функции мы должны передать аргументы именно в том порядке, в каком они сохраняются в функции. Если нарушить порядок следования аргументов, то при вызове возможны неожиданные результаты или ошибки.
2.2. Именованные аргументы
Если порядок передачи аргументов по каким то причинам не известен, то можно использовать именованные аргументы. Именованный аргумент представляет собой пару "имя-значение". Имя и значения связываются с аргументом напрямую, так что при передаче аргумента путаница исключается. Вызовем туже самую функцию car() с помощью именованных аргументов:
>>> def car (car_brend, car_model, mileage):
. """Выводит информацию о автомобиле"""
. print(f"Продается с пробегом км.")
.
>>> car (mileage = 45152, car_model = 'x5', car_brend='bmw')
Продается Bmw X5 с пробегом 45152 км.
При обработке вызова функции Python знает к какому аргументу принадлежат данные и проблем с выводом не случается.
2.3. Значения по умолчанию
Для каждого параметра функции можно определить значение по умолчанию. Если при вызове функции не был передан аргумент, то используется значение по умолчанию. Все значение по умолчанию всегда должны следовать после параметров, у которых значений по умолчанию нет. Приведем пример той же функции, но тип автомобиля будем использовать по умолчанию
>>> def car (car_model, mileage, car_brend='bmv'):
. """Выводит информацию о автомобиле"""
. print(f"Продается с пробегом км.")
.
>>> car ('x7', 12345)
Продается Bmv X7 с пробегом 12345 км.
>>> car ('m5' , 56148)
Продается Bmv M5 с пробегом 56148 км.
Для изменения значения по умолчанию, мы можем передать именованный аргумент для изменения значения car_brend='audi':
>>> car ('q7', 35600, car_brend='audi')
Продается Audi Q7 с пробегом 35600 км.
Так как аргумент для параметра car_brend задан явно, Python игнорирует значение по умолчанию.
2.4. Передача произвольного набора аргументов
Иногда заранее не известно сколько аргументов должно быть передано функции, Python позволяет получить произвольное количество аргументов из вызывающей команды. Рассмотрим функцию, которая просто передает любое количество аргументов, к примеру название автомобилей:
>>> def cars ( * args ):
. """Вывод автомобилей"""
. print( args )
.
>>> cars ('audi', 'bmv', 'ford', 'kia')
('audi', 'bmv', 'ford', 'kia')
>>> cars ('porshe')
('porshe')
Звездочка в имени параметра args приказывает создать Python пустой кортеж с именем args и упаковать в него все полученные результаты и с помощью команды print вывести на экран. В примере видно, что функция работает и при передаче четырех и при передаче одного аргумента.
Для более удобной работы с данными, например изменения регистра символов можно воспользоваться циклом for:
>>> def cars ( * args):
. """Вывод автомобилей в продаже"""
. print('Автомобили в продаже:')
. for arg in args:
. print(f"-")
.
>>> cars ('audi', 'bmv', 'ford', 'kia')
Автомобили в продаже:
-Audi
-Bmv
-Ford
-Kia
2.5. Позиционные аргументы с произвольным набором аргументов
В случае, когда в функции есть позиционные аргументы и произвольные, параметр получения произвольного количества аргументов должен стоять на последнем месте. Python сначала подберет соответствия для позиционных и именных аргументов, а потом объединит все остальные аргументы в последний параметр colors:
>>> def car (car_brend, car_model, * colors):
. """Выводит информацию о автомобиле"""
. print(f"Автомобиль можно заказать в цветах:")
. for color in colors:
. print(f"-")
.
>>> car ('bmw', 'x7', 'синий', 'зеленый', 'белый', 'черный', 'желтый')
Автомобиль Bmw X7 можно заказать в цветах:
-синий
-зеленый
-белый
-черный
-желтый
В результате данная функция получает два позиционных аргумента car_brend и car_model, а остальные сохраняются в кортеже colors.
В большинстве программ часто используется имя обобщенного параметра *args для хранения произвольного набора позиционных аргументов.
2.6. Произвольный набор именованных аргументов
Иногда может потребоваться, чтобы функция получала произвольное количество именованных аргументов. В таком случае можно написать функцию, которая получает столько пар "ключ-значение", сколько указано в команде вызова. Например, для построение пользовательских профилей, заранее не известно, какую точно информацию предоставит пользователь. Поэтому определим в функции обязательное предоставление имени и фамилии, а остальная информация может быть получена с помощью произвольного количества именованных аргументов:
>>> def profile (first, last, **user_info):
. """Возвращает словарь с данными о пользователе"""
. user_info['first_name'] = first
. user_info['last_name'] = last
. return user_info
.
>>> profile_1 = profile ('tomas', 'edisson', location='usa')
>>> print(profile_1)
Функция profile ожидает получить имя и фамилию пользователя, а также позволяет передать любое количество пар "имя - значение". Две звездочки в параметре **user_info заставляют Python создать пустой словарь с именем user_info и добавить в него все полученные пары "имя - значение". В теле функции сразу добавляются имя и фамилия, а остальные пары в зависимости от переданных параметров при вызове фукции. В конце словарь возвращается с помощью команды return .
В программах часто используется имя обобщенного параметра **kwargs для хранения произвольного набора ключевых аргументов.
3. Возвращаемое значение в функции на Python
Вместо вывода результата работы напрямую, функция может обработать данные и вернуть значение c помощью команды return . Значение, возвращаемое функцией, называется возвращаемым значением.
3.1. Возвращение простого значения
Напишем функцию, которая возвращает отформатированное имя и фамилию
>>> def form_name (last_name, first_name, middle_name):
. """Возвращает отформатированное полное имя"""
. full_name = f" "
. return full_name.title()
.
>>> poet = form_name ('пушкин', 'александр', 'сергеевич')
>>> print(poet)
Пушкин Александр Сергеевич
Функция form_name получает в параметрах имя, фамилию и отечество, далее объединяет эти имена и сохраняет их в переменной full_name. Завершив выполнение, функция возвращает управление в точку вызова с помощью команды return , то есть в строку кода, которая вызывала функцию.
Предположим, что мы не знаем отчество человека, для передачи его фукции параметру middle_name. В связи с этим удобно заранее сделать в функции необязательный аргумент . Присвоим ( middle_name = "" ) пустое значение.
>>> def form_name (last_name, first_name, middle_name=''):
. """Возвращает отформатированное полное имя"""
. full_name = f" "
. return full_name.title()
.
>>> poet = form_name ('пушкин', 'александр')
>>> print(poet)
Пушкин Александр
>>> poet = form_name('пушкин', 'александр', 'сергеевич')
>>> print(poet)
Пушкин Александр Сергеевич
С необязательным аргументом мы не получим ошибку (TypeError: form_name() missing 1 required positional argument: 'middle_name') в случае отсутствия на входе данных по аргументу.
3.2. Возвращение словаря
Функция может возвращать и более сложную структуру данных, например словарь или список. Напишем функцию, которая будет возвращать словарь, представляющий человека:
>>> def info_person (first_name, last_name):
. """Возвращает словарь с данными о человеке"""
. person =
. return person
.
>>> musician = info_person ('Freddie', 'Mercury')
>>> print(musician)
При вызове функции info_person получает имя и фамилию на входе и помещает их сразу в словарь, с ключами имя и фамилия. Затем с помощью команды return возвращает словарь. В будущем со словарем будет удобнее работать, мы сможем отдельно использовать имя, фамилию или другие аргументы функции.
4. Использования функции в цикле while
Функции могут вызываться в циклах while где угодно. Приведем пример цикла while, где у посетителя запрашивают имя и фамилию, а с помощью функции form_name возвращается отформатированное имя и фамилия с приветствием:
def form_name (first_name, last_name):
"""Возвращает отформатированное полное имя"""
full_name = f" "
return full_name.title()
while True:
print("\nВведите 'x' если хотите завершить программу")
first_name = input("Введите ваше имя: ")
if first_name == 'x':
break
last_name = input("Введите вашу фамилию: ")
if last_name == 'x':
break
formatted_name = form_name (first_name, last_name)
print(f"\nДобрый день !")
В данном примере в цикле whle запрашивается имя и фамилия и с помощью функции form_name возвращается отформатированное полное имя и записывается в переменную formatted_name. А затем уже с помощью функции print данные выводятся на экран.
5. Передача списка функции на Python
При передаче аргумента функции мы можем сразу передать список. В результате функция получает доступ сразу ко всему его содержимому. Воспользуемся функцией square которую писали в первом разделе, которая выводит квадрат своего аргумента и немного обновим ее. Но в качестве аргумента мы передадим сразу список чисел, которые нужно обработать и возвести в квадрат.
>>> def square (numbers):
. """Вычисление квадрата числа"""
. for number in numbers:
. print(number ** 2)
.
>>> numbers = [1, 5, 6, 15, -7, 1.5]
>>> square (numbers)
1
25
36
225
49
2.25
В результате функции square мы передаем список numbers. Для возведения всех чисел в квадрат, вначале нам нужно перебрать данный список с помощью цикла for, а затем каждое число возвести в квадрат.
6. Использование лямбда-выражений вместо функций
Для простых функций, например square, который просто вычисляют квадрат числа, можно использовать лямбда-выражения.
>>> square = lambda x : x ** 2
>>> print(square(5))
25
В начале создается переменная square и в дальнейшем по имени переменной будет вызываться лямбда-выражение. Лямбда-выражение является анонимной функцией, то есть функцией, не имеющей имени. Лямбда-выражение начинается с ключевого слова lambda , за которым следует разделенный запятыми список параметров. В нашем примере параметр один x. Затем ставится двоеточие и само выражение x ** 2. В результате при вызове переменной square мы передаем параметр число 5, и оно возводится в квадрат.
Лямбда-выражение может иметь и несколько параметров. Например, перемножать передаваемые числа.
>>> mult = lambda x, y, z : x * y * z
>>> print(mult(2, 4, 6))
48
Таким образом любая простая функция в форме
может быть выражена в более компактной форме посредством лямбда-выражения
Встроенные функции в Python позволяют осуществлять самые разные операции. Каждая из них решает какую-то особую задачу. Но кроме них есть еще функции, которые пишут сами программисты.
В этой статье мы рассмотрим, как создавать и вызывать функции в Python. Также мы коснемся темы передачи параметров и аргументов в функцию.
Что такое функция?
Функция – это изолированный блок кода, который решает отдельную задачу.
Смысл функций в том, что они позволяют избежать ненужного повторения кода. Если какое-то действие повторяется часто и в разных местах, это хороший показатель того, что код для этого действия можно выделить в отдельную функцию.
Функции также помогают организовать ваш код.
Если нужно внести какое-то изменение в код функции, обновить придется только ее. Без функций у вас были бы многократно повторяющиеся куски одинакового кода в разных местах, и обновлять этот код пришлось бы повсюду.
Код внутри функции запускается только тогда, когда функцию вызывают.
Функции могут принимать аргументы и значения по умолчанию. При вызове они могут возвращать какое-то значение в вызвавший их код, но могут и не возвращать ничего.
Определение функции в Python
Базовый синтаксис определения функции выглядит так:
Итак, давайте разберемся:
- def — ключевое слово. Оно сообщает Python, что начинается определение функции.
- Затем идет имя функции. Оно может быть произвольным (ограничения те же, что и для обозначения переменных).
- Далее у нас есть пара круглых скобок () . Внутри них могут быть разделенные запятыми параметры. Для параметров могут указываться дефолтные значения. Количество параметров варьируется: может быть один или несколько, а может и вовсе не быть параметров.
- Затем идет двоеточие : , которое завершает строку определения функции.
- Дальше идет новая строка, начинающаяся с отступа (4 пробела или одно нажатие клавиши tab).
- В этой новой строке после отступа начинается тело функции: код действий, которые должна осуществлять функция при вызове.
- Наконец, в теле функции может быть опциональный оператор return , возвращающий значение вызывающей стороне при выходе из функции.
Имейте в виду, что если вы забудете круглые скобки () или двоеточие : , Python сообщит вам об этом с помощью SyntaxError .
Определение и вызов простой функции в Python
Ниже приведен пример базовой функции. В ней нет оператора return, и никаких параметров она тоже не принимает.
Эта функция просто выводит hello world при каждом вызове.
Когда функция определена, код в ней не запускается сам по себе. Для его выполнения необходимо сделать вызов функции.
Вызывать функцию можно столько раз, сколько вам нужно.
Для вызова функции используется следующий синтаксис:
Сначала пишется имя функции. За ним пишутся круглые скобки. Если функция имеет обязательные аргументы, они должны быть перечислены в скобках. Если аргументов у функции нет, скобки все равно нужно написать, просто они останутся пустыми.
Для вызова функции из нашего примера пишем следующий код:
Как определять и вызывать функции с параметрами в Python
Пока что мы рассмотрели самый базовый вариант функции. Она лишь выводит что-то в консоль.
Но что, если в функцию нужно передать какие-то дополнительные данные?
Здесь мы используем такие термины, как параметры и аргументы.
Параметры – это именованные заполнители. Они работают как переменные, определенные локально в строке объявления функции.
В нашем примере мы указали один параметр — name .
Для форматирования строки мы могли бы использовать f-строки. Код, приведенный ниже, работает точно так же, как и приведенный выше:
Мы можем передать функции столько параметров, сколько душе угодно, разделив их запятыми:
Здесь параметры функции — name и age .
При вызове функции в нее передаются аргументы.
Аргументы — это информация, переданная в функцию. Они представляют собой настоящие значения, соответствующие параметрам, которые были указаны при объявлении функции.
Лаборатория Django-разработки
За 3 месяца отработай навыки Django-разработки до профессионального уровня на серьезном проекте под руководством наставника.
Вызов функции из предыдущего примера и передача аргументов будет выглядеть так:
Функцию можно вызывать многократно, каждый раз передавая разные значения в качестве аргументов:
Аргументы, которые мы рассматривали до сих пор, называются позиционными. Все позиционные аргументы являются обязательными.
Количество позиционных аргументов имеет значение
Когда мы вызываем наши функции, мы должны передавать правильное количество аргументов, иначе мы получим ошибку.
Число передаваемых аргументов при вызове функции должно быть равным числу параметров, указанных при объявлении этой функции. Нельзя ни убавить, ни прибавить.
Скажем, у нас есть функция с двумя параметрами:
Если мы попробуем вызвать эту функцию, передав всего один аргумент, мы получим ошибку:
Если передать три аргумента вместо двух, опять получим ошибку:
И если вообще не передать аргументов, это тоже вызовет ошибку:
Порядок позиционных аргументов тоже важен
В том, что касается позиционных аргументов, значение имеет не только количество, но и порядок следования.
Аргументы должны передаваться в том же порядке, в котором были объявлены параметры при определении функции.
Это работает так же, как присваивание значений переменным.
Первый аргумент в вызове функции используется в качестве значения для первого параметра, второй аргумент – для второго параметра и так далее.
Если порядок будет нарушен, мы можем получить не тот результат, который хотели.
Использование именованных аргументов в функциях в Python
Пока что мы имели дело только с позиционными аргументами. При вызове функций в них передавались только значения. Все эти значения идут по порядку и соответствуют параметрам, указанным при определении функции.
Но в Python есть еще и именованные аргументы.
В этом случае при вызове функции не просто передаются значения. Вы указываете имя параметра, за затем значение, которое хотите ему присвоить (в формате ключ = значение ).
Все ключи совпадают с параметрами, указанными при определении функции.
Явное указание имен параметров и их значений помогает внести дополнительную ясность и избежать возможных недоразумений.
Именованные аргументы, как видим, могут идти в том же порядке, что указан при определении функции. Но в этом плане они гибче позиционных: их порядок не имеет большого значения.
То есть, вы могли бы написать код следующим образом, и это не вызвало бы ошибок:
Но количество передаваемых аргументов имеет значение.
При вызове функции можно использовать одновременно и позиционные, и именованные аргументы. В следующем примере есть один позиционный и один именованный аргумент:
В этом случае порядок опять-таки имеет значение.
Позиционные аргументы всегда идут первыми. Все именованные аргументы должны следовать за позиционными. В противном случае будет ошибка:
Как определять параметр со значением по умолчанию
Аргументы функции также могут иметь значения по умолчанию.
Чтобы аргумент функции имел дефолтное значение, нужно назначить это самое значение параметру при определении функции.
Делается это в формате ключ=значение .
Ранее мы видели, что можем определять функции со значением по умолчанию. Аргументы со значением по умолчанию называются аргументами по умолчанию.
Мы можем вызвать такую функцию, не передавая ей никаких аргументов. Тогда она будет использовать значение по умолчанию, которое мы присвоили при определении функции.
В нашем примере, если не передан аргумент, значением language всегда будет Python .
Значения по умолчанию при желании можно легко перезаписать, указав другое значение при вызове функции:
В функции может быть и несколько значений по умолчанию.
При вызове функции мы можем передать какой-нибудь один аргумент, несколько или даже ни одного. Порядок передачи аргументов не имеет значения.
Аргументы со значениями по умолчанию можно комбинировать с оыбчными.
Давайте рассмотрим другой пример. На этот раз наша функция принимает два аргумента: один позиционный, без значения по умолчанию ( name ), и один необязательный, со значением по умолчанию ( language ).
Мы видим, что аргумент со значением по умолчанию language = "Python" является опциональным. Тогда как позиционный аргумент name всегда будет обязательным. Таким образом, если другой язык не передан, по умолчанию всегда будет Python .
Важно помнить, что в этом случае порядок опять же имеет значение. Сначала идут позиционные аргументы, а за ними — аргументы с дефолтными значениями.
Вот такой код не сработал бы:
Заключение
В этой статье мы рассмотрели, как объявлять функции в Python и как вызывать их с параметрами.
Мы также разобрали тему позиционных и именованных аргументов и использование значений аргументов по умолчанию.
Читайте также: