Функции в программировании
Функция в программировании представляет собой обособленный участок кода, который можно вызывать, обратившись к нему по имени, которым он был назван. При вызове происходит выполнение команд тела функции.
Функции можно сравнить с небольшими программками, которые сами по себе, то есть автономно, не исполняются, а встраиваются в обычную программу. Нередко их так и называют – подпрограммы. Других ключевых отличий функций от программ нет. Функции также при необходимости могут получать и возвращать данные. Только обычно они их получают не с ввода (клавиатуры, файла и др.), а из вызывающей программы. Сюда же они возвращают результат своей работы.
Существует множество встроенных в язык программирования функций. С некоторыми такими в Python мы уже сталкивались. Это print() , input() , int() , float() , str() , type() . Код их тела нам не виден, он где-то «спрятан внутри языка». Нам же предоставляется только интерфейс – имя функции.
С другой стороны, программист всегда может определять свои функции. Их называют пользовательскими. В данном случае под «пользователем» понимают программиста, а не того, кто пользует программу. Разберемся, зачем нам эти функции, и как их создавать.
Предположим, надо три раза подряд запрашивать на ввод пару чисел и складывать их. С этой целью можно использовать цикл:
i = 0 while i 3: a = int(input()) b = int(input()) print(a + b) i += 1
Однако, что если перед каждым запросом чисел, надо выводить надпись, зачем они нужны, и каждый раз эта надпись разная. Мы не можем прервать цикл, а затем вернуться к тому же циклу обратно. Придется отказаться от него, и тогда получится длинный код, содержащий в разных местах одинаковые участки:
print("Сколько бананов и ананасов для обезьян?") a = int(input()) b = int(input()) print("Всего", a + b, "шт.") print("Сколько жуков и червей для ежей?") a = int(input()) b = int(input()) print("Всего", a + b, "шт.") print("Сколько рыб и моллюсков для выдр?") a = int(input()) b = int(input()) print("Всего", a + b, "шт.")
Пример исполнения программы:
Сколько бананов и ананасов для обезьян? 15 5 Всего 20 шт. Сколько жуков и червей для ежей? 50 12 Всего 62 шт. Сколько рыб и моллюсков для выдр? 16 8 Всего 24 шт.
Внедрение функций позволяет решить проблему дублирования кода в разных местах программы. Благодаря им можно исполнять один и тот же участок кода не сразу, а только тогда, когда он понадобится.
Определение функции. Оператор def
В языке программирования Python функции определяются с помощью оператора def . Рассмотрим код:
def count_food(): a = int(input()) b = int(input()) print("Всего", a + b, "шт.")
Это пример определения функции. Как и другие сложные инструкции вроде условного оператора и циклов функция состоит из заголовка и тела. Заголовок оканчивается двоеточием и переходом на новую строку. Тело имеет отступ.
Ключевое слово def сообщает интерпретатору, что перед ним определение функции. За def следует имя функции. Оно может быть любым, также как и всякий идентификатор, например, переменная. В программировании весьма желательно давать всему осмысленные имена. Так в данном случае функция названа «посчитать_еду» в переводе на русский.
После имени функции ставятся скобки. В приведенном примере они пустые. Это значит, что функция не принимает никакие данные из вызывающей ее программы. Однако она могла бы их принимать, и тогда в скобках были бы указаны так называемые параметры.
После двоеточия следует тело, содержащее инструкции, которые выполняются при вызове функции. Следует различать определение функции и ее вызов. В программном коде они не рядом и не вместе. Можно определить функцию, но ни разу ее не вызвать. Нельзя вызвать функцию, которая не была определена. Определив функцию, но ни разу не вызвав ее, вы никогда не выполните ее тела.
Вызов функции
Рассмотрим полную версию программы с функцией:
def count_food(): a = int(input()) b = int(input()) print("Всего", a+b, "шт.") print("Сколько бананов и ананасов для обезьян?") count_food() print("Сколько жуков и червей для ежей?") count_food() print("Сколько рыб и моллюсков для выдр?") count_food()
После вывода на экран каждого информационного сообщения осуществляется вызов функции, который выглядит просто как упоминание ее имени со скобками. Поскольку в функцию мы ничего не передаем скобки опять же пустые. В приведенном коде функция вызывается три раза.
Когда функция вызывается, поток выполнения программы переходит к ее определению и начинает исполнять ее тело. После того, как тело функции исполнено, поток выполнения возвращается в основной код в то место, где функция вызывалась. Далее исполняется следующее за вызовом выражение.
В языке Python определение функции должно предшествовать ее вызовам. Это связано с тем, что интерпретатор читает код строка за строкой и о том, что находится ниже по течению, ему еще неизвестно. Поэтому если вызов функции предшествует ее определению, то возникает ошибка (выбрасывается исключение NameError ):
print("Сколько бананов и ананасов для обезьян?") count_food() print("Сколько жуков и червей для ежей?") count_food() print("Сколько рыб и моллюсков для выдр?") count_food() def count_food(): a = int(input()) b = int(input()) print("Всего", a + b, "шт.")
Сколько бананов и ананасов для обезьян? Traceback (most recent call last): File "test.py", line 2, in count_food() NameError: name 'count_food' is not defined
Для многих компилируемых языков это не обязательное условие. Там можно определять и вызывать функцию в произвольных местах программы. Однако для удобочитаемости кода программисты даже в этом случае предпочитают соблюдать определенные правила.
Функции придают программе структуру
Польза функций не только в возможности многократного вызова одного и того же кода из разных мест программы. Не менее важно, что благодаря им программа обретает истинную структуру. Функции как бы разделяют ее на обособленные части, каждая из которых выполняет свою конкретную задачу.
Пусть надо написать программу, вычисляющую площади разных фигур. Пользователь указывает, площадь какой фигуры он хочет вычислить. После этого вводит исходные данные. Например, длину и ширину в случае прямоугольника. Чтобы разделить поток выполнения на несколько ветвей, следует использовать оператор if-elif-else:
figure = input("1-прямоугольник, 2-треугольник, 3-круг: ") if figure == '1': a = float(input("Ширина: ")) b = float(input("Высота: ")) print("Площадь: %.2f" % (a * b)) elif figure == '2': a = float(input("Основание: ")) h = float(input("Высота: ")) print("Площадь: %.2f" % (0.5 * a * h)) elif figure == '3': r = float(input("Радиус: ")) print("Площадь: %.2f" % (3.14 * r ** 2)) else: print("Ошибка ввода")
Здесь нет никаких функций, и все прекрасно. Но напишем вариант с функциями:
def rectangle(): a = float(input("Ширина: ")) b = float(input("Высота: ")) print("Площадь: %.2f" % (a * b)) def triangle(): a = float(input("Основание: ")) h = float(input("Высота: ")) print("Площадь: %.2f" % (0.5 * a * h)) def circle(): r = float(input("Радиус: ")) print("Площадь: %.2f" % (3.14 * r ** 2)) figure = input("1-прямоугольник, 2-треугольник, 3-круг: ") if figure == '1': rectangle() elif figure == '2': triangle() elif figure == '3': circle() else: print("Ошибка ввода")
Он кажется сложнее, а каждая из трех функций вызывается всего один раз. Однако из общей логики программы как бы убраны и обособлены инструкции для нахождения площадей. Программа теперь состоит из отдельных «кирпичиков Лего». В основной ветке мы можем комбинировать их как угодно. Она играет роль управляющего механизма.
Если нам когда-нибудь захочется вычислять площадь треугольника по формуле Герона, а не через высоту, то не придется искать код во всей программе (представьте, что она состоит из тысяч строк кода как реальные программы). Мы пойдем к месту определения функций и изменим тело одной из них.
Если понадобиться использовать эти функции в какой-нибудь другой программе, то мы сможем импортировать их туда, сославшись на данный файл с кодом (как это делается в Python, будет рассмотрено позже).
Практическая работа
В программировании можно из одной функции вызывать другую. Для иллюстрации этой возможности напишите программу по следующему описанию.
Основная ветка программы, не считая заголовков функций, состоит из одной строки кода. Это вызов функции test() . В ней запрашивается на ввод целое число. Если оно положительное, то вызывается функция positive() , тело которой содержит команду вывода на экран слова «Положительное». Если число отрицательное, то вызывается функция negative() , ее тело содержит выражение вывода на экран слова «Отрицательное».
Понятно, что вызов test() должен следовать после определения функций. Однако имеет ли значение порядок определения самих функций? То есть должны ли определения positive() и negative() предшествовать test() или могут следовать после него? Проверьте вашу гипотезу, поменяв объявления функций местами. Попробуйте объяснить результат.
Примеры решения и дополнительные уроки в pdf-версии курса
X Скрыть Наверх
Python. Введение в программирование
Функции в Python — синтаксис и основные типы
Под функцией в программировании понимают часть кода или группу из определённых инструкций, которые выполняют конкретную задачу. Проще говоря, они делят программу на части — она выглядит составной и структурной благодаря функциям. А ещё они помогают избежать повторения программного кода и других сложностей, возникающих во время работы. Функции в Python — обширная и интересная тема. В этой статье мы затронем важные моменты, на которые стоит обратить внимание — типы функций в Питоне и их вызов, примеры синтаксиса и использование при написании кода.
Что такое функция в Python, синтаксис функции
Функции в Python — инструкции для задач, которые могут принимать данные ввода, выполнять указания и возвращать данные вывода. Для наглядности их нередко сравнивают с небольшими программами. Вот только автономно они существовать не могут, а являются частью обычной программы. Вы также можете встретить и другое название для функций — подпрограммы. Они обеспечивают лучшую модульность приложения и заметно повышают уровень повторного использования кода.
Вызов функции — это передача входных данных, которые необходимы для выполнения и возвращения результата. Передача входных данных называется передачей параметра функции. При этом в Python всё является объектом, например, строки или модули, включая функции. Вы можете присваивать переменным, хранить в структурах данных, передавать или возвращать другим функциям.
Функции и методы в Python начинаются с инструкции def (от английского define — «определять»). Далее отмечается имя функции, за которым идёт пара скобок — в них часто указывают имена некоторых переменных, и после заключительное двоеточие. Оно открывает блок тела функции, которое пишут с новой строки. В Питоне не используются фигурные скобки для блока кода — на их месте располагаются отступы в четыре пробела.
Каждая новая функция начинается с новой строки — вы можете разделить их точкой с запятой. Для завершения функции и возврата значения из неё подходит команда return. Если вы не отметите место завершения, то когда функция завершится, когда её тело достигнет конца. Так возвращается объект типа None.
Функции в Питоне можно сравнить с простыми математическими функциями. Например, f(x) = x + 11. В левой части — определение функции f, которая принимает параметр x. Правая часть — определение функции, которое использует x, чтобы вычислить и вернуть результат. Конкретно здесь значением функции выступает её параметр с прибавлением числа 11. В Python шаблон функции выглядит так:
def имя_функции (параметры): определение_функции
Если мы возьмём за основу описанную выше математическую функцию, она будет отображаться таким образом:
Составлять несложные функции довольно просто. Ещё один пример:
print(‘Привет, Мир!’) #блок функции
sayHello() # вызов функции
sayHello() # второй вызов функции
Привет, Мир! Привет, Мир!
Интересуетесь веб-разработкой и погружаетесь сразу в несколько языков программирования? Обратите внимание на онлайн-курсы с поддержкой от куратора и большим количеством практики с кодом. Обучение от лучших школ на рынке с сайта tutortop:
- «Веб-разработчик с трудоустройством» от Eduson Academy
- «Веб-разработчик с нуля» от Нетологии
- «Профессия: Web-разработчик с гарантией трудоустройства» от ProductStar
- «Веб-разработчик с нуля» — Skypro
Мы дарим 10 000 ₽ на обучение в любой из школ-партнёров, представленных на сайте tutortop. При покупке через сайт tutortop вы также получите курсы стоимостью 20 000 ₽ абсолютно бесплатно.
Получите онлайн-курсы стоимостью 20 000 ₽ абсолютно бесплатно и промокод 10 000 ₽ на обучение.
Нажимая на кнопку «Получить», я соглашаюсь на обработку моих персональных данных.
Спасибо! Мы получили вашу заявку. Скоро с вами свяжемся.
Параметры функции в Python
Когда мы пишем def в начале функции, мы сообщаем интерпретатору, что код за командой — это её определение. Вместе эту конструкцию можно считать объявлением функции. Не стоит путать два важных составляющих. Под параметром подразумевается переменная, которой будет присваиваться входящее в функцию значение. Аргумент — это значение, которое передаётся в функцию при её вызове:
c, l — параметры функции
# 100, 809 — аргументы
Функция может иметь один параметр, несколько параметров или вовсе ноль. Для определения функции, не требующей параметров, круглые скобки нужно оставить пустыми:
В случаях, когда необходимо, что функция принимала больше одного параметра, параметры в скобках нужно отделить запятой:
Существуют параметры двух типов. Те, что мы рассмотрели выше, называются обязательными параметрами. Когда разработчик вызывает функцию, он предаёт в неё обязательные параметры — если этого не сделать, Python создаст исключение. Есть и другой тип. Опциональные имеют такой синтаксис: имя_функции (имя_параметра = значение_параметра). Эти параметры тоже необходимо отделять запятыми. Пример функции с использованием опционального параметра:
Мы видим, что из-за того, что параметр необязательный, x сразу равен 3, а функция возвращает цифру 9. Эта же функция вызывается с параметром 9. Теперь х равен 9 — функция возвращает 27. В функции могут быть как обязательные, так и опциональные параметры, однако первые стоит определять в первую очередь.
Использование аргументов и их виды
При вызове функции ей передаются аргументы. При переходе к функции в Python для её исполнения, переменным-параметрам присваиваются переданные в функцию значения-аргументы. Важно, что количество аргументов и параметров всегда совпадает. Не получится передать два аргумента, если функция передает лишь один. Нельзя передать два аргумента, если функции нужно три. Синтаксис в Python устроен так, что при определении функции параметры, которым имеют значение по умолчанию, должны идти следом за параметрами, не имеющими такого значения — так соблюдается порядок следования.
Вызывая функцию, можно передать ей различные виды аргументов:
- обязательные аргументы,
- аргументы-ключевые слова,
- аргументы по умолчанию,
- произвольные аргументы.
Обязательные используются, когда при создании функции указано количество передаваемых ей аргументов и их порядок. Вызывать функцию надо с тем же количеством аргументов, расположенных в едином порядке:
#В описании функции отмечено — функция принимает 2 аргумента
Такие аргументы также называют позиционными. Всё потому, что они должны располагаться по порядку, чтобы пользователь получил корректный результат. Приведём пример того, как может выглядеть ошибка при вызове:
def elements(call1, call2):
return call1 + call2
result = elements(4, 11)
В этом примере всё верно, но вот, что будет, если вызвать функцию без аргументов:
elements() # вызов без аргументов
Traceback (most recent call last):
TypeError: elements() missing 2 required positional arguments: ‘call1’ and ‘call2’
Аргументы — ключевые слова или именные также используются при вызове функции. С их помощью вы можете задавать произвольный порядок аргументов. Переписать значение легко, используя новое значение по имени атрибута.
Пример номер один:
def information (color, smell):
print color, «is», smell, » «
#Первый аргумент — цвет, но мы можем поменять их местами и сначала указать запах
information (smell=nice, color =»blue»)
Пример номер два:
def words (*args, name=»World!»):
print («Hey there,», name)
В этом варианте у атрибута name новое значение. Это повлияло на результат соединения строк и вывод результата.
Аргументами по умолчанию называют те аргументы, значение для которых задано с самого начала при создании функции:
def space(planet_name, center=»Star»):
print planet_name, «is orbiting a», center
# Можно вызвать функцию space так:
# В результате получим: Mars is orbiting a Star
# Можно вызвать функцию space иначе:
# В результате получим: Mars is orbiting a Black Hole
Произвольные аргументы используются в случаях, когда вы точно не знаете, сколько именно аргументов нужно будет принять функции. Их называют аргументами произвольной длины. Задать их можно произвольным именем переменной, перед которой ставится звездочка (*):
for argument in args:
unknown(«love»,»sleep») # напечатает слова
unknown(1,2,3,4,5) # напечатает числа, каждое на новой строке
unknown() # без ответа
В нашем блоге вы можете прочитать статью о том, как скачать и установить Python на компьютер. Мы также подробно рассказали о функциях append() и extend() в Питоне и сравнили два популярных языка программирования — PHP и Python. Переходите в блог и читайте другие статьи, в которых вы сможете найти много полезной информации.
Не теряйте время и начните своё путешествие в мир PHP-разработки уже сегодня! Мы собрали для вас подборку лучших онлайн-курсов, которые помогут вам углубить свои знания и навыки.
Как объявить и вызвать функцию в Python
Объявить функцию в Питоне не так сложно, как кажется. Сначала обратите внимание на синтаксис и последовательность:
# def — DEclare Function — «объявить функцию»
# function_name — имя функции
# (argument1, argument2, …) — список аргументов, поступающих на вход функции при её вызове
# тело функции — код, который идёт после двоеточия
Пример:
Если вы допустите ошибку в расположении, например, сначала напишите вызов, может получиться такой результат:
> NameError: name ‘hello’ is not defined
Оператор возврата return
В примерах выше мы использовали слово return — в Python оно позволяет вернуть значение. Оператор может содержать выражение, которое возвращает значение. Если выражения нет или же внутри функции отсутствует сам оператор возврата, она вернёт значение None. Так его можно использовать для разных типов расчётов:
def led (a, b):
return a + b
l1 = led(11, 4)
l2 = led(56, 100)
l3 = led(9, 1)
Возвращаемые значения удобны потому, что их можно включать в дальнейшую работу: совершать с ними разные операции и передавать в качестве аргументов в уже другие функции.
Область видимости функций
Область видимости нужна для разрешения конфликта имен. Она гарантирует, что любое составляющее, созданное внутри функции, не перезапишет предыдущий объект с таким же именем без указания. Стоит отметить, что переменные, находящиеся в теле функции, доступны только внутри нее. Можно сказать, что они располагаются в локальной области видимости.
Локальная
Она находится внутри def. В функциях можно создавать временные переменные для вычислений. Для того, чтобы снизить вероятность возникновения конфликта имен и перезаписи предыдущего объекта, под функцию выделяется пространство:
# переменная local является локальной внутри L()
Глобальная
Пространство за пределами def. Оно может включать в себя названия классов, функций, остальных объектов, которые были созданы в файле:
Область объемлющих функций
Ключевое слово в этом случае — nonlocal. Оно указывает, что необходимо выбрать переменную уровнем выше — при этом переменная не должна относиться к глобальной области, описанной выше. Пример взаимодействия:
Lambda-функции
Так в Питоне называют анонимные функции. Выражение этого типа можно присвоить переменной и потом использовать необходимое количество раз. Часто lambda применяют для фильтрации множества или отложенного выполнения фрагмента программного кода:
double = lambda x: x*2
Функцию в примере можно считать безымянной. Она возвращает функциональный объект с идентификатором double. По сути она идентична с функцией:
Стоит запомнить, что функция может иметь любое количество аргументов. Однако она вычисляет и возвращает лишь одно значение. Это делает её в определенной мере ограниченной в синтаксисе.
Почему функции в Python так важны
Функции помогают экономить время и силы — вы можете создать одну функцию для решения большого количества похожих задач вместо того, чтобы заниматься решением каждой по отдельности. Это особенно актуально, когда вы работаете над крупным проектом и ваш код очень большой — используйте функции, чтобы сократить объём и время, а также упростить себе процесс написания и редактирования.
Повторное использование — то, что больше всего привлекает в функциях. Без них код приложений или программ можно было бы читать бесконечно — это не только сложно, но и совсем неудобно. Если вы отказываетесь от функций, то сразу на первых этапах работы можете столкнуться с повторением своих же действий. Включайте в работу выработанные алгоритмы, сохраняйте те варианты, что используете чаще всего и запоминайте новые для расширения своих возможностей.
Без функций невозможно представить понятия «модульность» в Python. Она буквально состоит из использования функций. Под этим термином понимают разделение кода на составляющие, с которыми проще работать, такой код легче читать и понимать. Вы наверняка знаете, что путь к успеху в одном крупном деле лежит через разделение его на более мелкие дела. Также и с функциями — без них сложно представить поддержку кода, его редактирование или написание с нуля.
Что ещё стоит знать о функциях в Питоне
Мы собрали ещё несколько важных фактов, которые помогут вам понять, как работать с функциями, какие особенности синтаксиса и написания существуют.
Функции могут храниться в структурах данных:
>>> funcs = [bark, str.lower, str.capitalize]
Их можно передавать в качестве аргументов другим функциям. Например, функция greet — она форматирует строку greeting, использует переданный объект функции, и после выводит функцию:
greeting = func(‘Hi, I am a Python program’)
greet(yell) ‘HI, I AM A PYTHON PROGRAM!’
Есть возможность делать функции внутри функций — их называют вложенными. Их главная особенность в том, что можно обращаться к переменным и объектам из внешней, главной функции. Она же даёт пространство имен, доступное вложенной в неё функции:
Анна Уженкова
Копирайтер. Увлекается литературой и любит разбираться в сложных вещах. В работе ценит сам процесс — тексты, это не просто тексты, а возможность на что-то повлиять. Среди тем, которые нравятся, — образование, психология, IT.
Как указать тип функции в Python ?
Указывают скорее типы не функций, а переменных. Типы аргументов пишут после их названий (через : ), а тип возвращаемого значение после аргументов между -> и : .
def my_function(arg1: int, arg2: str) -> bool: # тело функции return True Подробности ищи в PEP 484 — Type Hints
Просто про функции и их аргументы в Python
Функции существуют в большинстве современных языков программирования. В императивных языках (к которым относится и Python) функция — это набор инструкций, объединенных для выполнения одной задачи. Блоки кода, однажды оформленные в виде функций, можно использовать в коде многократно. Поэтому разработчики охотно применяют этот подход на практике, чтобы облегчить работу себе и своему приложению.
Курс Python basic.
Після курсу ви зможете впевнено працювати з чатботами, скриптами, вбудованими системами, веб- та мобільними застосунками, а також навіть ігровими програмами.
Редакция highload.today разобралась, как это работает, как создавать функции Python, на какие разновидности они делятся, как вызывать функции и передавать в них аргументы. Теперь мы готовы помочь разобраться в этом вам. И… да, примеры кода обязательно будут.
1. Что такое функция в Python
В предыдущем абзаце уже шла речь о том, что функции Python делятся на разновидности. Мы рассмотрим две классификации:
-
встроенные / не встроенные (пользовательские);
Курс Англійської.
Навчання для різних цілей та рівнів: робоча англійська, початковий рівень, курси для дітей та підлітків.
Отличия между ними сводятся не только к синтаксису и способу использования. Не менее важно, что работают они тоже по-разному (далее мы в этом убедимся).
Встроенные функции Python выполняют очень широкий круг мелких, но важных задач. Например:
| Встроенная функция Python | Краткое описание |
| len() | вычисляет длину (количество элементов) последовательности (например, списка) |
| next() | возвращает следующий по порядку элемент последовательности (например, списка) |
| reversed() | меняет порядок элементов последовательности на обратный |
В языке Python десятки таких функций, и внутренняя реализация многих из них очень сложна. Но об этом за вас уже позаботились разработчики языка, поэтому пользуйтесь с удовольствием — как говорится, бесплатно и без регистрации. Разобраться во всех тонкостях языка Python можно на специальных курсах от наших партнеров в Powercode и ШАГ.
Пользовательские функции разработчики приложений на Python должны создавать самостоятельно. Для этого в языке существуют специальные конструкции, которыми нужно просто научиться пользоваться. И чем лучше вы этому научитесь, тем лучше будет выглядеть ваш код. И более того, его будет проще поддерживать и дорабатывать. Пользовательские функции помогают:
- разделить объемный код на понятные, осмысленные части;
- вынести повторяющийся код в один блок;
- оптимизировать скорость работы приложения.
Про встроенные функции Python в этой статье мы говорить практически не будем, но знайте, что они есть. И перед тем, как писать свою функцию, проверьте, существует ли встроенная функция, которая подходит для решения вашей задачи.
Курс Англійської.
Навчання для різних цілей та рівнів: робоча англійська, початковий рівень, курси для дітей та підлітків.
2. Именные функции (инструкция def)
Из названия термина ясно, что синтаксис такой функции обязательно должен включать ее имя:
def function_name(parameters): """здесь можно описать, что делает функция""" statement(s) return result
Первая строка — заголовок функции. Далее следуют опциональная строковая переменная (в тройных кавычках) и тело функции (обозначено как statement(s) ).
У синтаксиса функции есть ряд особенностей:
-
Заголовок функции должен начинаться с ключевого слова def .
Курс UI/UX для геймдеву.
Під час навчання ви розробите проекти для портфоліо, що складається з 5 ключових аспектів UX/UI-дизайну, та отримаєш необхідні навички для професійного росту.
Функции Python могут иметь произвольное имя. Но желательно, чтобы имя было глаголом и отражало суть задачи, которую решает эта функция.
Пример:
def greet(name): """ Функция выводит приветственное сообщение для имени name """ print("Hello, " + name + ". Good morning!")
Напомним также общие правила именования переменных, которые полностью распространяются и на имена функций:
- Имя может состоять из чисел, латинских символов и символа нижнего подчеркивания и не должно включать что-либо другое.
- Имя функции не должно включать пробелы.
- В начале имени нельзя ставить цифру.
- X и x — это два разных идентификатора (регистр имеет значение).
- Имена функций рекомендуют начинать со строчной буквы.
- В качестве имени пользовательской функции запрещено использовать ключевые слова языка Python и имена его встроенных функций.
Вызов функции
Функцию можно вызвать из консоли Python, из скрипта или из другой функции. Чтобы сделать это для именной функции мы должны написать ее имя, а в скобках при необходимости передать ей параметры, либо оставить скобки пустыми.
>>> say_goodbye('Paul') Goodbye, Paul.
вызов функции из консоли Python
def say_goodbye(name): print("Goodbye, " + name) say_goodbye('Paul')
вызов функции say_goodbye из скрипта Python и вызов функции print из функции say_goodbye
ВАЖНО: язык Python не позволяет вызывать функцию до того, как она была создана. Потому что анализатор Python в данном случае сканирует код сверху вниз и не может найти объявление функции, которая была вызвана.
# вызов функции say_goodbye('Paul') # реализация функции def say_goodbye(name): print("Goodbye, " + name) # Ошибка: в точке say_goodbye('Paul') функция 'say_goodbye' не определена, не существует
вызов функции до ее объявления
Без вызова именная функция никогда не запустится. То есть, мы обязательно должны вызвать именную функцию, чтобы заставить работать код внутри нее, включая инструкцию return , о которой расскажем в специальном разделе.
3. Документирование функции
После заголовка функции идет опциональная строка, в которой можно написать любой текст. Но в данном случае она нужна для описания, документирования работы функции. Ее еще называют иностранным словосочетанием docstring . Вряд ли вы помните, что делает и как работает каждая функция, которую вы написали. Если даже вы это помните, то остальные разработчики, которые будут сопровождать или как-то еще использовать ваш код, не в курсе.
Поэтому такое документирование позволяет в итоге сэкономить время. А те минуты, которые вы потратите на него, окупятся с избытком.
Вспомним функцию из предыдущего примера и добавим в нее docstring :
def greet(name): """ Функция выводит приветственное сообщение для имени name """ print("Hello, " + name + ". Good morning!")
объявление функции с документированием
Все, теперь, встретившись с таким кодом, другие разработчики сразу поймут, что к чему. Понятно, что тут очень простой пример, но представьте, что это большой и запутанный код.
Но оказывается, можно сделать жизнь разработчиков еще проще. Встретив функцию, они могут не искать ее объявление по всему проекту, а воспользоваться специальным атрибутом __doc__ .
>>> print(greet.__doc__) Функция выводит приветственное сообщение для имени name
вывод значения атрибута __doc__ для функции greet
4. Аргументы функции
Вновь вернемся к заголовку функции и разберемся, какими могут быть эти самые параметры, они же — аргументы. Сколько их может быть? В предельном случае их может не быть вовсе. Тогда получаем такой заголовок:
def function_name():
и вот такой вызов функции:
function_name();
Рассмотрим теперь более распространенный случай, когда аргументов несколько.
def say_goodbye(name, msg): print("Goodbye", name + ', ' + msg) say_goodbye("Monica", "Sweet dreams!")
Функция say_goodbye принимает два аргумента — переменные name и msg . Вызывая функцию, мы передаем в нее значения, которые соответствуют аргументам. То есть эти значения (“ Monica ” и “ Sweet dreams! “) подставляются вместо переменных name и msg соответственно.
Результат работы программы:
Goodbye Monica, Sweet dreams!
Отлично. Два аргумента — два переданных значения. Все работает.
Но что будет, если мы передадим в эту же функцию только одно значение или совсем не передадим значения?
>>> say_goodbye("Monica") TypeError: say_goodbye() missing 1 required positional argument: 'msg' >>> say_goodbye() TypeError: say_goodbye() missing 2 required positional arguments: 'name' and 'msg'
Как видите программа работать не будет и выдаст ошибку для каждого вызова. Получается, Python не позволяет передавать количество значений, не совпадающее с количеством аргументов, указанных в объявлении функции?
Если отвечать в очень грубом приближении, то не позволяет. Но далее мы увидим, как можно решить эту задачу, если очень хочется.
Значения аргументов по умолчанию
Python позволяет задавать значения аргументов по умолчанию.
def say_goodbye(name, msg="Sweet dreams!"): print("Goodbye", name + ', ' + msg)
Конструкция msg=»Sweet dreams!» в первой строке означает, что при вызове функции значение аргумента msg можно не задавать. Достаточно задать только значение аргумента name , а значение msg подставится само.
И тогда программа будет работать без ошибок:
Goodbye Monica, Sweet dreams!
При этом вариант вызова с полным количеством аргументов также будет работать
say_goodbye(«Bruce», «See you!»)
и программа выдаст
Goodbye Bruce, See you!
В данном случае значение, которое мы передали в качестве второго аргумента, будет использовано вместо значения по умолчанию, заданное в заголовке функции.
Однако, в силу особенностей языка Python, мы не можем переписать код так:
def say_goodbye(msg = «Sweet dreams!», name):
Потому что получим ошибку.
SyntaxError: non-default argument follows default argument
Это означает, что справа от аргумента со значением по умолчанию могут располагаться только такие же аргументы, имеющие значение по умолчанию. Обычные аргументы без значений по умолчанию должны находиться слева.
Порядок передачи аргументов
При вызове функции нельзя просто так поменять местами значения, которые вы передаете в качестве аргументов.
say_goodbye(«See you!», «Bruce»)
приведет к следующему результату:
Goodbye See you!, Bruce
Потому что в объявлении функции аргументы расположены не в том порядке:
def say_goodbye(name, msg):
В Python такие аргументы называются позиционными. Но существуют и аргументы другого типа — именованные или ключевые (калька с английского keyword arguments ). Если точнее, то существует другой способ передачи значений аргументов при вызове функции.
# 2 ключевые аргументы say_goodbye(name = "Bruce", msg = "See you!") # 2 ключевые аргументы в другом порядке say_goodbye(msg = "See you!",name = "Bruce")
Такая конструкция позволяет игнорировать порядок передачи аргументов при вызове функции. Хотя можно использовать и смешанный вариант:
# позиционный и ключевой аргумент say_goodbye("Bruce", msg = "See you!")
Функции с неизвестным количеством аргументов
Если мы не знаем, сколько значений будет обрабатывать функция, можно задать ее аргументы в виде списка.
def say_goodbye(*names): """Функция выведет приветствие для каждого имени из полученного names""" for name in names: print("Goodbye", name)
В этом случае перед именем списка пишется знак * . Тут names — это список имен неизвестной длины. Функция обрабатывает его, как обычный список.
Вызывая эту функцию, мы можем в качестве аргументов передавать произвольное количество значений. Они преобразуются в список и полученный список автоматически подставляется вместо переменной names.
say_goodbye(«Monica», «Luke», «Steve», «John»)
Результат работы программы:
Goodbye Monica Goodbye Luke Goodbye Steve Goodbye John
5. Инструкция return
Несмотря на то, что эта инструкция опциональная, она помогает в двух случаях:
- Когда нужно вернуть результат работы функции в виде значения, которое может использовано вне функции — например, записано во внешнюю переменную.
def sum(a,b): return a+b
- Когда нужно прервать работу функции и вернуться к той точке программы, из которой была вызвана эта функция.
def division(a,d): if d == 0: # если делитель равен нулю return "Нельзя делить на ноль" # мы прерываем работу функции return a / d
Посмотрим, как будут работать эти функции с различными значениями аргументов.
print(sum(2, 4)) print(sum(2, -4))
6 -2 print(division(4, 2)) print(division(4, 0))
2.0 Нельзя делить на ноль
Если в коде функции нет инструкции return , она не возвращает ничего. Запустив в консоли функцию из предыдущего раздела, в третьей строке мы получим None .
>>> print(say_goodbye("May")) Goodbye, May. None
6. Глобальные и локальные переменные
В этой статье мы еще не встречали функции, в которых помимо аргументов использованы переменные. Например:
def multiplicator(x): k = 2 return k * x
Что это за переменная k ?
Чтобы ответить на этот вопрос, нужно ввести понятия области видимости и времени жизни переменных. Область видимости переменной — это фрагмент программы (блок), внутри которого эта переменная существует и доступна. О такой переменной говорят, что она видна в данной области видимости (простите за тавтологию).
В приведенном выше примере переменная k видна только внутри функции. В этом случае говорят, что переменная является локальной.
Время жизни переменной — это временной промежуток, в течение которого переменная хранится в памяти (и доступна хотя бы для чтения).
Локальные переменные обычно живут до тех пор, пока функция не завершит свою работу после очередного вызова. Во время каждого вызова функции все ее локальные переменные сбрасываются и инициализируются заново. Значения (если они были изменены) локальных переменных из предыдущих вызовов функция не хранит.
Хорошо, тогда что будет, если создать переменную с тем же именем, но за пределами функции?
def multiplicator(x): k = 2 print("Значение локальной переменной k:", k) return k*x k = 20 multiplicator(4) print("Значение внешней переменной k:", k)
Значение локальной переменной k: 2 Значение внешней переменной k: 20
В этом примере внешняя переменная k никак не влияет на результат работы функции. Дело в том, что сначала функция ищет переменную с подходящим именем внутри своей локальной области видимости — где как раз находится локальная переменная k .
Если мы удалим эту переменную из реализации функции, то она будет искать k уже во внешних по отношению к ней блоках кода (пошагово двигаясь изнутри наружу). В данном случае она найдет внешнюю переменную k , равную 20 и использует ее значение для своих вычислений.
Но если нам нужно не просто использовать, а еще и модифицировать это значение, необходимо внести изменения в код:
def multiplicator(x): global k k = 2 print("Значение локальной переменной k:", k) return k*x k = 20 multiplicator(4) print("Значение внешней переменной k:", k)
Добавив выделенные жирными строки ( global k и k = 2 ), мы сообщаем анализатору Python, что не намерены создавать локальную переменную k : мы просто модифицируем глобальную переменную.
Язык программирования Python – один из самых востребованных. С каждым годом потребность в специалистах с его знаниями только растет. Поэтому если вам он интересен, то вы можете записаться на курс к нашим друзьям из академии ШАГ или Mate Academy. Получите высокооплачиваемую профессию на долгие годы.
7. Рекурсивные функции
В разделе про python def function мы упоминали, что функцию можно вызывать, находясь внутри другой функции. Оказывается, функция может вызывать саму себя внутри своего же исходного кода.
def factorial(x): #условие окончания рекурсии if x == 1: return 1 else: return (x * factorial(x-1)) num = 3 print("Факториал числа", num, "равен", factorial(num))
Такие функции называют рекурсивными. В данном случае factorial(x) один раз вызывается из внешней программы и два раза — из самой себя. Перед каждым из двух этих вызовов значение аргумента x уменьшается на 1. Это происходит до тех пор, пока x не достигнет значения, равного 1. Это так называемое условие окончания рекурсии.
Программа отработает и выведет соответствующее сообщение:
Факториал числа 3 равен 6
Последовательность вычислений можно представить в хронологическом порядке:
| Операция | Значение x | Состояние программы | Условие окончания рекурсии |
| factorial(3) | 3 | первый вызов функции | не выполнено |
| 3 * factorial(2) | 2 | второй вызов, погружение в рекурсию | не выполнено |
| 3 * (2 * factorial(1)) | 1 | третий вызов, погружение в рекурсию | не выполнено |
| 3 * (2 * 1) | 1 | выход из рекурсии (всплываем) | выполнено |
| return 3 * 2 | 2 | выход из рекурсии | выполнено |
| 6 | 3 | возвращение результата | выполнено |
8. Анонимные функции (инструкция lambda)
Их также называют лямбда-функциями (это отсылка к математическому инструментарию под названием Лямбда Исчисление). Ключевое отличие анонимных от именных функций, казалось бы, заложено в их названиях. Но это не совсем так.
Во-первых, синтаксис функций отличается кардинально:
lambda аргументы: выражение
Во-вторых, лямбда-функция может выполнить только одну инструкцию (действие).
Для чего тогда нам нужны такие узкоспециализированные функции?
Анонимные функции идеально подходят, если нужно передать функцию в другую функцию в качестве аргумента. И если больше нигде переданная функция не будет вызвана — имя ей не понадобится. Ну и требование выполнять только одно действие (вычислять лишь одно выражение) здесь тоже играет в плюс, так как делает код более лаконичным.
l = [2, 5, 1, 4] l.sort(key=lambda x: x)
l = [2, 5, 1, 4] l.sort(key=lambda x: -x)
В первом примере список будет отсортирован по своим исходным (не измененным) значениям. Во втором примере лямбда-функция подставит вместо каждого элемента списка это же число, но со знаком минус. В результате список будет отсортирован в обратном порядке.
Важно также отметить, что лямбда-функции не используют инструкцию return , но всегда возвращают результат. В одном из наших примеров это результат вычисления выражения -x .
9. Присвоение функции переменной
Присвоение анонимной функции
Будет очень в тему еще один пример с анонимной функцией:
double = lambda x: x * 2
В данном случае мы просто присвоили имя этой лямбда-функции, но не вызвали ее. Этот код эквивалентен вот такой реализации именной функции:
def double(x): print(x * 2) return x * 2
Теперь для вызова нашей анонимной функции, записанной в переменную double , нужно добавить ей скобки, подставив произвольное значение аргумента. Например:
Присвоение именной функции
Хорошо, а какие чудеса мы сможем сотворить, если запишем в переменную именную функцию? Для примера создадим вот такую функцию:
def f(): print("I am f")
Зададимся целью ввести такую переменную g , чтобы
- g() запускал вызов функции f
- с печатью строки I am f
Первый способ
def f(): print("I am f") # присваивание g = f # вызов функции g()
Это работает, потому что благодаря присваиванию переменная g указывает на тот же участок памяти (блок кода), что и функция f . А значит, подставив к g скобки, мы получим обычный вызов функции.
Второй способ
Используем так называемую лямбда-обертку. Создадим лямбда-функцию без аргументов, с возвращаемым значением в виде f() и запишем ее в переменную g (примерно так мы делали в начале раздела).
def f(): print("I am f") # лямбда-обертка g = lambda : f() # вызов функции g()
Это будет работать так же, так как лямбда-функция, записанная в переменную g запустится (то есть отправит на выполнение инструкцию f() ) только после выполнения инструкции g()
Заключение
Функции Python — это достаточно гибкий механизм, но в нем легко запутаться, не зная тонкостей. Надеюсь, в этой статье нам удалось заложить основы и объяснить важные детали при работе с функциями. Но если у вас остались вопросы, или вы хотите более подробно вникнуть в язык программирования Python, то курсы наших друзей Hillel и Powercode, помогут вам освоить новые знания.
Видео: примеры использования функции map()