Lambda в Python: функция в одну строку

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

Что такое lambda в Python: коротко

lambda — это функция без имени, записанная в одну строку: слева от двоеточия перечисляются аргументы, справа — одно выражение, значение которого возвращается само. Её не создают, чтобы хранить, а передают аргументом туда, где нужно правило: sorted, map, filter. Отдельная def нужна, когда правилу требуется имя или тело длиннее одного выражения.

Правило без имени

Сравним две записи одного и того же правила «умножь на два»:

def double_def(x):
    return x * 2

double_lambda = lambda x: x * 2

print(double_def(5))
print(double_lambda(5))

10
10

Оба вызова вернули десятку: lambda — та же функция, только записанная компактнее. Разбираем запись lambda x: x * 2 по частям:

• lambda — ключевое слово: начинается функция-выражение;
• x — аргументы: стоят до двоеточия, через запятую, как у def;
• двоеточие отделяет аргументы от тела;
• x * 2 — тело: ровно одно выражение; его значение lambda и возвращает, слово return не пишется.

Аргументы lambda стоят до двоеточия, а после двоеточия пишут одно выражение — его значение lambda и возвращает. Присваивание double_lambda = ... здесь показано для сравнения с def: так видно, что перед вами функция. В настоящем коде lambda в переменную почти не сохраняют — её настоящее применение впереди.

Несколько аргументов

Аргументов может быть сколько нужно — через запятую до двоеточия:

total = lambda price, quantity: price * quantity

print(total(150, 3))
print(total(80, 2))

450
160

Правило «цена умножить количество» поместилось в одну строку: price и quantity — аргументы, price * quantity — выражение, чьё значение возвращается. Всё, что умела def с аргументами — позиционные вызовы, имена, умолчания — lambda тоже умеет.

Главное применение: lambda как аргумент

Настоящая сила lambda раскрывается, когда функция передаётся в другую функцию. В Python функции — полноценные значения: их можно передавать аргументами, как строки и числа. Напишем функцию apply, которая принимает список и правило — и применяет правило к каждому элементу:

def apply(numbers, rule):
    result = []
    for n in numbers:
        result.append(rule(n))
    return result

print(apply([1, 2, 3, 4], lambda n: n * 10))
print(apply([1, 2, 3, 4], lambda n: n ** 2))

[10, 20, 30, 40]
[1, 4, 9, 16]

Функция apply написана один раз, а правила приходят аргументом: в теле цикла rule(n) вызывает то, что передали — умножение на десять во втором вызове, квадрат в третьем. lambda создана прямо на месте вызова, без имени: она нужна только здесь и сейчас. Это главный способ использования lambda в реальном коде — не хранить, а передавать.

Правило может быть любым коротким выражением — работа со строками не исключение:

def apply_all(items, rule):
    result = []
    for item in items:
        result.append(rule(item))
    return result

words = ['кот', 'собака', 'ёж']
print(apply_all(words, lambda w: len(w)))
print(apply_all(words, lambda w: w.upper()))

[3, 6, 2]
['КОТ', 'СОБАКА', 'ЁЖ']

В тело lambda помещается и выражение с if-else — это по-прежнему одно выражение, а не инструкция:

def apply_all(numbers, rule):
    result = []
    for n in numbers:
        result.append(rule(n))
    return result

print(apply_all([1, 2, 3, 4], lambda n: 'чёт' if n % 2 == 0 else 'нечёт'))

['нечёт', 'чёт', 'нечёт', 'чёт']

Выражение «значение если условие, иначе другое значение» посчиталось для каждого числа и вернуло слово. Даже с условием тело lambda остаётся одним выражением — это жёсткое ограничение.

Границы lambda

Ограничение — одно выражение. Всё, что требует инструкций: присваивания, циклы, несколько строк — в lambda не помещается:

# Так не запускается: в lambda тело — выражение, return не нужен
f = lambda x: return x * 2

# Так не запускается: тело lambda обязано быть одним выражением на той же строке
f = lambda x:
    y = x * 2
    return y

Второе ограничение — про печать. Функцию нельзя напечатать осмысленно: вместо кода выведется служебная запись с адресом памяти:

# Так не делают: печать функции даёт служебную запись
double = lambda x: x * 2
print(double)
print(double(5))

lambda или def: правило выбора

Правило выбора простое. Правилу нужно имя или тело больше одного выражения — пишите def, как во всех прошлых уроках. Правило короткое и нужно прямо сейчас, как аргумент — lambda на месте вызова. Сохранять lambda в переменную с осмысленным именем не стоит: для именованных функций есть def.

• передача правила в функции обработки списков — map и filter из следующего урока принимают lambda первым делом;
• сортировка по своему критерию: sorted с именованным аргументом key и lambda внутри — тема урока про sorted;
• правила-вычисления для словарей и таблиц, когда правило умещается в выражение.

lambda освоена как правило-аргумент — теперь появились инструменты, которые такое правило ждут. В уроке про map правило применяется к каждому элементу списка одной строкой вместо цикла с append, а возврат значения lambda делают автоматически, как это делает return в обычных функциях из урока про возврат результата.

Под капотом lambda — обычная функция

Никакой отдельной сущности «лямбда» в Python нет. Это синтаксический сахар: запись lambda x: x * 2 создаёт такой же объект функции, как def double(x), просто без имени и без тела из нескольких строк. Проверить легко — посмотрите на тип:

f = lambda x: x + 1

print(type(f))
print(callable(f))

<class 'function'>
True

Отсюда следуют две вещи. Первая: lambda можно положить в переменную, список, словарь, передать аргументом, вернуть из другой функции — обращаться с ней можно как с любой функцией. Вторая: у lambda есть __name__, но там лежит строка <lambda> вместо имени. В трассировке и в отладке вы увидите <lambda> — и это сигнал, что функции не хватает имени.

lambda в цикле: все функции помнят одно и то же

Отдельная ловушка, на которой мы потеряли вечер. Если собрать несколько lambda в цикле и потом вызвать их, все они вернут одно и то же значение — последнее. Потому что lambda не копирует переменную цикла, а ссылается на неё, и к моменту вызовов переменная уже дошла до конца.

funcs = []
for i in range(3):
    funcs.append(lambda: i)

print([f() for f in funcs])

[2, 2, 2]

Ожидали [0, 1, 2] — получили [2, 2, 2]. Переменная i у всех трёх lambda одна и та же: та, что осталась в области видимости после цикла. К моменту, когда мы вызвали функции, в ней было 2. Лечится это значением по умолчанию, которое копируется в момент создания lambda:

funcs = []
for i in range(3):
    funcs.append(lambda i=i: i)

print([f() for f in funcs])

[0, 1, 2]

Когда lambda становится неудобной

lambda заканчивается там, где начинается что-то одноразовое. Если правило переиспользуется, требует описания или перестаёт помещаться в строку, короткая запись мешает больше, чем помогает.

Мы держимся простого правила: правило не помещается в одну строку или его нужно назвать — пишем def. lambda — это не способ писать короткий код вообще, это способ передать правило туда, где оно нужно, и забыть о нём сразу после вызова.

Практика: три правила для одного списка

Типичная задача — прогнать одни и те же данные через несколько правил. Одна функция и три lambda рядом: ни одно из правил не появляется в коде под именем.

def apply_all(items, rule):
    return [rule(item) for item in items]

prices = [100, 250, 80]

print(apply_all(prices, lambda p: p * 2))
print(apply_all(prices, lambda p: p - p // 10))
print(apply_all(prices, lambda p: p > 150))

[200, 500, 160]
[90, 225, 72]
[False, True, False]

Третье правило отвечает на вопрос «а что осталось», а не «сколько получилось» — по списку True и False. Такие фильтры в Python вынесены в отдельную функцию: filter из урока 8 делает ровно это одной строкой, а map из следующего урока — то же, что наша apply_all, только встроенная в язык.