Что такое функция и как её создать через def
Функция - это именованный блок кода, который можно вызывать много раз с разными данными. Она убирает повторы и делит программу на понятные части. В Python функции создаёт ключевое слово def: за ним идут имя, круглые скобки с параметрами и двоеточие, а тело функции записывается с отступом в четыре пробела.
def greet(name, greeting="Привет"):
"""Возвращает приветствие."""
return f"{greeting}, {name}!"
print(greet("Аня"))
print(greet("Олег", greeting="Здравствуй"))
print(greet(greeting="Хай", name="Жан"))
Вывод: Привет, Аня!, Здравствуй, Олег!, Хай, Жан!. Здесь name и greeting - параметры (имена в определении), а значения "Аня" или "Олег" - аргументы (то, что передают при вызове).
Определение функции только создаёт её, выполняется тело при вызове: greet("Аня"). Вызывать функцию можно только после того, как она определена выше по ходу программы.
Кроме своих функций в Python много встроенных: print, input, len, range, int, str, sum, min, max, sorted, map, filter. Работа со списками и строками тоже построена на функциях и методах (метод - это функция, привязанная к объекту).
Return: как функция возвращает результат
Оператор return завершает функцию и отдаёт значение туда, где её вызвали. Если return нет или он без значения, функция вернёт None. Частая ошибка новичков - использовать print вместо return: напечатанное значение нельзя потом использовать в вычислениях.
def show():
print("x") # только печатает
print(show()) # x, затем None
def minmax(nums):
return min(nums), max(nums) # возвращает кортеж из двух значений
lo, hi = minmax([4, 1, 9])
print(lo, hi, minmax([4, 1, 9])) # 1 9 (1, 9)
Во втором примере функция вернула сразу два значения. На самом деле Python упаковал их в кортеж, а при вызове распаковал в две переменные. После выполнения return остальной код функции не выполняется, поэтому его удобно использовать для раннего выхода из функции по условию.
Аргументы: позиционные, именованные и значения по умолчанию
Аргументы можно передавать по позиции (greet("Аня", "Хай")) или по имени (greet(name="Аня", greeting="Хай")). Именованные можно ставить в любом порядке, но после первого именованного позиционных быть не должно. Параметры со значением по умолчанию (greeting="Привет") можно не указывать при вызове, и их записывают после обязательных.
| Вид параметра | Запись в def | Как передавать |
|---|---|---|
| Обычный | def f(a, b) | по позиции или по имени |
| Со значением по умолчанию | def f(a, b=10) | можно пропустить |
| Произвольное число позиционных | def f(*args) | f(1, 2, 3), внутри args - кортеж |
| Произвольное число именованных | def f(**kwargs) | f(x=1, y=2), внутри kwargs - словарь |
| Только по имени | def f(a, *, b) | b обязательно с именем: f(1, b=2) |
| Только по позиции | def f(a, b, /) | без имён: f(1, 2) |
Параметры после одиночной звёздочки * принимаются только по имени, а до косой черты / только по позиции. Эти формы нужны, когда вы проектируете публичные функции и хотите зафиксировать способ вызова, а новичку достаточно знать первые четыре строки таблицы.
Ловушка изменяемого значения по умолчанию
Значение по умолчанию вычисляется один раз, когда выполняется def, а не при каждом вызове. Если оно изменяемое (список, словарь, множество), то все вызовы делят один и тот же объект.
def add_bad(item, bucket=[]):
bucket.append(item)
return bucket
print(add_bad(1), add_bad(2)) # [1, 2] [1, 2] - один и тот же список!
def add_ok(item, bucket=None):
if bucket is None:
bucket = []
bucket.append(item)
return bucket
print(add_ok(1), add_ok(2)) # [1] [2]
В первой версии список один на все вызовы, поэтому второй вызов дописывает в него же. Обе печатаемые ссылки указывают на один объект, потому вывод одинаков. Правильный приём показан во второй функции: по умолчанию ставят None и создают новый список внутри. Увидеть сохранённое значение можно так: add_bad.__defaults__.
Не используйте списки, словари и множества как значения по умолчанию. Берите None и создавайте объект внутри функции. Для чисел, строк, True и False таких проблем нет, потому что они неизменяемые.
Произвольное число аргументов: *args и **kwargs
Если заранее неизвестно, сколько аргументов передадут, используют *args (собирает лишние позиционные в кортеж) и **kwargs (собирает лишние именованные в словарь). Названия args и kwargs - это соглашение, важны только звёздочки.
def total(*args):
return sum(args)
def info(**kwargs):
for k, v in kwargs.items():
print(k, v)
def f(a, b, *args, sep="-", **kwargs):
return (a, b, args, sep, kwargs)
print(total(1, 2, 3), total()) # 6 0
info(a=1, b="два") # a 1 и b два на двух строках
print(f(1, 2, 3, 4, sep="+", x=5)) # (1, 2, (3, 4), '+', {'x': 5})
Звёздочки работают и при вызове, в обратную сторону: * разворачивает список или кортеж в позиционные аргументы, а ** - словарь в именованные.
nums = [1, 2, 3]
print(total(*nums)) # 6
d = {"name": "Мия", "greeting": "Хэй"}
print(greet(**d)) # Хэй, Мия!
Такая запись удобна, когда данные приходят уже в списке или словаре, например из JSON. Порядок параметров в определении всегда один: обычные, затем значения по умолчанию, затем *args, потом параметры только по имени и в конце **kwargs.
Lambda-функции
Лямбда (lambda) - это короткая анонимная функция из одного выражения, результат которого возвращается автоматически. Без имени, без return и без нескольких строк. Чаще всего её передают как аргумент другой функции: в sorted, map, filter, max и параметр key.
sq = lambda x: x * x
print(sq(5), (lambda a, b: a + b)(2, 3)) # 25 5
print(sorted(["bb", "a", "ccc"], key=lambda s: -len(s))) # ['ccc', 'bb', 'a']
print(list(map(lambda x: x * 2, [1, 2, 3]))) # [2, 4, 6]
print(list(filter(lambda x: x > 1, [1, 2, 3]))) # [2, 3]
Присваивать лямбду переменной, как в первой строке, можно, но стиль PEP 8 рекомендует для именованных функций использовать def. Для map и filter часто читабельнее генератор списка. Лямбду оставляйте для коротких одноразовых ключей сортировки.
Области видимости и правило LEGB
Переменная живёт только в той области, где создана. Python ищет имя по цепочке LEGB: сначала локальная область функции (Local), затем объемлющие функции (Enclosing), потом глобальная область модуля (Global) и в конце встроенные имена (Built-in).

| Область | Где находится | Пример |
|---|---|---|
| Local | внутри текущей функции | переменные, созданные в def |
| Enclosing | во внешней функции для вложенной | переменная n в outer для inner |
| Global | на уровне файла | x = 1 в начале модуля |
| Built-in | встроенные имена Python | len, print, range |
Присваивание внутри функции создаёт локальную переменную, даже если глобальная с таким именем есть. Чтобы изменить глобальную, объявляют global, а для переменной внешней функции используют nonlocal.
x = "глобальная"
def a1():
x = "локальная"
print(x)
a1(); print(x) # локальная, затем глобальная
cnt = 0
def inc():
global cnt
cnt += 1
inc(); inc(); print(cnt) # 2
def outer():
n = 0
def inner():
nonlocal n
n += 1
return n
return inner
c = outer()
print(c(), c(), c()) # 1 2 3
Вложенная функция inner помнит переменную n даже после завершения outer: такой механизм называется замыканием. Типичная ошибка: прочитать переменную и потом присвоить её в той же функции без global. Тогда Python считает имя локальным, и обращение до присваивания вызывает UnboundLocalError. Глобальных переменных лучше избегать: передавайте данные параметрами и возвращайте результат через return.
Изменяемые аргументы и передача по ссылке
Функция получает ссылку на объект. Если внутри изменить список методом append, изменения видны снаружи, а присваивание нового значения числу или строке снаружи не отражается.
def f2(x):
x.append(1) # меняем сам список
def f3(x):
x = x + 1 # создаём новое число, внешнее не затрагивается
lst = []; f2(lst); print(lst) # [1]
v = 1; f3(v); print(v) # 1
Если функция не должна менять входные данные, работайте с их копией: data = list(data).
Docstring и аннотации типов
Строка документации (docstring) - это строка в тройных кавычках первой строкой тела функции. Она описывает, что делает функция, и доступна через help(функция) и атрибут __doc__. Аннотации типов указывают ожидаемые типы параметров и результата. Python их не проверяет при запуске, но их используют редакторы (PyCharm, VS Code) и анализаторы вроде mypy.
def area(w: float, h: float = 1.0) -> float:
"""Площадь прямоугольника.
w - ширина, h - высота.
"""
return w * h
print(area(2, 3)) # 6
print(area.__doc__.splitlines()[0]) # Площадь прямоугольника.
print(area.__annotations__)
# {'w': <class 'float'>, 'h': <class 'float'>, 'return': <class 'float'>}
Запись -> float означает, что функция возвращает число с плавающей точкой. Хороший docstring пишут по существу: что принимает, что возвращает, какие бывают исключения. Именно эту строку покажет подсказка в редакторе при вводе вызова.
Рекурсия и функции как объекты
Функция может вызывать сама себя. Такая рекурсия нужна для обхода деревьев и вычислений, которые естественно делятся на меньшие части. У неё обязательно должно быть условие остановки.
def fact(n):
return 1 if n <= 1 else n * fact(n - 1)
print(fact(5)) # 120
Глубина рекурсии ограничена (по умолчанию около тысячи вызовов), при превышении будет RecursionError, поэтому для больших задач используют циклы. В Python функции - обычные объекты: их можно присваивать переменным, класть в списки и передавать в другие функции, как лямбды выше.
Когда функций и данных накопится много, их объединяют в классы, этому посвящена статья про ООП на Python. Закрепить материал помогут задачи на Python для начинающих, а для повторения циклов можно заглянуть в материал про циклы for в Python.
