Что вы узнаете
В этом параграфе вы научитесь создавать собственные функции, передавать в них параметры и возвращать значения. Разберётесь, как устроены локальные и глобальные переменные и как избежать ошибок при работе с областями видимости.
Вы узнаете, как устроены локальные и глобальные переменные — и почему с глобальными нужно быть осторожными.
Ключевые вопросы параграфа
- Как создавать собственные функции и зачем они нужны?
- Что такое аргументы функции и как они передаются?
- Как работает оператор return и какие значения может возвращать функция?
- Что такое область видимости? Чем различаются локальные и глобальные переменные?
- Как безопасно изменять переменные, переданные в функцию?
Как создавать собственные функции и зачем они нужны
Вы уже познакомились с некоторыми встроенными функциями Python — например, print()
, input()
, max()
, min()
и другими.
Но часто в программе возникает необходимость повторно использовать один и тот же блок кода. Чтобы не писать его каждый раз заново, программисты выносят такую часть в отдельную функцию
.
Функции позволяют:
- переиспользовать один и тот же код без копирования;
- сделать программу более читаемой и структурированной — за счёт разделения логики на небольшие, понятные блоки.
Синтаксис функции
Вот как выглядит базовое определение функции в Python:
1def имя_функции(аргументы):
2 тело функции
Что такое аргументы функции и как они передаются
Аргументы функции
— это значения, которые передаются при её вызове и становятся переменными внутри тела функции.
Тело функции выполняет операции с этими аргументами, а также, при необходимости, с внешними переменными. Когда функция завершает работу, она может вернуть результат с помощью оператора return. После этого интерпретатор продолжает выполнение основной программы, подставляя возвращённое значение на место вызова функции.
Рассмотрим пример: здесь создаётся функция, которая принимает список чисел и проверяет, все ли они чётные.
1def only_even(numbers):
2 result = True
3 for x in numbers:
4 if x % 2 != 0:
5 result = False
6 break
7 return result
8
9print(only_even([2, 4, 6]))
10print(only_even([1, 2, 3]))
11
12# Вывод программы:
13# True
14# False
Как работает оператор return
и какие значения может возвращать функция
В функции можно использовать несколько операторов return
. Как только срабатывает первый из них, выполнение функции немедленно прекращается, а результат передаётся в основную программу.
Пример: перепишем функцию only_even
так, чтобы сразу возвращать результат без использования флага result
:
1def only_even(numbers):
2 for x in numbers:
3 if x % 2 != 0:
4 return False
5 return True
6
7print(only_even([2, 4, 6]))
8print(only_even([1, 2, 3]))
9
10# Вывод программы:
11# True
12# False
Если в функции отсутствует return
или он используется без значения, Python всё равно вернёт специальный объект None
. Это тип, обозначающий отсутствие результата.
Пример:
1print(print("Эту строку выведет функция до возврата значения."))
2
3# Вывод программы:
4# Эту строку выведет функция до возврата значения.
5# None
Кроме того, функция может возвращать сразу несколько значений, указанных через запятую. Они автоматически объединяются в кортеж
:
1def only_even(numbers):
2 for i, x in enumerate(numbers):
3 if x % 2 != 0:
4 return False, i
5 return True
6
7print(only_even([2, 4, 6]))
8print(only_even([1, 2, 3]))
9
10# Вывод программы:
11# True
12# (False, 0)
Обратите внимание: в первом случае функция возвращает значение логического типа (True
), а во втором — кортеж ((False, 0)
). Это важно учитывать при дальнейшем использовании результата: от типа возвращаемого значения зависит, какие операции с ним возможны.
Что такое область видимости. Чем различаются локальные и глобальные переменные
Аргументы функции становятся локальными переменными
— это значит, что они доступны только внутри
этой функции. Если попытаться обратиться к ним снаружи, произойдёт ошибка.
Рассмотрим пример:
1def only_even(numbers):
2 for i, x in enumerate(numbers):
3 if x % 2 != 0:
4 return False, i
5 return True
6
7print(numbers)
8
9# Вывод программы:
10# NameError: name 'numbers' is not defined
Ошибка возникла потому, что переменная numbers
определена как аргумент функции и существует только в момент её выполнения. Такая переменная находится в локальной области видимости
.
Существует и глобальная область видимости
— она охватывает переменные, созданные вне функций, например в основном теле программы. К таким переменным можно обращаться из любой части программы, в том числе внутри функций.
Пример:
1def check_password(pwd):
2 return pwd == password
3
4password = "Python"
5print(check_password("123"))
6
7# Вывод программы:
8# False
В этом случае переменная password
определена глобально и доступна внутри функции check_password
.
Важно: хотя глобальные переменные доступны из функции, изменять их без специальных приёмов нельзя — об этом поговорим в следующем разделе.
Как безопасно изменять переменные, переданные в функцию
Можно ли изменить переменную из глобальной области видимости внутри функции? Ответ зависит от типа данных
переменной:
- Если это изменяемый тип (например, список), то изменение происходит напрямую.
- Если это неизменяемый тип (например, число или строка), то попытка изменить значение создаёт локальную копию с тем же именем.
Рассмотрим пример с изменяемым типом — списком:
1def list_modify():
2 del sample[-1]
3
4sample = [1, 2, 3]
5list_modify()
6print(sample)
7# Вывод программы:
8# [1, 2]
А теперь пример, где внутри функции происходит присваивание нового значения списку:
1def list_modify():
2 sample = [4, 5, 6]
3
4sample = [1, 2, 3]
5list_modify()
6print(sample)
7
8# Вывод программы:
9# [1, 2, 3]
В этом случае внутри функции создаётся новая локальная переменная sample
, и она никак не влияет на глобальную переменную с тем же именем.
То же самое касается аргументов функции. Они ведут себя как локальные переменные:
1def list_modify_1(list_arg):
2 # создаём новый локальный список, не имеющий связи с внешним
3 list_arg = [1, 2, 3, 4]
4
5def list_modify_2(list_arg):
6 # меняем исходный внешний список, переданный как аргумент
7 list_arg += [4]
8
9sample_1 = [1, 2, 3]
10sample_2 = [1, 2, 3]
11list_modify_1(sample_1)
12list_modify_2(sample_2)
13print(sample_1)
14print(sample_2)
15
16# Вывод программы:
17# [1, 2, 3]
18# [1, 2, 3, 4]
Во втором случае список действительно изменился, потому что операция += модифицирует объект на месте.
Если вам всё же нужно изменить глобальную переменную внутри функции, это можно сделать с помощью ключевого слова global
:
1def inc():
2 global x
3 x += 1
4 print(f"Количество вызовов функции равно {x}.")
5
6x = 0
7inc()
8inc()
9inc()
10
11# Вывод программы:
12
13# Количество вызовов функции равно 1.
14# Количество вызовов функции равно 2.
15# Количество вызовов функции равно 3.
Однако использовать global
нужно с осторожностью. Глобальные переменные делают код менее предсказуемым: любое изменение может произойти в любой части программы, и это затрудняет отладку.
Обычно лучше передавать значения в функцию и возвращать результат, как показано ниже:
1def f(count):
2 count += 1
3 print(f'Количество вызовов функции равно {count}.')
4 return count
5
6count_f = 0
7count_f = f(count_f)
8count_f = f(count_f)
9count_f = f(count_f)
10
11# Вывод программы:
12# Количество вызовов функции равно 1.
13# Количество вызовов функции равно 2.
14# Количество вызовов функции равно 3.
✅ У вас получилось разобраться с функциями из этого параграфа?
Что дальше
Теперь вы умеете создавать собственные функции, передавать в них аргументы и возвращать значения. Вы разобрались, как работает оператор return
, чем отличается None
от обычных значений и как вернуть из функции сразу несколько результатов.
Кроме того, вы научились различать локальные и глобальные переменные, поняли, почему переменные внутри функций «не видны» снаружи и как аккуратно работать с изменяемыми объектами, чтобы не допустить скрытых ошибок.
Дальше вас ждёт следующий шаг — гибкие способы передачи аргументов и работа с функциями как объектами. Мы поговорим про позиционные и именованные аргументы, значения по умолчанию, а также научимся передавать в функции другие функции. Вы узнаете, что такое *args
, **kwargs
, как устроены функции высшего порядка и зачем нужны лямбда-выражения.
А пока вы не ушли дальше — закрепите материал на практике:
- Отметьте, что урок прочитан, при помощи кнопки ниже.
- Пройдите мини-квиз, чтобы проверить, насколько хорошо вы усвоили тему.
- Перейдите к задачам этого параграфа и потренируйтесь.
- Перед этим загляните в короткий гайд о том, как работает система проверки.
Хотите обсудить, задать вопрос или не понимаете, почему код не работает? Мы всё предусмотрели — вступайте в сообщество Хендбука! Там студенты помогают друг другу разобраться.
Ключевые выводы параграфа
- Функции позволяют переиспользовать код, делить программу на логические блоки и повышать читаемость.
- Аргументы функции — это переменные, значения которых передаются при вызове и доступны только внутри функции (локальная область видимости).
- Оператор
return
завершает выполнение функции и возвращает результат. Еслиreturn
не указан, функция возвращаетNone
. - Функция может возвращать сразу несколько значений — в этом случае они автоматически упаковываются в кортеж.
- Локальные и глобальные переменные различаются по области действия: локальные живут только внутри функции, а глобальные доступны во всей программе. Изменять глобальные переменные внутри функции стоит только при необходимости: обычно лучше передавать значения через аргументы и возвращать результат.