Что такое лямбда-функция в Python

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

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

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

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

Синтаксис лямбда-функции в Python

Начнем с объяснения синтаксиса лямбда-функции.

Функция лямбда начинается с ключевого слова lambda, за которым следует список аргументов, разделенных запятыми. Следующий элемент — двоеточие (:), за которым следует одно выражение.

lambda <argument(s)>: <expression>

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

Ниже вы можете увидеть очень простую лямбду, которая умножает число x (аргумент) на 2:

lambda x: 2 * x

Вот что произойдет, если вы определите эту лямбду в оболочке Python, попробуйте:

>>> lambda x: 2 * x
<function <lambda> at 0x101451cb0>

Вы получаете обратно объект функции. Также, что интересно, при определении лямбды вам не нужен оператор return как часть выражения.

Если вы добавите к выражению оператор return, вы получите синтаксическую ошибку.

>>> lambda x: return 2 * x
  File "<stdin>", line 1
    lambda x: return 2 * x
                    ^
SyntaxError: invalid syntax

При определении лямбда-функции в Python нет необходимости включать оператор return.

Как использовать лямбда-функцию в Python

Мы увидели, как определить лямбду, но как ее вызвать?

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

(lambda x: 2*x)(2)

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

Это вывод лямбда-вызова:

>>> (lambda x: 2*x)(2)
4

Хороший!

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

>>> multiply = lambda x: 2*x
>>> multiply(2)
4

Я считаю, что это противоречит идее не давать лямбде имени, но об этом стоит знать.

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

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

Передача нескольких аргументов в лямбда-функцию

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

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

Создайте лямбду, которая умножает аргументы x и y:

lambda x, y: x * y

Как видите, два аргумента разделены запятой.

>>> (lambda x, y: x * y)(2, 3)
6

На выходе получаем правильное число (2*3).

Лямбда — это IIFE (Immediately Invoked Function Expression). Это способ сказать, что лямбда-функция выполняется немедленно, как только она определена.

Разница между лямбда-функцией и обычной функцией

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

Возьмем предыдущий пример:

lambda x, y:  x*y

Вы также можете записать это выражение как обычную функцию, используя ключевое слово def:

def multiply(x, y):
    return x*y

Вы сразу заметите три отличия по сравнению с лямбда-формой:

1. При использовании ключевого слова def необходимо указать имя функции.
2. Скобки заключают два аргумента.
3. Результат функции возвращается с помощью оператора return.

Как упоминалось ранее, присваивание лямбда-функции переменной необязательно:

multiply_lambda = lambda x, y:  x * y

Давайте сравним объекты для этих двух функций:

>>> def multiply(x, y):
...     return x * y
... 
>>> multiply
<function multiply at 0x100af4700>
>>> 
>>> multiply_lambda = lambda x, y:  x * y
>>> multiply_lambda
<function <lambda> at 0x100af45e0>

Здесь мы видим разницу: функция, определенная с помощью ключевого слова def, идентифицируется именем «multiply», тогда как лямбда-функция идентифицируется общей меткой <lambda>.

Давайте посмотрим, что возвращает встроенная функция type() при применении к обеим функциям:

>>> type(multiply)
<class 'function'>
>>> type(multiply_lambda)
<class 'function'>

Тип обеих функций одинаков.

Можно ли использовать If-Else в лямбда-выражении Python?

Давайте выясним, можно ли использовать оператор if-else в лямбда-функции.

lambda x: x if x > 2 else 2*x

Эта лямбда должна возвращать x, если x больше 2, в противном случае она должна возвращать x, умноженный на 2.

Во-первых, давайте проверим правильность синтаксиса:

>>> lambda x: x if x > 2 else 2*x
<function <lambda> at 0x101451dd0>

Пока ошибок нет, давайте проверим функцию, вызвав ее:

>>> (lambda x: x if x > 2 else 2*x)(1)
2
>>> (lambda x: x if x > 2 else 2*x)(2)
4
>>> (lambda x: x if x > 2 else 2*x)(3)
3

Логика if-else в лямбда-выражении работает хорошо.

Вы также можете заметить, что код может стать более трудным для чтения, если вы сделаете лямбда-выражение слишком сложным.

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

Также помните, что в лямбда-выражении не может быть нескольких операторов.

Обработка ошибок для лямбда-выражений Python

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

>>> multiply
<function multiply at 0x101451d40>
>>> multiply_lambda
<function <lambda> at 0x1014227a0>

Где multiply — это обычная функция, а multiple_lambda — это лямбда-функция.

Как вы можете видеть, объект функции для обычной функции идентифицируется по имени, в то время как объект функции лямбда идентифицируется по общему имени <lambda>.

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

Давайте создадим обычную функцию и передадим ей аргументы, которые заставят интерпретатор Python вызвать исключение:

def calculate_sum(x, y):
    return x+y

print(calculate_sum(5, 'Not_a_number'))

При запуске этого кода в оболочке Python вы получите следующую ошибку:

>>> def calculate_sum(x, y):
...     return x + y
... 
>>> print(calculate_sum(5, 'Not_a_number'))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in calculate_sum
TypeError: unsupported operand type(s) for +: 'int' and 'str'

Из трассировки видно, что ошибка возникает в строке 2 функции calculate_sum().

Теперь замените эту обычную функцию лямбда-функцией, реализующей ту же логику:

calculate_sum = lambda x, y: x + y
print(calculate_sum(5, 'Not_a_number'))

На этот раз вывод такой:

>>> calculate_sum = lambda x,y: x + y
>>> print(calculate_sum(5, 'Not_a_number'))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 1, in <lambda>
TypeError: unsupported operand type(s) for +: 'int' and 'str'

Тип исключения и сообщение об ошибке те же самые, но на этот раз трассировка сообщает нам, что произошла ошибка в строке 1 функции <lambda>.

Не очень полезно, если в вашем коде есть несколько лямбда-функций.

Вот почему вместо лямбда-функций следует использовать обычные функции.

Передача переменного списка аргументов в лямбда-выражение Python

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

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

Вот пример:

(lambda *args: max(args))(5, 3, 4, 10, 24)

При выполнении этого кода вы получаете максимум из аргументов, переданных лямбде:

>>> (lambda *args: max(args))(5, 3, 4, 10, 24)
24

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

Давайте убедимся, что это так, заменив args на переменные numbers:

>>> (lambda *numbers: max(numbers))(5, 3, 4, 10, 24)
24

Он по-прежнему отлично работает!

Еще примеры использования лямбда-функций

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

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

Вычислите площадь прямоугольника с помощью лямбды

>>> area = lambda length, width: length * width
>>> area(5, 4)
20

Перевернуть строку с помощью среза и лямбда-функции

>>> reverse_string = lambda s: s[::-1]
>>> reverse_string("hello")
'olleh'

Проверьте, находится ли число в заданном диапазоне, используя лямбда-функцию

>>> in_range = lambda x, low, high: low <= x <= high
>>> in_range(5, 1, 10)
True
>>> in_range(15, 1, 10) 
False

Заключение

В этом уроке мы рассмотрели:

• Что такое лямбда-функция Python.
• Как определить лямбду.
• Как выполнить лямбда.

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

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

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

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

Всегда помните, как важно писать чистый код. Код, который каждый может быстро понять и поддерживать.

Теперь у вас есть выбор между лямбдами и обычными функциями, сделайте правильный выбор! 🙂