Lambda в Python — это анонимная (безымянная) функция, которую используют для написания выражений в одну строку. Важно понимать, что в одном случае лямбда сделает код аккуратнее, а в другом — усложнит его.
Лямбда-функции полезны, когда нужно вернуть результат одного выражения. Но они не подходят для замены конструкций из нескольких шагов и конструкций со сложной обработкой условий.
Как читать и писать лямбда-выражения
Лямбда позволяет создать функцию без имени. Общая форма записи выглядит так:
lambda параметры: выражение
То есть мы объявляем функцию, передаем ей параметры и сразу указываем выражение, результат которого нужно вернуть.
Допустим, у нас есть обычная функция double(x):
def double(x): return x * 2 print(double(5))
Вывод: 10.
Эту же логику можно написать с помощью лямбда-выражения:
double = lambda x: x * 2 print(double(5))
Такая конструкция создает функцию, которая принимает число x и возвращает его удвоенное значение.
Иначе говоря, выражение lambda x: x * 2 можно прочитать так: «Возьми x и верни x * 2». С помощью лямбды мы сократили запись функции на одну строку, при этом читаемость почти не пострадала.
Как работает lambda
Лямбда работает так же, как обычные функции, то есть ее можно сохранить в переменную, передать в другую функцию или вызвать обычным способом.
По сути, лямбда создает объект функции, то есть сокращенную запись простой функции, возвращающей результат одного выражения.
Примеры лямбда-выражений
- Увеличить значение на единицу:
lambda x: x + 1
Напишем эту функцию в консоли Python (IDLE Shell). Объявим переменную x, присвоим лямбда-выражение переменной func и передадим в нее переменную x:
- Вернуть сумму параметров:
lambda a, b: a + b
Также используем func и передадим в нее уже две переменных — x и y.
- Преобразовать строку:
lambda s: s.strip().lower()
Эта функция принимает строку, убирает пробелы по краям и переводит символы в нижний регистр.
Тут мы присваиваем переменной s значение «Hello!», затем присваиваем лямбда-выражение переменной func. И только потом передаем в func значение s и выводим результат.
Где lambda используют на практике
В реальной практике лямбды чаще всего используют как короткие вспомогательные функции внутри других конструкций, например при сортировке или обработке коллекций.
Lambda в sorted()
Один из самых частых сценариев — это сортировка по определенному полю или признаку с помощью sorted().
users = [
{"name": "Anna", "age": 28},
{"name": "Ivan", "age": 21},
{"name": "Olga", "age": 25}
]
users_sorted = sorted(users, key=lambda user: user["age"])
print(users_sorted)
Вывод:
[{'name': 'Ivan', 'age': 21}, {'name': 'Olga', 'age': 25}, {'name': 'Anna', 'age': 28}]
Здесь lambda user: user[«age»] выступает как короткая функция-ключ. Она возвращает значение поля age для каждого элемента списка и именно по этим значениям sorted() выполняет сортировку.
Отдельную функцию через def здесь создавать не обязательно, потому что логика очень простая и читается сразу.
Lambda в map() и filter()
Лямбду также часто используют вместе с map() и filter().
- map()
numbers = [1, 2, 3, 4] squared = list(map(lambda x: x ** 2, numbers)) print(squared)
Тут lambda x: x ** 2 возводит каждый элемент списка в квадрат.
Вывод: [1, 4, 9, 16].
Но при этом список квадратов можно записать и без лямбды через списковое включение:
squared = [x ** 2 for x in numbers]
В официальной документации Python вариант со списковым включением называют более кратким и читаемым.
- filter()
evens = list(filter(lambda x: x % 2 == 0, numbers)) print(evens)
Здесь lambda x: x % 2 == 0 проверяет каждый элемент и возвращает True, если число четное, и False, если нечетное. Функция filter() оставляет только те элементы, для которых результат оказался истинным.
Вывод: [2, 4].
Когда lambda лучше не использовать
Лямбда-выражения не всегда удобны. Если запись начинает ухудшать читаемость или логика уже не помещается одно короткое действие, лучше перейти на обычный def.
Когда выражение становится громоздким
Это те случаи, когда лямбду можно использовать, но выражение становится длинным и трудночитаемым. Например:
result = sorted(data, key=lambda item: (item["category"], item["price"], item["name"].lower()))
Эту конструкцию можно записать нагляднее как отдельную функцию:
def sort_key(item): return item["category"], item["price"], item["name"].lower() result = sorted(data, key=sort_key)
У функции появилось имя, по которому можно понять, что она делает, и понятная структура.
Когда функция используется повторно
Если одна и та же логика нужна в нескольких местах, нет смысла каждый раз писать одинаковое лямбда-выражение. Лучше оформить ее как обычную функцию через def. Это упростит поддержку кода, и когда нужно будет править функцию, это можно будет сделать в одном месте, а не в каждом лямбда-выражении.
Когда в функции несколько шагов вычисления
Если в функции есть промежуточные действия, несколько проверок, комментарии, отладка или обработка ошибок, лучше сразу использовать def.
Например, не стоит превращать в лямбда-выражение многострочную функцию:
def normalize_price(price): price = float(price) if price < 0: return 0 return round(price, 2)
Если записать это в одну строку, мы получим следующее выражение:
normalize_price = lambda price: 0 if float(price) < 0 else round(float(price), 2)
Оно хуже читается и повторно вычисляет float(price). В обычной функции логика выглядит гораздо яснее.
Когда в функции нужен цикл
Еще одна частая ошибка — это попытка поместить в лямбду цикл или несколько последовательных действий. Например, так написать нельзя:
lambda items: for item in items: print(item)
Лямбда в Python допускает только одно выражение, а не полноценное тело функции.
Что не так с лямбдой внутри цикла
Если все же создавать лямбды внутри цикла, результат может оказаться неожиданным:
funcs = [] for x in range(5): funcs.append(lambda: x ** 2) print(funcs[2]())
Вывод: 16.
print(funcs[4]())
Вывод: 16.
Почему так происходит
В записи lambda: x ** 2 у лямбды нет собственного параметра x, поэтому она берет переменную x из внешней области видимости, то есть из цикла for x in range(5).
Когда цикл заканчивается, переменная x имеет последнее значение, равное 4. Поэтому при вызове каждая функция вычисляет 4 ** 2, и результат всегда один и тот же — 16.
Этот случай разобрали в официальном FAQ Python. Исправить его можно так:
funcs = [] for x in range(5): funcs.append(lambda n=x: n ** 2) print(funcs[2]())
Вывод: 4.
print(funcs[4]())
Вывод: 16.
Иначе говоря, мы создаем новый параметр n и сразу присваиваем ему текущее значение x в момент создания лямбды. В результате каждая функция сохраняет собственное значение и работает уже с ним, а не с общей переменной x, которая позже меняется в цикле.
Главное правило применения лямбды: используйте ее, когда нужна короткая функция в момент вызова другой функции. Но если код становится трудно читать без дополнительного объяснения, от лямбды лучше отказаться в пользу обычной функции.
Lambda в Python: коротко о главном
- Lambda (лямбда) в Python — это анонимная функция, которую используют для коротких и простых выражений.
- Чаще всего лямбда нужна там, где небольшую функцию нужно передать прямо в момент вызова другой функции, например в sorted(), map() или filter().
- Лямбда подходит только для написания одного выражения и не заменяет полноценную функцию через def.
- Если лямбда-выражение становится длинным или код требует комментариев, отладки, цикла или нескольких шагов вычисления, лучше использовать def.
- Если одна и та же логика повторяется в разных местах, ее тоже лучше вынести в обычную функцию, чтобы избежать повторов и сделать поддержку кода проще.
- Главный критерий выбора между лямбда-выражением и def — это читаемость кода. Если выражение сложно понять с первого взгляда, от лямбды лучше отказаться.
