Лямбда функции (выражения)

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

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

Пример кода с lambda выражением, при этом сохраняем выражение в переменной:

# вначале создаём переменную как выражение
# затем используем эту переменную
my_sum = lambda x, y: x+y
print(my_sum(3, 5))

### результат выполнения
8

Пример кода без сохранения lambda выражения в переменной:

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

### результат выполнения
8

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

Замыкания

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

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

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

Вот пример замыкания:

def main_func(value):
    name = value
    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(‘Саша’) и выполняю их.

То есть функция a — это функция inner_func() в которой предопределена переменная name = ‘Миша’. И подобная функция b — в которой предопределена переменная 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

Здесь у нас есть родительская функция main_func(value), и дочерняя inner_func(a). Дочерняя использует переменную от родительской — value. И родительская функция возвращает дочернюю — return inner.

Создаём экземпляры функции — a3 = adder(3) и a4 = adder(4). При этом функция a3() — это функция inner(a) с предопределённым value = 3. А функция a4() — это функция inner(a) с предопределенным value = 4.

Затем мы можем пользоваться этими функциями.

Очень хорошее видео по замыканиям, можно посмотреть здесь.

Декораторы

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

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

Вот пример:

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

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

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

### результат выполнения
hello world

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

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

Теперь навесим декоратор на функцию say(). Для этого просто перед созданием функции 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(). Эта функция теперь ссылается на вложенную функцию inner() в функции header(func).

А чтобы функция могла принимать аргументы мы должны прокинуть эти аргументы во вложенную функцию с помощью *args и **kwargs:

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

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

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

### результат выполнения
<h1>
hello
</h1>

Таким образом у нас есть просто функция say(), которая выводит в терминал то, что ей передают. И мы можем её задекорировать, декоратором @header, который мы написали ранее. Тогда функция say() начнёт обрамлять вывод html тегами <h1> и </h1>.

Также, можете посмотреть видео по декораторам — здесь.

Рекурсия

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

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

1. выводит значение переменной x;






2. вызывает саму себя, но с новыми значениями — rec(x+1); — рекурсивная функция






3. выводит значение переменной x;






4. и так до тех пор, пока x<4. — условие выхода из рекурсии

Записывается такая рекурсивная функция на языке Python следующим образом:

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. Сохраняет состояние (x=1).






2. Затем запускается rec(2). Она проверяет что x<4, и выводит в консоль 2. Сохраняет состояние (x=2).






3. Затем запускается rec(3). Она проверяет что x<4, и выводит в консоль 3. Сохраняет состояние (x=3).






4. Затем запускается rec(4). Проверяет что x<4, и так как условие не выполняется то функция завершает свою работу.






5. Продолжает работать предыдущая функция, она запомнила что x=3, выводит в консоль 3. И завершает свою работу.






6. Продолжает работать предыдущая функция, она запомнила что x=2, выводит в консоль 2. И завершает свою работу.






7. Продолжает работать предыдущая функция, она запомнила что x=1, выводит в консоль 1. И завершает свою работу.

Пример рекурсии «нахождение чисел Фибоначчи»

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

Здесь первое число всегда равно 0, а второе число равно 1. Остальные числа легко высчитываются по формуле (предыдущее число) + (число перед предыдущим). Другими словами формула такая: (n-1) + (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))

Мы ищем пятое число Фибоначчи. Если 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(4) и посчитали fib(3) + fib(2) = 1 + 1 = 2. То есть fib(4)=2.






2. вернулись к fib(5) и посчитали fib(4) + fib(3) = 2 + 1 = 3. То есть fib(5)=3.

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

Но помните, чем больше вложенность, тем медленнее работают рекурсивные функции. Например, если захотите вычислить 40-ое число Фибоначчи (print(fib(40))) — то придётся немного подождать. А если 45-ое — то долго подождать.

Здесь можете посмотреть видео по рекурсии.