Объявление функций, параметры, возвращаемое значение, область видимости переменных
Зачем нужны подпрограммы
Подпрограмма — это именованный, самостоятельно оформленный фрагмент программы, который решает отдельную подзадачу и может вызываться из основной программы (или из других подпрограмм) многократно, с разными исходными данными. Подпрограммы решают сразу несколько важных задач: избавляют от дублирования одинакового кода, делают программу понятнее (сложная задача разбивается на именованные смысловые блоки) и упрощают тестирование и отладку — каждую подпрограмму можно проверить независимо от остальной программы. В большинстве языков программирования различают процедуры (подпрограммы, которые выполняют действия, но не возвращают значение) и функции (подпрограммы, которые вычисляют и возвращают результат); в Python оба этих понятия реализуются единой конструкцией def, а разница лишь в том, использует ли подпрограмма оператор return для возврата значения.
Объявление функции в Python
Функция объявляется ключевым словом def, за которым следует имя функции, список параметров в круглых скобках и двоеточие; тело функции записывается с отступом (обычно 4 пробела). Вызов функции — это обращение к ней по имени с указанием конкретных значений (аргументов) в скобках.
def greet(name):
print(f'Здравствуйте, {name}!')
# Вызов функции с аргументом
greet('Анна')
greet('Пётр')
Параметры и аргументы функции
Параметры — это переменные, перечисленные в заголовке функции при её объявлении; они играют роль «заготовок» для будущих данных. Аргументы — это конкретные значения, которые передаются функции при её вызове и подставляются вместо параметров. Функция может принимать несколько параметров, и при вызове аргументы обычно передаются в том же порядке, что и параметры в объявлении (позиционные аргументы), либо явно по имени параметра (именованные аргументы).
def rectangle_area(width, height):
area = width * height
print(f'Площадь прямоугольника {width}x{height} = {area}')
rectangle_area(5, 3) # позиционные аргументы
rectangle_area(height=3, width=5) # именованные аргументы — порядок не важен
Возвращаемое значение: return
Если подпрограмма должна не просто выполнить действие (например, вывести что-то на экран), а вычислить и передать результат обратно в место вызова, используется оператор return. Как только выполняется return, функция немедленно завершает работу и возвращает указанное значение; это значение можно сохранить в переменную, использовать в выражении или передать в другую функцию.
def rectangle_area(width, height):
return width * height
# Результат функции сохраняется в переменную
s1 = rectangle_area(5, 3)
s2 = rectangle_area(2, 7)
print(s1 + s2) # результаты можно использовать в выражениях
# Функция без return фактически возвращает None
def say_hi():
print('Привет!')
result = say_hi()
print(result) # None — функция ничего не возвращает через return
Параметры по умолчанию
Параметру можно задать значение по умолчанию, которое будет использовано, если при вызове функции соответствующий аргумент не передан. Это удобно для необязательных настроек функции.
def power(base, exponent=2):
return base ** exponent
print(power(5)) # 25 — exponent взят по умолчанию (2)
print(power(5, 3)) # 125 — exponent указан явно
Область видимости переменных: локальные и глобальные
Переменная, созданная внутри функции (в том числе параметр), называется локальной: она существует только во время выполнения этой функции и недоступна за её пределами. Переменная, созданная вне всех функций (в основном теле программы), называется глобальной и по умолчанию доступна для чтения из любой функции. Однако при попытке просто присвоить значение переменной с тем же именем внутри функции Python создаёт новую локальную переменную, а не изменяет глобальную — чтобы явно изменить именно глобальную переменную внутри функции, используют ключевое слово global.
counter = 0 # глобальная переменная
def increment_wrong():
counter = counter + 1 # ОШИБКА: UnboundLocalError
def increment_correct():
global counter
counter += 1 # теперь изменяется именно глобальная переменная
increment_correct()
increment_correct()
print(counter) # 2
def local_example():
local_var = 100 # существует только внутри функции
print(local_var)
local_example()
# print(local_var) # ОШИБКА: NameError, переменная не видна снаружи
Передача массива в функцию
Список (массив) в Python передаётся в функцию по ссылке: параметр внутри функции указывает на тот же объект в памяти, что и аргумент снаружи. Поэтому, если функция изменяет содержимое списка (например, методом append() или через присваивание элементу), эти изменения видны и после возврата из функции — в отличие от чисел и строк, которые внутри функции изменить «снаружи» невозможно.
def add_zero(array):
array.append(0) # изменяет исходный список
def find_max(array):
m = array[0]
for x in array:
if x > m:
m = x
return m # возвращает новое значение, не изменяя список
data = [3, 7, 2]
add_zero(data)
print(data) # [3, 7, 2, 0] — список изменился
print(find_max(data)) # 7 — просто вычислен результат
Функции с переменным числом аргументов
Иногда заранее не известно, сколько аргументов будет передано функции при вызове — например, функция должна находить сумму произвольного количества чисел. Для таких случаев в Python используется специальный параметр со звёздочкой *args, который собирает все переданные позиционные аргументы в один кортеж (tuple), доступный внутри функции для перебора.
def total_sum(*args):
result = 0
for x in args:
result += x
return result
print(total_sum(1, 2, 3)) # 6
print(total_sum(5, 10, 15, 20)) # 50
print(total_sum()) # 0 — можно вызвать и без аргументов
Несколько возвращаемых значений
Функция в Python может вернуть сразу несколько значений — фактически оператор return при перечислении значений через запятую упаковывает их в кортеж, который затем можно «распаковать» сразу в несколько переменных при вызове функции. Это удобно, когда функция должна вычислить, например, сразу и минимум, и максимум массива за один проход.
def min_max(array):
lo = hi = array[0]
for x in array:
if x < lo:
lo = x
if x > hi:
hi = x
return lo, hi # возвращается кортеж (lo, hi)
smallest, largest = min_max([5, 3, 8, 1, 9, 2])
print('Минимум:', smallest, 'Максимум:', largest)
Функции как способ избежать дублирования кода
Если один и тот же расчёт нужен в программе несколько раз для разных данных, его оформляют в виде функции один раз, а затем многократно вызывают с разными аргументами — это ключевой принцип структурного программирования, называемый принципом DRY (Don't Repeat Yourself, «не повторяйся»). Он не только сокращает объём кода, но и упрощает исправление ошибок: если в алгоритме найдена ошибка, её достаточно исправить в одном месте — в теле функции.
def is_prime(n):
if n < 2:
return False
for d in range(2, int(n ** 0.5) + 1):
if n % d == 0:
return False
return True
for number in range(2, 20):
if is_prime(number):
print(number, end=' ')
print()
Типичные ошибки
Частая ошибка — забыть оператор return в функции, которая должна что-то вычислять: тогда функция по умолчанию вернёт None, и последующие вычисления с этим результатом приведут к ошибке TypeError. Вторая ошибка — попытка изменить глобальную переменную внутри функции без ключевого слова global, что вызывает ошибку UnboundLocalError, если переменная используется в выражении с самой собой. Третья ошибка — путаница между процедурой (которая только печатает результат) и функцией (которая возвращает значение для дальнейшего использования): если результат функции нужен для расчётов, печать внутри неё вместо return делает результат недоступным для остальной программы. Наконец, опасная ловушка — использовать в качестве значения параметра по умолчанию изменяемый объект (например, def f(lst=[])): такой список создаётся один раз при определении функции и сохраняется между вызовами, что приводит к неожиданному поведению.
Краткий словарь терминов
Подпрограмма — именованный, самостоятельно оформленный фрагмент программы, вызываемый из других частей программы.
Параметр — переменная в заголовке функции, играющая роль заготовки для передаваемого значения.
Аргумент — конкретное значение, передаваемое функции при вызове вместо параметра.
return — оператор, завершающий выполнение функции и возвращающий результат в точку вызова.
Локальная переменная — переменная, созданная внутри функции и недоступная за её пределами.
Глобальная переменная — переменная, созданная вне функций и доступная (для чтения) из любой функции программы.
Заключение
Функции — важнейший инструмент структурирования программы: они позволяют выделять повторяющиеся или логически законченные действия в отдельные именованные блоки с чёткими входными параметрами и возвращаемым результатом. Особый и очень важный частный случай вызова функции — вызов функцией самой себя, называемый рекурсией; именно этому мощному приёму программирования посвящена следующая тема.
