Как использовать функции в Python

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

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

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

Синтаксис функций в Python

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

Изучить все базовые функции и методы Python можно на курсе Skypro «Python-разработчик». За несколько месяцев вы освоите нужную теорию и навыки, чтобы найти работу по новой специальности. А специалисты центра карьеры помогут составить резюме и подготовиться к собеседованию.

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

Чтобы завершить функцию и вернуть из нее значение, используют ключевое слово return. Если этого не указать, то, когда тело функции достигнет конца, функция завершится и вернет объект типа None.

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

Теперь функция возвращает строку, а значение можно сохранять в переменной и использовать.

Подробнее об этом расскажет наш спикер на видео:
< видео >

Как вызвать функцию в Python

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

sayHello(name)

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

result = say_hello("name")
print(result)

Результатом такой операции будет строка Hello, name!, которую затем можно использовать где-то еще.

Точно так же можно проводить в функции и арифметические операции:

def addfunc(val1, val2):
return val1 + val2

Эта функция принимает два значения (val1, val2) и возвращает их сумму с помощью return val1 + val2. Например:

result = addfunc(3, 5)
print(result) # Выведет: 8

Аргументы и их виды

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

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

Позиционные

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

def plus(a, b):
return a + b

result = сложить(2, 3)
print(результат) # 5

Если не передать нужное количество аргументов, Python выдаст ошибку TypeError.

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

def sum(*числа):
total = 0
for number in numbers:
if isinstance(number, (int, float)):
total += number
else:
print(f"{number} — не число")
return total

итог = сумма(1, 2, "Привет", 3.5, 4)
print("Сумма:", итог) # Сумма: 10.5

Аргументы из *args можно перебирать, а можно обращаться к ним по индексу.

def showArgs(*args):
if len(args) > 0:
print("Первый:", args[0])
if len(args) > 1:
print("Второй:", args[1])

showArgs("один", "два")

Именованные

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

def greet(имя="Гость"):
print("Привет,", имя)

greet() # Привет, Гость
greet(имя="Аня") # Привет, Аня

Чтобы передать функции много именованных аргументов, используют **kwargs. Такие аргументы собираются в словарь: специальную структуру данных из пар «ключ-значение».

def showData(**данные):
print(данные)

showData(имя="Кира", возраст=25, город="Минск")
# {'имя': 'Кира', 'возраст': 25, 'город': 'Минск'}

Функции и области видимости

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

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

Глобальная область (global scope)

Это пространство имен всего файла (модуля). В него входят переменные, функции и т. п., объявленные вне других блоков.

x = 10

def showVar():
print(x)

showVar() # 10

Глобальные переменные видны из любого места в файле или модуле. Их нельзя изменить без ключевого слова Global.

Локальная область (local scope)

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

x = 100 # глобальная переменная

def first():
print(x) # использует глобальную переменную

def second():
x = "local" # создает локальную переменную
print(x)

def third():
global x # указывает, что будет изменяться глобальная переменная
x = "modified globally"

first() # 100
second() # local
third()
first() # modified globally

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

Область объемлющей функции (enclosing function scope)

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

def counter(func):
count = 0 # переменная во внешней функции

def wrapper():
nonlocal count # указываем, что используем переменную из внешней области
func()
count += 1
print("Calls:", count)

return wrapper

@counter
def demo():
print("Message")

for _ in range(3):
demo()

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

Ключевое слово nonlocal нужно, чтобы менять переменные внешней (объемлющей) функции. Без него вместо изменения в существующую переменную получится новая локальная переменная.

Lambda-функции (анонимные)

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

numbers = [1, 2, 3, 4, 5, 6]
evens = list(filter(lambda x: x % 2 == 0, numbers)) # фильтруем четные числа
print(evens) # [2, 4, 6]

Лямбда-функции в Python — анонимные: у них нет имени.

Рекурсивные функции в Python

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

def factorial(n):
if n == 0:
return 1 # базовый случай: факториал 0 равен 1
return n * factorial(n - 1) # рекурсивный вызов

print(factorial(5)) # 120

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

Декораторы функций в Python

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

Пример:

def log_decorator(func):
def wrapper():
print("Вызов функции:", func.__name__)
func()
print("Завершение работы")
return wrapper

@log_decorator
def say_hello():
print("Hello!")

say_hello()

Функция возвращает такой результат:

Вызов функции: say_hello
Hello!
Завершение работы

Символ @ перед именем декоратора — это синтаксический сахар: он не влияет на поведение программы, но с ним код проще читать и воспринимать.

Оператор возврата return

return возвращает результат из функции. Можно вернуть несколько значений — они будут собраны в кортеж. Такие значения можно потом распаковать в переменные.

def calculate(a, b):
return a + b, a - b, a * b, a / b

results = calculate(10, 2)
print(results) # (12, 8, 20, 5.0)
print(results[0]) # 12

s, d, m, q = calculate(4, 2)
print(s) # 6
print(m) # 8

Оператор возврата yield

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

def generator(n, text):
for _ in range(n):
yield text # возвращает значение и запоминает позицию

g = generator(3, "Example")

for item in g:
print(item)

После того как генератор закончится, при следующем вызове next() возникнет ошибка StopIteration.

[FAQ] Частые вопросы

Функции vs процедуры — в чём отличие?

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

Можно ли объявить функцию внутри другой функции?

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

Можно ли использовать return и yield в одной функции?

Нет. Функция использует либо return, либо yield. Если есть хотя бы один yield, функция становится генератором.

Что произойдет, если вызвать функцию до ее определения?

Можно ли присвоить функцию переменной?[/txt]

Да, в Python функции — это объекты. Их можно присваивать переменным, передавать как аргументы и возвращать из других функций.

Для чего нужна область видимости?

Чтобы решить конфликт имен.

Как провести распаковку множества?

Нужно присвоить его такому же количеству переменных, сколько в нём содержится объектов.

Обязательно ли наличие аргументов для функции?

Нет, но чаще у функции есть один или несколько аргументов.

Можно ли передавать в функцию другие функции?

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

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

Главное о функциях в Python

• Функция — это блок кода, который можно вызывать много раз. Она помогает избежать повторения одного и того же.
• Функции создают с помощью def, после пишут имя и аргументы в скобках. Тело функции оформляют с отступом.
  return завершает выполнение функции и возвращает результат. Без него функция вернет None.
• Чтобы знать, как вызвать функцию, достаточно знать ее имя и передать ей аргументы в скобках. Результат можно сохранить в переменной.
• Аргументы могут быть позиционными (по порядку) и именованными (с указанием имени). Есть специальные — *args (много значений) и **kwargs (много пар «ключ-значение»).
• Переменные внутри функции не видны снаружи. Есть глобальная, локальная и область объемлющей функции. Для доступа к внешним переменным используют global и nonlocal.
• Это короткие функции без имени. Удобны для простых операций, например при фильтрации.
• Это функции, которые вызывают сами себя. Обязательно нужно указывать базовый случай, чтобы остановить рекурсию.
• Декораторы оборачивают другие функции и добавляют поведение. Используются, например, для логирования или подсчета вызовов.
  return возвращает сразу результат. yield — по одному значению за раз, работает в генераторах. В одной функции нельзя использовать и то и другое.
• Функции можно создавать внутри других. Их можно присваивать переменным и передавать как аргументы.
• Перед вызовом функцию нужно определить.