Вам необходимо отсортировать товары по цене. Написание отдельной именованной функции только для того, чтобы сказать «используйте цену», кажется большой церемонией. Лямбда-функции Python позволяют вам определить этот крошечный фрагмент логики прямо там, где вы его используете.

Лямбды удобны, но ими легко злоупотреблять. В этом руководстве показано, где они действительно помогают, а где затрудняют чтение кода. Мы запускали каждый пример на Python 3.13, и показанный результат получен в результате этого запуска.

Что такое лямбда?

Лямбда — это функция без имени, записанная с ключевым словом lambda:

lambda arguments: expression

Он принимает любое количество аргументов и автоматически возвращает значение одного выражения. Здесь нет ключевого слова return и тела операторов.

square = lambda x: x * x
print(square(4))                     # 16

print((lambda a, b=10: a + b)(5))    # 15

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

лямбда против защиты

Эти два создают функции, которые ведут себя одинаково:

square = lambda x: x * x

def square_def(x):
    return x * x

print(square(4), square_def(4))                 # 16 16
print(square.__name__, square_def.__name__)     # <lambda> square_def

Посмотрите на имена. Каждая лямбда называется просто <lambda>, поэтому сообщения об ошибках и журналы не могут сказать вам, какой из них произошел сбой. Это основная причина, по которой руководства по стилю, такие как PEP 8, рекомендуют использовать def всякий раз, когда вы хотите дать функции имя.

Сортировка по ключу: лучшее применение

Такие функции, как sorted, min и max, принимают функцию key, которая решает, что сравнивать. Вот где сияют лямбды:

products = [("pen", 10), ("bag", 900), ("book", 250)]

sorted(products, key=lambda p: p[1])
# [('pen', 10), ('book', 250), ('bag', 900)]

max(products, key=lambda p: p[1])
# ('bag', 900)

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

people = [{"name": "Asha", "age": 31}, {"name": "Ben", "age": 25},
          {"name": "Dev", "age": 31}]

[p["name"] for p in sorted(people, key=lambda p: (-p["age"], p["name"]))]
# ['Asha', 'Dev', 'Ben']

Знак минус меняет порядок только чисел. Иногда вам вообще не нужна лямбда, потому что существующая функция уже выполняет эту работу. Сравните сортировку по умолчанию с сортировкой без учета регистра:

names = ["Asha", "ben", "Chitra", "dev"]

sorted(names)                  # ['Asha', 'Chitra', 'ben', 'dev']
sorted(names, key=str.lower)   # ['Asha', 'ben', 'Chitra', 'dev']

По умолчанию все слова, написанные с заглавной буквы, ставятся на первое место. Передача str.lower исправляет это без каких-либо лямбда-выражений. Модуль operator предлагает аналогичные помощники, например itemgetter(1) для lambda p: p[1].

карта и фильтр

map применяет функцию к каждому элементу, а filter сохраняет элементы, для которых она возвращает true. Оба работают с лямбда-выражениями, но сравнивают каждый с пониманием списка:

nums = [1, 2, 3, 4, 5, 6]

list(map(lambda n: n * 10, nums))      # [10, 20, 30, 40, 50, 60]
[n * 10 for n in nums]                 # [10, 20, 30, 40, 50, 60]

list(filter(lambda n: n % 2 == 0, nums))   # [2, 4, 6]
[n for n in nums if n % 2 == 0]            # [2, 4, 6]

Результаты идентичны, и большинство разработчиков Python считают, что понимание легче читать. Обратите также внимание, что map и filter возвращают ленивые итераторы, поэтому вам нужно list(), чтобы увидеть значения. Наше руководство по пониманию списков в Python подробно описывает этот стиль. map по-прежнему хорошо читается с существующей именованной функцией, как в map(str.strip, lines).

уменьшить

functools.reduce объединяет элементы в одно значение, несущее текущий результат:

from functools import reduce

reduce(lambda acc, n: acc + n, nums, 0)   # 21
sum(nums)                                 # 21

Для обычных заданий, таких как итоговые значения, используйте встроенные функции, например sum, max или any. Сохраните reduce для более редких случаев и рассмотрите простой цикл, если лямбда начинает выглядеть сложной.

Условия в лямбде

Вы не можете использовать оператор if в лямбде, но можете использовать условное выражение:

label = lambda total: "large" if total >= 1000 else "small"

label(1200), label(300)
# ('large', 'small')

Одно условие — это хорошо. Как только вы начнете их вкладывать, читателям придется потрудиться, что является явным признаком перехода к def ​​с обычными if операторами.

Лямбды, возвращающие функции

Функция может создавать и возвращать лямбду, которая запоминает значение из своего окружения:

def multiplier(n):
    return lambda x: x * n

double = multiplier(2)
double(7)   # 14

Это работает благодаря замыканиям, которые в нашей статье о замыканиях JavaScript объясняются на другом языке. Python functools.partial предлагает другой способ предварительного заполнения аргументов.

Ловушка позднего связывания

В конечном итоге это затрагивает почти всех. Мы создали три лямбды в цикле, ожидая, что каждая вернет свой номер:

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

# [2, 2, 2]

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

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

# [0, 1, 2]

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

Таблицы поиска небольших функций

Лямбды аккуратно вписываются в словарь, который сопоставляет имена небольшим операциям:

ops = {
    "add": lambda a, b: a + b,
    "sub": lambda a, b: a - b,
}

ops["sub"](10, 3)   # 7

Это может заменить длинную цепочку из if и elif. Руководство Словарь Python охватывает больше шаблонов словарей, а модуль operator уже предоставляет operator.add и operator.sub.

Пределы лямбд

• Только одно выражение. Никаких присваиваний с =, циклов и блоков try.
• Нет утверждений. Запись lambda x: return x с SyntaxError не удалась, как подтвердил наш тест.
• Нет строки документации или подсказок по типам. Инструменты и читатели получают меньше помощи.
• Усложнение отладки. Ошибки указывают на <lambda>, а не на полезное имя.

Конечно, лямбда-выражения все еще могут вызывать исключения. Их обработка работает так же, как и для любой функции, как описано в Обработка исключений Python.

Когда не следует использовать лямбду

Последний пункт имеет значение. Логику, достойную повторного использования, стоит тестировать, а именованную функцию тестировать гораздо проще, как показывает наше руководство по pytest.

Итоги

Хорошая лямбда достаточно коротка, чтобы ее можно было прочитать с первого взгляда, и используется один раз, обычно в качестве аргумента. Сортировка ключей — классический пример. Чтобы проверить свой собственный код, найдите = lambda и превратите его в именованные функции. Затем посмотрите на любой map или filter с лямбда-выражением и посмотрите, будет ли понимание читаться лучше.

Часто задаваемые вопросы

Продолжайте учиться