Из чего состоит функция

Функции в программировании

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

Функции можно сравнить с небольшими программками, которые сами по себе, то есть автономно, не исполняются, а встраиваются в обычную программу. Нередко их так и называют – подпрограммы. Других ключевых отличий функций от программ нет. Функции также при необходимости могут получать и возвращать данные. Только обычно они их получают не с ввода (клавиатуры, файла и др.), а из вызывающей программы. Сюда же они возвращают результат своей работы.

Существует множество встроенных в язык программирования функций. С некоторыми такими в 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. Введение в программирование

Урок 4. Основы программирования. Функции

Чем больше в вашей программе строк, тем сложнее она для понимания. Поскольку программу придётся актуализировать, дополнять и изменять бесконечно, то объёмный код в этой задаче не помощник. Для его упрощения есть функции. Благодаря им вы сократите время на разработку и уберёте дублирующиеся части. Понимать и тестировать программу станет проще. Как всё работает, сейчас покажем.

Сначала теория

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

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

Зачем обращаться к функции? Чтобы не прописывать тот же самый алгоритм повторно в другом месте. Вместо этого достаточно написать только имя функции. Код становится лаконичным и понятным, его легко отлаживать и сопровождать.

Объясняем

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

1. Взять палочки.

3. Совершить удар по барабану.

4. Нажать на педаль ногой.

5. Помотать головой в такт.

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

По сути, это алгоритм в алгоритме, который вызывается по имени с помощью команды. Например, лай собаки – это функция, которая выполняется по определённому алгоритму и вызывается командой «Голос».

Аргументы

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

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

Например, если взять функцию человека ходить, то в качестве аргументов в неё передаётся «обувь».

Обувь – это параметр.

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

Кроссовки и сапоги – это аргументы.

Алгоритм при этом не поменяется: каждый раз человек ходит одинаково, но в разной обуви.

При вызове функции в строке происходит следующее:

1. Язык программирования находит её в той части программы, где она прописана.

2. Выполняет команды, содержащиеся в ней, с учетом указанных при вызове аргументов.

3. Возвращается обратно к строке, которая её вызвала.

4. Переходит к следующей строке.

Некоторые функции уже встроены в язык программирования, например, console.log() в JavaScript, с которой мы уже познакомились 🙂

Пользовательские функции

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

В JavaScript специальное слово для определения функций – function. После него указывается:

— список аргументов в круглых скобках;

— тело функции в фигурных скобках.

Создадим простейшую функцию без параметров с именем greeting, которая будет выводить строку ‘Hello!’:

function greeting()

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

Если позже нам понадобится вызвать функцию в другой части программы, то мы вызовем её только по имени – «greeting();» – и нажмём :

greeting();

Увидим в консоли результат:

"Hello!"

Тренировка

1. Напишем на JS функцию height() с двумя аргументами: высота в полных метрах (m) и остаток в сантиметрах (cm). Объявление функции выглядит так:

function height(m, cm)

(m, cm) — это параметры, которые необходимо передавать в функцию, чтобы она заработала.

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

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

100 * m + cm

Мы указали, что для расчета общей высоты в сантиметрах необходимо взять значение аргумента m, умножить его на 100, а затем прибавить значение аргумента cm.

3. Запишем эту формулу в переменную total. Наша функция теперь выглядит так:

function height(m, cm)

4. Попросим функцию сразу выводить значение переменной total, которое получилось после произведённого рассчета:

function height(m, cm)

5. Вызовем функцию с аргументами 1 и 70:

height(1,70);

Что произойдёт? Компьютер понимает, что функции height(m, cm) переданы аргументы 1 и 70 и подставляет их соответственно: m = 1, cm = 70. Затем производится расчёт по формуле:

Результат вычисления 170 записывается в переменную total. Далее – значение переменной total выводится в консоль:

6. Теперь попросим функцию выводить не просто результат расчёта, а добавлять к нему обозначение результата ‘cm tall’ и снова вызовем функцию с теми же аргументами:

function height(m, cm) < let total = 100 * m + cm; console.log(total + 'cm tall'); >height(1,70);

Алгоритм работы функции не поменяется. Но при выводе результата вычисления – в нашем случае 170 – выполняется конкатенация (склейка) двух строк таким образом:

— значение переменной total автоматически преобразуется в строку благодаря неявному преобразованию в JavaScript: число 170 превращается в строку ‘170’;

— строка ‘cm tall’ склеивается со строкой ‘170’.

Теперь результат в консоли выглядит так:

"170cm tall"

Возвращение значений

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

Чтобы «научить» функцию возвращать значения потребуется ввести ключевое слово return. А после него указать значение какой переменной необходимо вернуть.

Напишем функцию с именем calc(), которая бы принимала два числовых параметра и суммировала их. Запишем алгоритмическое выражение в переменную total:

function calc(a,b)

Справка! Переменной присваивается не само выражение a + b, а результат, который в итоге получится.

Теперь попросим функцию возвращать значение переменной total:

function calc(a,b)

При вычислении функция получит результат, присвоит его переменной total и вернёт это значение как результат функции.

Например, вызовем функцию calc() с параметрами 4 и 5:

console.log(calc(4,5));

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

Домашнее задание

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

Определение функции func

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

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

func uint sum( uint left right ) < return left + right >

Атрибуты

entry

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

main

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

func uint myprog < print("Hello, World!") getch() >

result

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

alias

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

func uint myfunc_verylongname( uint param ) < return param * 10 > func str mystring < result = "Result string" > func main < print( "Val= \( myfunc->func( 10 ))") print( mystring() ) getch() >

Параметры

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

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

func uint myfunc( uint a b c, byte d, str st1 st2, arr marr[,] of uint )

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

func str myadd( str left ) < left += " OK!" return left > func main < str val myadd( val = "Process" ) print( val ) >

Смотрите также

Возвращение переменных
Локальные переменные
Подфункции subfunc

Функции в Python для начинающих

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

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

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

f(x) = x * 2

Левая часть определяет функцию f , принимающую один параметр, x . А правая часть — это определение функции, которое использует переданный параметр x , чтобы произвести вычисление и вернуть результат. В этом случае значением функции является ее параметр, умноженный на два.

Как в Python функция записывается следующим образом: имя_функции(параметры_через_запятую) . Чтобы вызвать функцию, после ее имени нужно указать круглые скобки и поместить внутрь параметры, отделив каждый из них запятой. Для создания функций в Python выберите ее имя, определите параметры, укажите, что функция должна делать и какое значение возвращать.

def имя_функции(параметры): определениие_функции

Математическая функция f(x) = x * 2 в Python будет выглядеть вот так:

def f(x):
 return x * 2

Ключевое слово def сообщает Python, что вы определяете функцию. После def вы указываете имя функции; оно должно отвечать тем же правилам, что и имена переменных. Согласно конвенции, в имени функции нельзя использовать заглавные буквы, а слова должны быть разделены подчеркиванием вот_так .

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

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

return x * 2

Ключевое слово return используется для определения значения, которое функция возвращает при вызове.

Чтобы вызвать функцию в Python, мы используем синтаксис имя_функции(параметры, через, запятую) .

Ниже описан вызов функции f из предыдущего примера с параметром 2 .

Консоль ничего не вывела. Можно сохранить вывод вашей функции в переменной и передать ее функции print .

# Продолжение
# предыдущего примера
def f(x):
 return x * 2
result = f(2)
print(result) # 4

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

def f(x):
 return x + 1
 z = f(4)
if z == 5:
 print("z равно 5")
else:
 print ("z не равно 5")

У функции может быть один параметр, несколько параметров или вообще их не быть. Чтобы определить функцию, не требующую параметров, оставьте круглые скобки пустыми.

def f():
 return 1 + 1
 result = f()
print(result) # 2

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

def f(x, y, z):
 return x + y + z
 result = f(1, 2, 3)
print(result) # 6

Наконец, функция не обязана содержать инструкцию return. Если функции нечего возвращать, она возвращает значение None .

def f():
 z = 1 + 1
result = f()
print(result) # None

Обязательные и необязательные параметры ¶

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

В Python есть и другой вид параметров — опциональные. Опциональные параметры определяются с помощью следующего синтаксиса: имя_функции(имя_параметра = значение_параметра) . Как и обязательные, опциональные параметры нужно отделять запятыми. Ниже приведен пример функции, в коде которой используется опциональный параметр.

def f(x=2):
 return x**x
 print (f()) # 4
print (f(4)) # 16

Сначала функция вызывается без передачи параметра. Так как параметр необязательный, x автоматически становится равен 2 , и функция возвращает 4 .

Затем та же функция вызывается с параметром 4 . То есть x будет равен 4 и функция вернет 16 . Вы можете определить функцию, которая принимает как обязательные, так и опциональные параметры, но обязательные нужно определять в первую очередь.

def add(x, y=10):
 return x + y
result = add(2)
print(result)