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

Обновлено: 05.02.2025

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

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

Функции высшего порядка

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

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

В приведённом выше коде параметр combine имеет функциональный тип (R, T) -> R , поэтому он принимает функцию, которая принимает два аргумента типа R и T и возвращает значение типа R . Он вызывается внутри цикла for и присваивает accumulator возвращаемое значение.

Чтобы вызвать fold , вы должны передать ему экземпляр функционального типа в качестве аргумента и лямбда-выражение (описание ниже). Лямбда-выражения часто используются в качестве параметра функции высшего порядка.

Функциональные типы

Kotlin использует семейство функциональных типов, таких как (Int) -> String , для объявлений, которые являются частью функций: val onClick: () -> Unit = . .

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

У всех функциональных типов есть список с типами параметров, заключенный в скобки, и возвращаемый тип: (A, B) -> C обозначает тип, который предоставляет функции два принятых аргумента типа A и B , а также возвращает значение типа C . Список с типами параметров может быть пустым, как, например, в () -> A . Возвращаемый тип Unit не может быть опущен;

У функциональных типов может быть дополнительный тип - получатель (ориг.: receiver), который указывается в объявлении перед точкой: тип A.(B) -> C описывает функции, которые могут быть вызваны для объекта-получателя A с параметром B и возвращаемым значением C . Литералы функций с объектом-приёмником часто используются вместе с этими типами;

suspending functions

Объявление функционального типа также может включать именованные параметры: (x: Int, y: Int) -> Point . Именованные параметры могут быть использованы для описания смысла каждого из параметров.

Чтобы указать, что функциональный тип может быть nullable, используйте круглые скобки: ((Int, Int) -> Int)? .

При помощи круглых скобок функциональные типы можно объединять: (Int) -> ((Int) -> Unit) .

The arrow notation is right-associative, `(Int) -> (Int) -> Unit` is equivalent to the previous example, but not to `((Int) -> (Int)) -> Unit`. -->

Стрелка в объявлении является правоассоциативной (ориг.: right-associative), т.е. объявление (Int) -> (Int) -> Unit эквивалентно объявлению из предыдущего примера, а не ((Int) -> (Int)) -> Unit .

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

Создание функционального типа

Существует несколько способов получить экземпляр функционального типа:

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

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

Используя вызываемую ссылку на существующее объявление:

функции верхнего уровня, локальной функции, функции-члена или функции-расширения: ::isOdd , String::toInt ,
свойства верхнего уровня, члена или свойства-расширения: List ::size , : ::Regex

К ним относятся привязанные вызываемые ссылки, которые указывают на член конкретного экземпляра: foo::toString .

Используя экземпляр пользовательского класса, который реализует функциональный тип в качестве интерфейса:

При достаточной информации компилятор может самостоятельно вывести функциональный тип для переменной.

C` can be passed or assigned where a value of type `A.(B) -> C` is expected, and the other way around: -->

Небуквальные (ориг.: non-literal) значения функциональных типов с и без получателя являются взаимозаменяемыми, поэтому получатель может заменить первый параметр, и наоборот. Например, значение типа (A, B) -> C может быть передано или назначено там, где ожидается A.(B) -> C , и наоборот.

A function type with no receiver is inferred by default, even if a variable is initialized with a reference > to an extension function. > To alter that, specify the variable type explicitly. -->

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

Вызов экземпляра функционального типа

Значение функционального типа может быть вызвано с помощью оператора invoke(. ) : f.invoke(x) или просто f(x) .

Если значение имеет тип получателя, то объект-приёмник должен быть передан в качестве первого аргумента. Другой способ вызвать значение функционального типа с получателем - это добавить его к объекту-приёмнику, как если бы это была функция-расширение: 1.foo(2) .

Встроенные функции

Иногда выгодно улучшить производительность функций высшего порядка, используя встроенные функции (ориг.: inline functions).

Лямбда-выражения и анонимные функции

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

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

Синтаксис лямбда-выражений

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

Лямбда-выражение всегда заключено в скобки ;
Объявление параметров при таком синтаксисе происходит внутри этих скобок и может включать в себя аннотации типов;
Тело функции начинается после знака -> ;
Если тип возвращаемого значения не Unit , то в качестве возвращаемого типа принимается последнее (а возможно и единственное) выражение внутри тела лямбды.

Если вы вынесите все необязательные объявления, то, что останется, будет выглядеть следующим образом:

Передача лямбды в качестве последнего параметра

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

Такой синтаксис также известен как trailing lambda.

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

it: неявное имя единственного параметра

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

` can be omitted. The parameter will be implicitly declared under the name `it`: -->

Если компилятор способен самостоятельно определить сигнатуру, то объявление параметра можно опустить вместе с -> . Параметр будет неявно объявлен под именем it .

Возвращение значения из лямбда-выражения

Вы можете вернуть значение из лямбды явно, используя оператор return. Либо неявно будет возвращено значение последнего выражения.

Таким образом, два следующих фрагмента равнозначны:

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

Символ подчеркивания для неиспользуемых переменных

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

Деструктуризация в лямбдах

Деструктуризация в лямбдах описана в Деструктурирующие объявления.

Анонимные функции

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

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

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

Аналогично и с типом возвращаемого значения: он вычисляется автоматически для функций-выражений или же должен быть явно определён (если не является типом Unit ) для анонимных функций с блоком в качетсве тела.

When passing anonymous functions as parameters, place them inside the parentheses. The shorthand syntax that allows you to leave > the function outside the parentheses works only for lambda expressions. -->

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

Одним из отличий лямбда-выражений от анонимных функций является поведение оператора return (non-local returns). Слово return , не имеющее метки ( @ ), всегда возвращается из функции, объявленной ключевым словом fun . Это означает, что return внутри лямбда-выражения возвратит выполнение к функции, включающей в себя это лямбда-выражение. Внутри анонимных функций оператор return , в свою очередь, выйдет, собственно, из анонимной функции.

Замыкания

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

Литералы функций с объектом-приёмником

C`, can be instantiated with a special form of function literals – function literals with receiver. -->

Функциональные типы с получателем, такие как A.(B) -> C , могут быть вызваны с помощью особой формы – литералов функций с объектом-приёмником.

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

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

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

Ниже приведён пример литерала с получателем вместе с его типом, где plus вызывается для объекта-приёмника:

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

Лямбда-выражения могут быть использованы как литералы функций с приёмником, когда тип приёмника может быть выведен из контекста. Один из самых важных примеров их использования это типобезопасные строители (ориг.: type-safe builders).

Программирование и разработка

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

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

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

Что такое lambda functions?

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

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

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

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

История: Лямбда-выражения происходят от концепций лямбда-исчисления, модели вычислений, изобретенной Алонзо Чёрчем.

Хотя Python не является полностью функциональным языком, он добавил много функциональных концепций. В 1994 году filter(), map(), reduce()и lambdaоператор были добавлены к синтаксису. Другие объектно-ориентированные языки программирования, такие как Java и JavaScript, также добавили лямбда-выражения в более поздних версиях.

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

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

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

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

Возврат функции из функции
Сортировка по альтернативному ключу
Объединение элементов повторяющейся последовательности с reduce()

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

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

Как реализовать lambda functions Python

Лямбда-функция объявляется иначе, чем обычная функция. В Python лямбда-функции обладают следующими уникальными характеристиками:

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

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

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

В следующем примере мы используем лямбда-функцию для замены функции площади:

lambda Ключевое слово идентифицирует лямбда — выражение. В приведенном выше примере xэто единственный параметр. Двоеточие завершает список параметров и вводит тело функции.

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

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

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

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

Примеры lambda Python

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

Лямбда-выражения в Java

Присутствуют начиная с 8 версии.
Являются анонимными классами, реализующими метод функционального интерфейса.
Имеют доступ только к final (или effectively final) переменным из охватывающей области видимости (для потокобезопасности).
Не могут возвращать значение в каких-то ветках, а в других не возвращать.
Позволяют уменьшить количество кода и повысить его читаемость.

Примеры синтаксиса лямбда-выражений в Java

Лямбда-выражения в Java состоят из параметров и стрелки —> отделяющей тело функции. Скобки нужны, если параметров 0 или больше одного. Для однострочных лямбд ключевое слово return не обязательно.

(список параметров) -> тело лямбды

Без параметров

C параметром

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

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

Анонимная функция содержит небольшой фрагмент кода. Она имитирует встроенные функции C и C ++, но это не совсем встроенная функция.

Синтаксис для определения анонимной функции

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

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

Пример 1

В приведенном выше примере мы определили анонимную функцию лямбда a: a + 10, где a – аргумент, а a + 10 – выражение. Данное выражение оценивается и возвращает результат. Вышеупомянутая лямбда-функция такая же, как и обычная функция.

Пример 2

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

Зачем использовать лямбда функцию в Python?

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

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

Использование с filter()

Встроенная функция filter() принимает в качестве аргумента функцию и список. Это эффективный способ отфильтровать все элементы последовательности. Он возвращает новую последовательность, в которой функция оценивает значение True.

Рассмотрим следующий пример, в котором мы отфильтровываем единственное нечетное число из данного списка.

Использование с map()

Функция map() в Python принимает функцию и список. Дает новый список, который содержит все измененные элементы, возвращаемые функцией для каждого элемента.

Читайте также: