Python 3. Функции

Разберём функции Python 3 с нуля. Узнаем, зачем они нужны, как их создавать и вызывать, как работают области видимости, *args и **kwargs. Познакомимся с лямбда-выражениями, замыканиями, декораторами и рекурсией.

Функции в Python 3

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

Функции в Python создаются с помощью оператора def, после которого идут название функции, круглые скобки и двоеточие. Ниже, с отступом, описывается то, что должна делать функция. Этот блок называют телом функции. Но сама по себе функция не выполняется, её нужно вызвать. Для этого пишем имя функции и круглые скобки.

Код:

def my_func():
    print('hello')

my_func()

Исполнение:

hello

Функция может не только что-то делать (считать, выводить в консоль и так далее), но и возвращать значение. Для этого используется оператор return. Вот пример:

Код:

def my_func():
    a = 2
    b = 3
    return a + b
    
my_func()

При таком вызове внешне ничего не происходит. Функция сложила значения переменных a и b, но никому об этом не сообщила. Зато она вернула результат сложения, то есть вызов функции my_func() превратился в значение 5. Чтобы в этом убедиться, передадим результат вызова в print():

Код:

def my_func():
    a = 2
    b = 3
    return a + b

print(my_func())

Исполнение:

5

Обратите внимание: return — это оператор, а не функция, поэтому скобки после него не нужны. Можно писать return(a+b) и это будет работать, но тогда скобки просто группируют выражение. Принято писать return a + b.

Оператор return не только возвращает значение, но и сразу завершает работу функции. Всё, что написано после него, выполнено не будет:

Код:

def my_func():
    print('до return')
    return 5
    print('после return')  # эта строка никогда не выполнится

my_func()

Исполнение:

до return

А что вернёт функция, если в ней нет return? Она вернёт специальное значение None, которое означает «ничего»:

Код:

def say_hello():
    print('hello')

result = say_hello()
print(result)

Исполнение:

hello
None

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

Возврат нескольких значений

Функция может вернуть сразу несколько значений, достаточно перечислить их через запятую. На самом деле Python вернёт один объект — кортеж, но его можно сразу «распаковать» в несколько переменных:

Код:

def min_max(numbers):
    return min(numbers), max(numbers)

low, high = min_max([4, 8, 1, 9, 3])
print(low, high)

Исполнение:

1 9

Документирование функции

Когда функций становится много, легко забыть, что делает каждая из них. Поэтому в первой строке тела функции принято писать краткое описание в тройных кавычках — docstring. Также можно указывать подсказки типов (type hints): какие типы данных функция ожидает и что возвращает.

Код:

def add(a: int, b: int) -> int:
    """Возвращает сумму двух чисел."""
    return a + b

print(add(2, 3))
print(add.__doc__)

Исполнение:

5
Возвращает сумму двух чисел.

Важно понимать, что подсказки типов Python не проверяет. Они нужны людям. Если передать в add() строки, функция всё равно отработает.

Области видимости переменных

Локальные переменные

Возьмём предыдущую функцию:

Код:

def my_func():
    a = 2
    b = 3
    return a + b

В ней есть две переменные: a и b. Эти переменные локальные для функции my_func(). Это означает, что в глобальном коде (в основной части программы) они не видны. Чтобы убедиться в этом, выполним функцию и попробуем получить значение переменной a:

Код:

my_func()
print(a)

Исполнение:

NameError: name 'a' is not defined

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

Код:

def my_func():
    a = 2
    print(a)

def my_func2():
    a = 3
    print(a)

my_func()
my_func2()
print(a)

Исполнение:

2
3
NameError: name 'a' is not defined

То есть первая функция вывела значение своей локальной переменной a = 2. Вторая функция вывела значение своей переменной a = 3. А из основного кода (из модуля) значение переменной a вывести не удалось, так как там такой переменной нет.

Вложенные функции и поиск переменных

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

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

Код:

a = 'глобальная переменная a'
b = 'глобальная переменная b'
c = 'глобальная переменная c'

def my_func():
    a = 'локальная переменная my_func a'
    b = 'локальная переменная my_func b'
    c = 'локальная переменная my_func c'

    def my_inner():
        a = 'локальная переменная my_inner a'
        b = 'локальная переменная my_inner b'
        c = 'локальная переменная my_inner c'

Когда функция ищет значение переменной, она всегда начинает поиск в своей локальной области. Если там не находит, то ищет в локальной области родительской функции. Если и там не находит, то ищет в глобальной области, то есть в основном коде программы. И в самую последнюю очередь — среди встроенных имён Python (таких как print или len).

Давайте изменим код так, чтобы функция my_func() вызывала my_inner(), а my_inner() выводила значение переменной a:

Код:

a = 'глобальная переменная a'
b = 'глобальная переменная b'
c = 'глобальная переменная c'

def my_func():
    a = 'локальная переменная my_func a'
    b = 'локальная переменная my_func b'
    c = 'локальная переменная my_func c'

    def my_inner():
        a = 'локальная переменная my_inner a'
        b = 'локальная переменная my_inner b'
        c = 'локальная переменная my_inner c'
        print(a)

    my_inner()

my_func()

Исполнение:

локальная переменная my_inner a

Теперь удалим переменную a из функции my_inner() и повторим:

Код:

a = 'глобальная переменная a'
b = 'глобальная переменная b'
c = 'глобальная переменная c'

def my_func():
    a = 'локальная переменная my_func a'
    b = 'локальная переменная my_func b'
    c = 'локальная переменная my_func c'

    def my_inner():
        b = 'локальная переменная my_inner b'
        c = 'локальная переменная my_inner c'
        print(a)

    my_inner()

my_func()

Исполнение:

локальная переменная my_func a

А теперь удалим переменную a ещё и из функции my_func():

Код:

a = 'глобальная переменная a'
b = 'глобальная переменная b'
c = 'глобальная переменная c'

def my_func():
    b = 'локальная переменная my_func b'
    c = 'локальная переменная my_func c'

    def my_inner():
        b = 'локальная переменная my_inner b'
        c = 'локальная переменная my_inner c'
        print(a)

    my_inner()

my_func()

Исполнение:

глобальная переменная a

Поиск переменных идёт снизу вверх: из локальной области функции к родительским функциям, а затем к глобальной области. Но не наоборот: из глобальной области локальные переменные функций не видны. Эту схему поиска часто запоминают по первым буквам: LEGB (Local, Enclosing, Global, Built-in).

Не локальные переменные

А если мы хотим из вложенной функции изменить переменную родительской функции? Для этого нужен оператор nonlocal. Давайте изменим переменную a функции my_func() из вложенной функции my_inner(). Дополнительно выведем значение переменной a из глобального кода:

Код:

a = 'глобальная переменная a'
b = 'глобальная переменная b'
c = 'глобальная переменная c'

def my_func():
    a = 'локальная переменная my_func a'
    b = 'локальная переменная my_func b'
    c = 'локальная переменная my_func c'

    def my_inner():
        nonlocal a
        a = 'изменённая переменная a'

    my_inner()
    print(a)

my_func()
print(a)  # глобальный код видит только глобальные переменные

Исполнение:

изменённая переменная a
глобальная переменная a

С помощью оператора nonlocal мы указали, что функция my_inner() обращается не к своей локальной, а к родительской переменной a.

Функция my_func() сначала создаёт переменные. Затем вызывает вложенную функцию my_inner(), которая изменяет переменную a родителя. После этого my_func() выводит значение a. А в глобальном коде после вызова my_func() выводится глобальная a, чтобы убедиться, что она не поменялась.

Глобальные переменные

А теперь из вложенной функции my_inner() изменим глобальную переменную a. Для этого используется оператор global. Он работает так же, как nonlocal, но указывает, что мы обращаемся не к родительской функции, а к глобальной переменной:

Код:

a = 'глобальная переменная a'
b = 'глобальная переменная b'
c = 'глобальная переменная c'

def my_func():
    a = 'локальная переменная my_func a'
    b = 'локальная переменная my_func b'
    c = 'локальная переменная my_func c'

    def my_inner():
        global a
        a = 'изменённая переменная a'

    my_inner()
    print(a)

my_func()
print(a)  # глобальный код видит только глобальные переменные

Исполнение:

локальная переменная my_func a
изменённая переменная a

Здесь my_inner() с помощью global изменила глобальную переменную a. А локальная переменная a функции my_func() не изменилась.

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

Частая ошибка: изменение глобальной переменной без global

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

Код:

counter = 0

def inc():
    counter += 1

inc()

Исполнение:

UnboundLocalError: cannot access local variable 'counter' where it is not associated with a value

Дело в том, что если в функции переменной присваивается значение (а counter += 1 — это тоже присваивание), то Python считает эту переменную локальной во всей функции. Но локальной counter ещё не существует, поэтому и возникает ошибка. Решения два: либо объявить global counter (не лучший вариант), либо передавать значение в функцию и возвращать результат:

Код:

counter = 0

def inc(value):
    return value + 1

counter = inc(counter)
print(counter)

Исполнение:

1

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

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

Вот пример функции с двумя параметрами:

Код:

def my_func(a, b):
    print(a + b)

Чтобы передать данные в функцию, нужно указать аргументы при её вызове:

Код:

my_func(2, 1)
my_func(3, 5)

Исполнение:

3
8

Здесь a и b — это параметры функции (то, что описано в def). А числа, с которыми мы вызывали функцию, (2, 1) и (3, 5) — это аргументы (то, что передано при вызове). Эти два слова часто путают, даже в книгах, и обычно по смыслу всё понятно. Но в официальной документации Python различие именно такое.

Аргументы, которые мы передали выше, называются позиционными: Python сопоставляет их с параметрами по порядку. Первый аргумент попадает в первый параметр, второй — во второй.

Значения параметров по умолчанию

Python позволяет задать для параметров значения по умолчанию:

Код:

def my_func(a=1, b=1):
    print(a + b)

my_func()
my_func(3, 5)

Исполнение:

2
8

Если вызвать функцию без аргументов, она возьмёт значения по умолчанию. А если аргументы указаны, то функция выполнится с ними.

Параметры со значениями по умолчанию должны идти после параметров без значений. Запись def my_func(a=1, b): вызовет синтаксическую ошибку.

Ловушка: изменяемое значение по умолчанию

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

Код:

def add_item(item, items=[]):
    items.append(item)
    return items

print(add_item('a'))
print(add_item('b'))

Исполнение:

['a']
['a', 'b']

Мы ожидали, что второй вызов вернёт ['b'], но список-по-умолчанию создался один раз и «запомнил» предыдущий вызов. Правильный способ — использовать None и создавать новый список внутри функции:

Код:

def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

print(add_item('a'))
print(add_item('b'))

Исполнение:

['a']
['b']

Неопределённое количество аргументов

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

Код:

def my_func(*args):
    print(args)       # кортеж переданных объектов
    print(sum(args))  # сумма объектов в кортеже
    for i in args:    # в цикле пробегаемся по элементам кортежа
        print(i)

my_func(3, 5, 7)

Исполнение:

(3, 5, 7)
15
3
5
7

Название args — просто устоявшаяся договорённость. Важна именно звёздочка перед именем, но лучше придерживаться общепринятого названия, чтобы код был понятен другим.

Именованные аргументы

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

Код:

def my_func(a, b, c):
    print(a, b, c)

my_func(a=15, c=4, b=8)  # именованные аргументы

Исполнение:

15 8 4

Позиционные и именованные аргументы можно комбинировать, но позиционные всегда должны идти первыми:

Код:

my_func(15, c=4, b=8)

Исполнение:

15 8 4

Неопределённое количество именованных аргументов

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

Код:

def my_func(**kwargs):
    print(kwargs)   # словарь именованных аргументов
    print(*kwargs)  # только ключи словаря

my_func(a=15, c=4, b=8)

Исполнение:

{'a': 15, 'c': 4, 'b': 8}
a c b

Здесь kwargs — это словарь. А запись *kwargs — это не отдельный объект, а распаковка: звёздочка «разворачивает» словарь в набор его ключей, которые print() выводит через пробел. Это работает со всеми итерируемыми объектами, например print(*[1, 2, 3]) выведет 1 2 3.

Пробежаться по словарю аргументов можно в цикле:

Код:

def my_func(**kwargs):
    for key, value in kwargs.items():
        print(key, '=>', value)

my_func(a=15, c=4, b=8)

Метод словатя kwargs.items() превращает словарь в список кортежей.

Исполнение:

a => 15
c => 4
b => 8

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

Код:

def my_func(a, b, *args, **kwargs):
    print(a, b, args, kwargs)

my_func(1, 2, 3, 4, x=10, y=20)

Исполнение:

1 2 (3, 4) {'x': 10, 'y': 20}

Первые два аргумента вошли в a и b, все остальные позиционные параметры вошли в *args, а все остальные именованные параметры вошли в *kwargs.

Звёздочки работают и в обратную сторону, при вызове функции. Так можно передать в неё список или словарь, «развернув» его в аргументы:

Код:

def my_func(a, b, c):
    print(a, b, c)

numbers = [1, 2, 3]
params = {'a': 10, 'b': 20, 'c': 30}

my_func(*numbers)
my_func(*params)
my_func(**params)

Исполнение:

1 2 3
a b c
10 20 30

Только позиционные и только именованные параметры

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

  • / — всё, что до него, можно передавать только позиционно;
  • * — всё, что после него, можно передавать только по имени.

Код:

def my_func(a, b, /, c, *, d):
    print(a, b, c, d)

my_func(1, 2, 3, d=4)
my_func(1, 2, c=3, d=4)

Исполнение:

1 2 3 4
1 2 3 4

А вот так вызвать функцию уже не получится:

Код:

my_func(a=1, b=2, c=3, d=4)

Исполнение:

TypeError: my_func() got some positional-only arguments passed as keyword arguments: 'a, b'

Лямбда-выражения

Лямбда-выражения (или лямбда-функции) — это мини-функции, которые записываются в одну строку и у которых нет имени. Они всегда возвращают результат, при этом return использовать не нужно.

Для создания используется оператор lambda, затем через запятую перечисляются параметры, после двоеточия записывается выражение, то есть что нужно сделать с этими параметрами.

Пример, в котором лямбда-выражение сохраняется в переменную:

Код:

my_sum = lambda x, y: x + y
print(my_sum(3, 5))

Исполнение:

8

Пример без сохранения в переменную. Мы создаём выражение и сразу вызываем его:

Код:

print((lambda x, y: x + y)(3, 5))

Исполнение:

8

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

Где же лямбды действительно удобны? Там, где нужна маленькая функция «на один раз», чаще всего как аргумент другой функции. Например, для сортировки списка по какому-нибудь признаку:

Код:

words = ['python', 'go', 'bash', 'c']

# сортируем по послденей букве слова
print(sorted(words, key=lambda w: w[-1]))

Слова в w передаёт сама функция sorted(). Вы лямбду не вызываете, вы отдаёте её в sorted() как инструкцию: «вот функция, вызови её для каждого элемента списка и по результатам отсортируй». Внутри sorted() происходит примерно следующее:

  1. Берёт первый элемент списка ('python') и вызывает вашу функцию: key('python'). В w попадает 'python', функция возвращает w[-1], то есть 'n'.
  2. То же самое делает для 'go', получает 'o'.
  3. Для 'bash' получает 'h'.
  4. Для 'c' получает 'c'.
  5. Сортирует элементы по этим результатам ('n', 'o', 'h', 'c'), но в итоговый список кладёт исходные слова, а не результаты функции.

Исполнение:

['c', 'bash', 'python', 'go']

Функции sorted() мы указываем, по какому признаку сортировать. Создавать ради этого отдельную функцию через def избыточно, поэтому проще передать маленькую лямбду.

Замыкания

После того как мы разобрали вложенные функции и области видимости, будет проще понять замыкания.

Замыкание — это вложенная функция, которая использует переменные родительской функции и «помнит» их, даже когда родительская функция уже завершила работу. Для этого родительская функция должна вернуть вложенную функцию, но не вызвать её, то есть return inner_func, а не return inner_func().

Благодаря этому мы можем создавать несколько «экземпляров» такой функции и использовать их независимо. Это похоже на экземпляры класса, хотя классы функциональнее и понятнее логически. Вот пример замыкания:

Код:

def main_func(name):
    def inner_func():
        print('Привет, мой друг', name)
    return inner_func

b = main_func('Миша')
b()
c = main_func('Саша')
c()

Исполнение:

Привет, мой друг Миша
Привет, мой друг Саша

У нас есть родительская функция main_func() и вложенная inner_func(). Родительская возвращает вложенную (return inner_func). Вложенная использует переменную родительской функции — name. Значит, замыкание мы сделали.

Затем в основном коде создаём «экземпляры» функции: b = main_func('Миша') и c = main_func('Саша') — и вызываем их. Функция b — это inner_func(), в которой name = 'Миша'. А функция c — это тоже inner_func(), но с name = 'Саша'.

Второй пример чуть сложнее:

Код:

def adder(value):
    def inner(a):
        return value + a
    return inner

a3 = adder(3)
a4 = adder(4)

print(a3(1))
print(a4(3))

Исполнение:

4
7

Здесь родительская функция adder(value) и вложенная inner(a). Вложенная использует переменную родителя — value. А родитель возвращает вложенную функцию — return inner.

Создаём «экземпляры»: a3 = adder(3) и a4 = adder(4). Функция a3() — это inner(a) с запомненным value = 3, а a4() — это inner(a) с запомненным value = 4. Затем мы можем вызывать их как обычные функции.

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

Код:

def make_counter():
    count = 0
    def counter():
        nonlocal count
        count += 1
        return count
    return counter

c1 = make_counter()
c2 = make_counter()

print(c1())
print(c1())
print(c1())
print(c2())

Исполнение:

1
2
3
1

Каждый счётчик хранит своё собственное значение count, и они друг на друга не влияют.

Декораторы

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

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

Код:

# Декоратор
def header(func):
    def inner():
        print('<h1>')
        func()
        print('</h1>')
    return inner

# Функция
def say():
    print('hello world')

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

Исполнение:

hello world

Сначала мы создали функцию-декоратор header(func). Она принимает функцию func и возвращает вложенную функцию inner(), которая печатает html-тег <h1>, вызывает func(), а затем печатает закрывающий тег </h1>.

А функция say() просто выводит в консоль hello world. Декоратор мы написали, но пока не применили.

Теперь «навесим» декоратор на функцию say(). Для этого перед её созданием напишем символ @ и имя декоратора (@header):

Код:

# Декоратор
def header(func):
    def inner():
        print('<h1>')
        func()
        print('</h1>')
    return inner

# Навесили декоратор на функцию
@header
def say():
    print('hello world')

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

Исполнение:

<h1>
hello world
</h1>

Так мы изменили поведение функции say(). Запись @header — это просто сокращение для такой строки:

Код:

say = header(say)

То есть имя say теперь указывает не на исходную функцию, а на вложенную inner(), которую вернул декоратор. А исходная say() сохранилась внутри как переменная func.

Чтобы декорированная функция могла принимать аргументы, нужно «прокинуть» их во вложенную функцию с помощью *args и **kwargs. А чтобы не потерять возвращаемое значение, результат вызова func() нужно вернуть:

Код:

# Декоратор
def header(func):
    def inner(*args, **kwargs):
        print('<h1>')
        result = func(*args, **kwargs)
        print('</h1>')
        return result
    return inner

# Навесили декоратор на функцию
@header
def say(n):
    print(n)

# Вызов функции
say('hello')

Исполнение:

<h1>
hello
</h1>

Теперь say() по-прежнему выводит то, что ей передали, но дополнительно обрамляет вывод тегами <h1> и </h1>. А благодаря *args и **kwargs один и тот же декоратор подойдёт для функций с любым набором параметров.

Сохраняем имя и описание функции: functools.wraps

У декорированных функций есть неприятная особенность: они «теряют» своё имя и описание. Проверим:

Код:

print(say.__name__)

Исполнение:

inner

Мы вызываем say(), а Python считает, что это функция inner. Это неудобно при отладке и в сообщениях об ошибках. Чтобы исправить, в стандартной библиотеке есть декоратор functools.wraps, который копирует имя, docstring и другие данные исходной функции во вложенную:

Код:

from functools import wraps

def header(func):
    @wraps(func)
    def inner(*args, **kwargs):
        print('<h1>')
        result = func(*args, **kwargs)
        print('</h1>')
        return result
    return inner

@header
def say(n):
    print(n)

print(say.__name__)

Исполнение:

say

Хорошая привычка — всегда добавлять @wraps(func) во вложенную функцию любого декоратора, который вы пишете.

Практический пример: замер времени работы

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

Код:

import time
from functools import wraps

def timer(func):
    @wraps(func)
    def inner(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        end = time.perf_counter()
        print(f'{func.__name__} выполнилась за {end - start:.3f} сек')
        return result
    return inner

@timer
def slow_sum(n):
    return sum(range(n))

print(slow_sum(10_000_000))

Исполнение:

slow_sum выполнилась за 0.084 сек
49999995000000

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

Рекурсия

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

Допустим, у нас есть рекурсивная функция rec(x), которая:

  1. выводит значение переменной x;
  2. вызывает саму себя с новым значением — rec(x+1) — это и есть рекурсивный вызов;
  3. после возврата снова выводит значение x;
  4. и всё это происходит, только пока x < 4 — это условие выхода из рекурсии.

Записывается такая функция так:

def rec(x):
    if x < 4:
        print(x)    # до входа в следующий уровень рекурсии
        rec(x + 1)  # рекурсивный вызов
        print(x)    # после выхода из следующего уровня

rec(1)

Исполнение:

1
2
3
3
2
1

Ещё раз разберём, как это работает:

  1. Мы вызываем rec(1). Она проверяет, что x < 4, и выводит в консоль 1. Затем вызывает rec(2) и ждёт, пока та закончит работу (при этом помнит, что у неё x = 1).
  2. rec(2) проверяет, что x < 4, выводит 2 и вызывает rec(3).
  3. rec(3) проверяет, что x < 4, выводит 3 и вызывает rec(4).
  4. rec(4) проверяет условие. Так как 4 < 4 — ложь, функция ничего не делает и завершается.
  5. Продолжает работать rec(3). Она помнит, что x = 3, выводит в консоль 3 и завершается.
  6. Продолжает работать rec(2). Она помнит, что x = 2, выводит 2 и завершается.
  7. Продолжает работать rec(1). Она помнит, что x = 1, выводит 1 и завершается.

Ограничение глубины рекурсии

Каждый рекурсивный вызов занимает память, поэтому в Python есть ограничение на глубину рекурсии. По умолчанию это 1000 вызовов. Посмотреть текущее значение можно так:

import sys
print(sys.getrecursionlimit())

Исполнение:

1000

Если забыть про условие выхода (или сделать его недостижимым), то Python остановит программу с ошибкой:

Код:

def rec(x):
    rec(x + 1)  # условия выхода нет

rec(1)

Исполнение:

RecursionError: maximum recursion depth exceeded

Пример рекурсии: числа Фибоначчи

Вот ещё один пример рекурсивной функции — поиск чисел Фибоначчи. Это числа, каждое из которых равно сумме двух предыдущих. Ряд начинается с 0 и 1, а дальше идёт сложение: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 и так далее.

Первое число всегда равно 0, а второе — 1. Остальные считаются по формуле: (предыдущее число) + (число перед предыдущим), то есть fib(n-1) + fib(n-2).

Код такой функции:

def fib(n):
    if n == 1:
        return 0  # первое число Фибоначчи всегда 0
    if n == 2:
        return 1  # второе число Фибоначчи всегда 1
    return fib(n - 1) + fib(n - 2)

print(fib(5))

Исполнение:

3

Мы ищем пятое число Фибоначчи. Если n = 1, то это ноль. Если n = 2, то единица. Любое другое число считается по формуле fib(n-1) + fib(n-2).

В нашем примере функция работает так:

  1. fib(5) — запомнили, что n = 5, и вызвали fib(4) + fib(3);
    • fib(4) — запомнили, что n = 4, и вызвали fib(3) + fib(2);
      • fib(3) — запомнили, что n = 3, и вызвали fib(2) + fib(1);
        • fib(2) — вернула 1;
        • fib(1) — вернула 0;
      • вернулись к fib(3) и посчитали fib(2) + fib(1) = 1 + 0 = 1. То есть fib(3) = 1.
      • fib(2) — вернула 1;
    • вернулись к fib(4) и посчитали fib(3) + fib(2) = 1 + 1 = 2. То есть fib(4) = 2.
    • fib(3) — снова считается так же, как выше, и возвращает 1;
  2. вернулись к fib(5) и посчитали fib(4) + fib(3) = 2 + 1 = 3. То есть fib(5) = 3.

Работу рекурсии можно представить как обход дерева: сначала вглубь, а затем обратно.

Обратите внимание, что fib(3) в этом примере вычисляется дважды, и чем больше n, тем больше повторных вычислений. Количество вызовов растёт очень быстро, поэтому такая функция работает медленно. Например, print(fib(40)) придётся подождать несколько секунд, а print(fib(45)) — уже около минуты (точное время зависит от компьютера и версии Python).

Ускоряем рекурсию с помощью кэша

Проблема в том, что мы раз за разом считаем одно и то же. Эту проблему легко решить: нужно запоминать уже вычисленные результаты. В стандартной библиотеке для этого есть декоратор functools.cache (он появился в Python 3.9):

Код:

from functools import cache

@cache
def fib(n):
    if n == 1:
        return 0
    if n == 2:
        return 1
    return fib(n - 1) + fib(n - 2)

print(fib(40))
print(fib(100))

Исполнение:

63245986
218922995834555169026

Теперь результат появляется мгновенно, даже для fib(100), который без кэша мы бы не дождались никогда. Декоратор запоминает, с какими аргументами функция уже вызывалась, и при повторном вызове сразу возвращает готовый результат.

Итог

Если вы дошли до конца этой довольно длинной статьи, то должны были узнать про функции и оператор def, про возвращаемые значения и оператор return. Мы разобрали области видимости и вложенные функции, узнали про операторы nonlocal и global. Познакомились с параметрами и аргументами, узнали, что аргументы бывают позиционные и именованные, а также разобрались с *args и **kwargs. Узнали про значения по умолчанию и ловушку с изменяемыми объектами. Познакомились с маленькими лямбда-выражениями. А также разобрали замыкания, декораторы и рекурсию.


Если понравилась статья, подпишись на мой канал в VK или Telegram .