Что такое lambda в питоне

Лямбда-функция в Python простыми словами

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

Лямбда-функции в Python являются анонимными. Это означает, что функция безымянна. Как известно, ключевое слов def используется в Python для определения обычной функции. В свою очередь, ключевое слово lambda используется для определения анонимной функции.

Лямбда-функция имеет следующий синтаксис.

Lambda аргументы: выражение

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

1.1. Пример лямбда-функции.

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

double = lambda x: x*2 print(double(5))

Вывод:

В вышеуказанном коде lambda x: x*2 — это лямбда-функция. Здесь x — это аргумент, а x*2 — это выражение, которое вычисляется и возвращается.

Эта функция безымянная. Она возвращает функциональный объект с идентификатором double . Сейчас мы можем считать её обычной функцией.

double = lambda x: x*2

def double(x): return x * 2

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

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

Рассмотрим пример и попробуем понять различие между определением ( Def ) для обычной функции и lambda —функции. Этот код возвращает заданное значение, возведенное в куб:

def defined_cube(y): return y*y*y lambda_cube = lambda y: y*y*y print(defined_cube(2)) print(lambda_cube(2))

Как показано в примере выше, обе представленные функции, defined_cube() и lambda_cube() , ведут себя одинаково, как и предполагалось.

Разберем вышеуказанный пример подробнее:

• Без использования лямбды: Здесь обе функции возвращают заданное значение, возведенное в куб. Но при использовании def , нам пришлось определить функцию с именем и defined_cube() дать ей входную величину. После выполнения нам также понадобилось возвратить результат, из того места, откуда была вызвана функция, и мы сделали это, используя ключевое слово return .
• С применением лямбды: Определение лямбды не включает оператор return , а всегда содержит возвращенное выражение. Мы также можем поместить определение лямбды в любое место, где ожидается функция, и нам не нужно присваивать его переменной. Так выглядят простые лямбда-функции.

3. Лямбда-функции и функции высшего порядка

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

В Python мы часто используем их как аргумент функции высшего порядка (функции, которая принимает другие функции в качестве аргументов). Лямбда-функции используют вместе с такими встроенными функциями как filter() , map() , reduce() и др.

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

3.1. Пример с filter()

Функция filter() в Python принимает в качестве аргументов функцию и список .

Функция вызывается со всеми элементами в списке, и в результате возвращается новый список, содержащий элементы, для которых функция результирует в True .

Вот пример использования функции filter() для отбора четных чисел из списка.

my_list = [1, 3, 4, 6, 10, 11, 15, 12, 14] new_list = list(filter(lambda x: (x%2 == 0) , my_list)) print(new_list)

Вывод:

[4, 6, 10, 12, 14]

3.2. Пример с map()

Функция map() принимает в качестве аргументов функцию и список.

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

Ниже пример использования функции map() для удвоения всех элементов списка.

current_list = [1, 3, 4, 6, 10, 11, 15, 12, 14] new_list = list(map(lambda x: x*2 , current_list)) print(new_list)

Вывод:

[2, 6, 8, 12, 20, 22, 30, 24, 28]

3.3. Пример с reduce()

Функция reduce() принимает в качестве аргументов функцию и список. Функция вызывается с помощью лямбда-функции и итерируемого объекта и возвращается новый уменьшенный результат. Так выполняется повторяющаяся операцию над парами итерируемых объектов. Функция reduce() входит в состав модуля functools .

from functools import reduce current_list = [5, 15, 20, 30, 50, 55, 75, 60, 70] summa = reduce((lambda x, y: x + y), current_list) print(summa)

Вывод:

Здесь результаты предыдущих двух элементов суммируются со следующим элементом, и это продолжается до конца списка, вот так:

5+15+20+30+50+55+75+60+70

4. Лямбда и списковое включение

В этом примере мы будем использовать лямбда-функцию со списковым включением и лямбда-функцию с циклом for . Мы выведем на экран таблицу из 10 элементов.

tables = [lambda x = x: x*10 for x in range(1, 11)] for table in tables: print(table())

Вывод:

10 20 30 40 50 60 70 80 90 100

5. Лямбда и условные операторы

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

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

max_number = lambda a, b: a if a > b else b print(max_number(3, 5))

Вывод:

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

6. Лямбда и множественные операторы

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

current_list = [[10,6,9],[0, 14, 16, 80],[8, 12, 30, 44]] sorted_list = lambda x: (sorted(i) for i in x) second_largest = lambda x, func: [y[len(y)-2] for y in func(x)] result = second_largest(current_list, sorted_list) print(result)

Вывод:

[9, 16, 30]

В предыдущем примере, мы создали лямбда-функцию, которая сортирует каждый вложенный список в заданном списке. Затем этот список проходит как параметр для второй лямбда-функции, которая возвращает элемент n-2 из отсортированного списка, где n — длина вложенного списка.

Заключение

Теперь вы знаете как использовать в Python lambda -функции и можете:

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

• python
• лямбда-выражения
• списки
• математические операции

Лямбда-функции в Python: примеры

Лямбда-функции – это анонимные функции, которые содержат только одно выражение.

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

В Python мы обычно создаём функции так:

def my_func(a): # Тело функции

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

Например, функция, удваивающая аргумент:

def double(x): return x*2

Такую функцию, например, можно использовать в методе map .

def double(x): return x*2 my_list = [1, 2, 3, 4, 5, 6] new_list = list(map(double, my_list)) print(new_list) # [2, 4, 6, 8, 10, 12]

Именно здесь целесообразно использовать лямбда-функцию, т.к. её можно создать прямо в том же месте, где она используется. А это означает меньше строк кода. Кроме того, нам не придётся создавать функцию с именем, которая будет занимать место в памяти и пригодится лишь однажды.

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

Как вы уже поняли, лямбды применяются там, где нужна маленькая функция на короткое время – например, в функциях высшего порядка, таких как map или filter .

Синтаксис лямбда-функции имеют следующий:

lambda args: expression

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

Обратите внимание, что лямбда-функциям нельзя дать имя, потому что они анонимные (без имени) по определению.

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

Пример 1

Можно написать лямбду, которая удваивает свой аргумент: lambda x: x*2 , и использовать её в функции map , чтобы удвоить все элементы в списке:

my_list = [1, 2, 3, 4, 5, 6] new_list = list(map(lambda x: x*2, my_list)) print(new_list) # [2, 4, 6, 8, 10, 12]

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

Пример 2

А ещё можно создать лямбда-функцию, которая ищет числа больше нуля: lambda x: x > 0 и использовать в filter , чтобы создать список исключительно положительных чисел.

my_list = [18, -3, 5, 0, -1, 12] new_list = list(filter(lambda x: x > 0, my_list)) print(new_list) # [18, 5, 12]

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

Пример 3

Лямбда также может быть возвращаемым значением другой функции.

Если вам потребуется создать несколько функций, умножающих числа (например, удваивающих и утраивающих), лямбда может помочь.

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

def muliplyBy (n): return lambda x: x*n double = multiplyBy(2) triple = muliplyBy(3) times10 = multiplyBy(10)

Лямбда-функция принимает значение n из функции multiplyBy . Таким образом, в double параметр n равен 2 , в triple — 3 , а в times10 – 10 . Теперь при вызове полученных функций с определённым аргументом будет производиться умножение на соответствующее число.

double(6) > 12 triple(5) > 15 times10(12) > 120

Без лямбды вам бы пришлось определять внутри multiplyBy другие функции:

def muliplyBy (x): def temp (n): return x*n return temp

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

Заключение

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

Что такое lambda в питоне

Лямбда-выражения в языке Python представляют небольшие анонимные функции, которые определяются с помощью оператора lambda . Формальное определение лямбда-выражения:

lambda [параметры] : инструкция

Определим простейшее лямбда-выражение:

message = lambda: print("hello") message() # hello

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

def message(): print("hello")

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

square = lambda n: n * n print(square(4)) # 16 print(square(5)) # 25

В данном случае лямбда-выражение принимает один параметр — n. Справа от двоеточия идет возвращаемое значение — n* n . Это лямбда-выражение аналогично следующей функции:

def square2(n): return n * n

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

sum = lambda a, b: a + b print(sum(4, 5)) # 9 print(sum(5, 6)) # 11

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

def do_operation(a, b, operation): result = operation(a, b) print(f"result = ") do_operation(5, 4, lambda a, b: a + b) # result = 9 do_operation(5, 4, lambda a, b: a * b) # result = 20

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

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

def select_operation(choice): if choice == 1: return lambda a, b: a + b elif choice == 2: return lambda a, b: a - b else: return lambda a, b: a * b operation = select_operation(1) # operation = sum print(operation(10, 6)) # 16 operation = select_operation(2) # operation = subtract print(operation(10, 6)) # 4 operation = select_operation(3) # operation = multiply print(operation(10, 6)) # 60

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

У стандартной сортировки (метода sort списка, функции sorted) есть более универсальный способ задания порядка сортировки при помощи параметра key. Значение этого параметра некоторая функция, которая вызывается для каждого элемента, перед сравнением этих элементов: элементы списка сортируются, но сравниваются не значения элементов, а результат вызова переданной функции от этого элемента.

Например, пусть дан список строк, содержащих цифры, нужно упорядочить элементы списка, сравнивая их, как числа, а не как строки. Это можно сделать так:

a = ["10", "20", "30", "1", "2", "3", "111", "112", "222"] a.sort(key=int)

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

def last_digit(n): return n % 10 a.sort(key=last_digit)

Параметр key можно использовать вместе с параметром reverse .

Лямбда-функции

В предыдущем примере пришлось создавать отдельную функцию только для того, чтобы задать порядок сортировки, что захламляет программу ненужными функциями. В таких случаях нужно использовать лямбда-функции: “одноразовые фукцнии, которые можно объявлять без использовать слова def , прямо при вызове сортировки. Лямбда-функция — это функция, которая состоит только из одной строки с инструкцией return , то есть функция сразу возвращает значение по набору аргументов. Лямбда-функции объявляются таким образом:

lambda список переменных-аргументов: возвращаемое значение 

Например, отсортировать список чисел по последней цифре можно при помощи следующей лямбда-функции:

a = [3, 15, 22, 13, 12, 32, 45, 43] a.sort(key=lambda n: n % 10)

Рассмотрим другой пример. Пусть дан список точек, каждая точка: кортеж из двух чисел. Например, [(3, -2), (7, 1), (0, 4)] . Этот список нужно отсортировать по возрастанию расстояния от начала координат до точки. Напишем лямбда-функцию:

a.sort(key=lamda point: point[0] ** 2 + point[1] ** 2)

Элементами списка являются кортежи из двух координат, можно обратиться к этим координатам по индексам [0] и [1].

Устойчивость сортировки

Вернёмся к примеру сортировки по последней цифре. В приведённом выше примере упорядоченный список будет таким:

[22, 12, 32, 3, 13, 43, 15, 45]

Этот пример иллюстрирует свойство устойчивости сортировки: функция сортировки не переставлят элементы, если они равны друг другу. В данном случае функция упорядочивает числа по последней цифре, а при равной последней цифре сохраняется порядок следования элементов в исходном списке: 22, 12, 32.

Что делать, если нужно сделать сложную сортировку, учитывающую несколько критериев? Например, при равной последней цифре нужно упорядочить элементы в порядке возрастания самих чисел.

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

a.sort(key=lambda n: (n % 10, n))

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

a.sort() a.sort(key=lambda n: n % 10)

То есть сортировку по \(k\) параметрам (если по первому параметру элементы равны, то сравнить по второму, если равны два параметра, то сравнить по третьему и т.д.) можно заменить на \(k\) последовательных сортировок, выполняющихся в обратном порядке (от наименее значимого параметра к наиболее значимому).

Функция operator.itemgetter

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

a.sort(key=lambda elem: elem[1])

Для удобства в модуле operator есть функция itemgetter , которая позволяет создавать подобные функции, а именно, функция реализована примерно так:

def itemgetter(i): return lambda elem: elem[i]

То есть operator.itemgetter(i) — это функция, при вызове которой от числового параметра создаётся лямдба-функция, которую можно использовать в качестве параметра key . Если вызвать функцию itemgetter от нескольких параметров, то полученная функция будет возвращать кортеж из элементов с заданными индексами.