Функции в Python — синтаксис и основные типы

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

Что такое функция в Python, синтаксис функции 

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

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

Функции и методы в Python начинаются с инструкции def (от английского define — «определять»). Далее отмечается имя функции, за которым идёт пара скобок — в них часто указывают имена некоторых переменных, и после заключительное двоеточие. Оно открывает блок тела функции, которое пишут с новой строки. В Питоне не используются фигурные скобки для блока кода — на их месте располагаются отступы в четыре пробела. 

Каждая новая функция начинается с новой строки — вы можете разделить их точкой с запятой. Для завершения функции и возврата значения из неё подходит команда return. Если вы не отметите место завершения, то когда функция завершится, когда её тело достигнет конца. Так возвращается объект типа None.

Функции в Питоне можно сравнить с простыми математическими функциями. Например, f(x) = x + 11. В левой части — определение функции f, которая принимает параметр x. Правая часть — определение функции, которое использует x, чтобы вычислить и вернуть результат. Конкретно здесь значением функции выступает её параметр с прибавлением числа 11. В Python шаблон функции выглядит так: 

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

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

def f(x):

return x +11

Составлять несложные функции довольно просто. Ещё один пример:

def sayHello(): 

print(‘Привет, Мир!’) #блок функции

# Конец функции 

sayHello() # вызов функции 

sayHello() # второй вызов функции

Результат:

$ python function1.py 

Привет, Мир! Привет, Мир!

Интересуетесь веб-разработкой и погружаетесь сразу в несколько языков программирования? Обратите внимание на онлайн-курсы с поддержкой от куратора и большим количеством практики с кодом. Обучение от лучших школ на рынке с сайта tutortop:

• «Веб-разработчик с трудоустройством» от Eduson Academy 
• «Веб-разработчик с нуля» от Нетологии
• «Профессия: Web-разработчик с гарантией трудоустройства» от ProductStar
• «Веб-разработчик с нуля» — Skypro

Параметры функции в Python 

Когда мы пишем def в начале функции, мы сообщаем интерпретатору, что код за командой — это её определение. Вместе эту конструкцию можно считать объявлением функции. Не стоит путать два важных составляющих. Под параметром подразумевается переменная, которой будет присваиваться входящее в функцию значение. Аргумент — это значение, которое передаётся в функцию при её вызове:

c, l — параметры функции

def test(c, l):

#instruction

# 100, 809 — аргументы

test(100, 809)

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

def f():

return 5 + 1

result = f()

print(result # 6

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

def f(x, y, z):

return x + y + z

result = f(3, 2, 3)

print(result) # 8

Существуют параметры двух типов. Те, что мы рассмотрели выше, называются обязательными параметрами. Когда разработчик вызывает функцию, он предаёт в неё обязательные параметры — если этого не сделать, Python создаст исключение. Есть и другой тип. Опциональные имеют такой синтаксис: имя_функции (имя_параметра = значение_параметра). Эти параметры тоже необходимо отделять запятыми. Пример функции с использованием опционального параметра:

def f(x=3):

return x*x

print (f()) # 9

print (f(3))# 27

Мы видим, что из-за того, что параметр необязательный, x сразу равен 3, а функция возвращает цифру 9. Эта же функция вызывается с параметром 9. Теперь х равен 9 — функция возвращает 27. В функции могут быть как обязательные, так и опциональные параметры, однако первые стоит определять в первую очередь. 

Использование аргументов и их виды 

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

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

• обязательные аргументы, 
• аргументы-ключевые слова, 
• аргументы по умолчанию, 
• произвольные аргументы.

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

def bigger(a, b):

if a > b:

print a

else:

print b

#В описании функции отмечено — функция принимает 2 аргумента

# Результат

bigger(5,6)

# Ошибка

bigger ()

bigger(3)

bigger(12,7,3)

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

def elements(call1, call2):

return call1 + call2

result = elements(4, 11)

print(result)

15

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

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)

words()

Hey there, World!

words (name=»Inna»)

Hey there, Inna

В этом варианте у атрибута name новое значение. Это повлияло на результат соединения строк и вывод результата.

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

def space(planet_name, center=»Star»):

print planet_name, «is orbiting a», center

# Можно вызвать функцию space так:

space(«Mars»)

# В результате получим: Mars is orbiting a Star

# Можно вызвать функцию space иначе:

space(«Mars», «Black Hole»)

# В результате получим: Mars is orbiting a Black Hole

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

def some(*args):

for argument in args:

print argument

unknown(«love»,»sleep») # напечатает слова

unknown(1,2,3,4,5) # напечатает числа, каждое на новой строке

unknown() # без ответа

В нашем блоге вы можете прочитать статью о том, как скачать и установить Python на компьютер. Мы также подробно рассказали о функциях append() и extend() в Питоне и сравнили два популярных языка программирования — PHP и Python. Переходите в блог и читайте другие статьи, в которых вы сможете найти много полезной информации.

Не теряйте время и начните своё путешествие в мир PHP-разработки уже сегодня! Мы собрали для вас подборку лучших онлайн-курсов, которые помогут вам углубить свои знания и навыки. 

Как объявить и вызвать функцию в Python

Объявить функцию в Питоне не так сложно, как кажется. Сначала обратите внимание на синтаксис и последовательность:

# код функции

# def — DEclare Function — «объявить функцию»

# function_name — имя функции

# (argument1, argument2, …) — список аргументов, поступающих на вход функции при её вызове

# тело функции — код, который идёт после двоеточия

Пример:

def hello(name):

print(‘Hello, ‘ + name)

hello(‘Alex’)

# Вывод

>> Hello, Alex

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

hello(‘Alex’)

def hello(name):

print(‘Hello, ‘ + name)

> 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)

print(f’l1 = {l1}’)
print(f’l2 = {l2}’)
print(f’l3 = {l3}’)

>> l1 = 15
>> l2 = 156
>> l3 = 10

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

Область видимости функций 

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

Локальная 

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

def L():

# переменная local является локальной внутри L()

local =4

Глобальная

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

var1 = 12

def global_func():

 print(x)

Область объемлющих функций 

Ключевое слово в этом случае — nonlocal. Оно указывает, что необходимо выбрать переменную уровнем выше — при этом переменная не должна относиться к глобальной области, описанной выше. Пример взаимодействия:

def р():

x = 3

def inner_p():

nonlocal x

 x = x + 1

return x

return inner_p()

print(p())

> 4

Lambda-функции 

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

double = lambda x: x*2 

print(double(5))

#10

Функцию в примере можно считать безымянной. Она возвращает функциональный объект с идентификатором double. По сути она идентична с функцией:

def double(x):

return x * 2

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

Почему функции в Python так важны 

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

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

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

Что ещё стоит знать о функциях в Питоне

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

Функции могут храниться в структурах данных:

>>> funcs = [bark, str.lower, str.capitalize] 

>>> funcs [<function yell at 0x10ff96510>, 

<method ‘lower’ of ‘str’ objects>,

 <method ‘capitalize’ of ‘str’ objects>]

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

def greet (func):

greeting = func(‘Hi, I am a Python program’) 

print(greeting)

greet(yell) ‘HI, I AM A PYTHON PROGRAM!’

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

def outer_func(): 

def inner_func(): 

print(«Hello, World!»)

inner_func()

outer_func() 

Hello, World!