Sometimes we need a function to pass it somewhere to a higher-order function only. As you may know, inventing names is one of the main issues programmers face. But if we need a function here and now, and you do not have to call it anywhere else, then you do not need to name it.
These one-time functions make it possible to describe almost all languages that can work as they do with values. In Python, defining this type of function looks like this:
lambda x: x + 1
# <function <lambda> at 0x7f56e5798a60>
We created a function but did not name it, so REPL displayed it as function <lambda>.
The keyword lambda is named after lambda abstractions. It is the essential building block of Lambda Calculus, a mathematical apparatus often used in programming language development. In Lambda Calculus, all functions are anonymous, so anonymous functions in many languages are also sometimes called lambdas or lambda functions.
Let us take a look at an example that uses an anonymous function:
l = [1, 2, 5, 3, 4]
l.sort(key=lambda x: -x)
l
# [5, 4, 3, 2, 1]
The sort method takes a function reference as a key argument. In the example, we specified a function as an argument that changes the sign, meaning we sorted the list in descending order. In and of itself, sorting with a key is common, but the sorting keys are usually different.
Therefore, it makes no sense to put keys in named functions; anonymous functions are perfect here.
Anonymous functions and their features
You may have noticed that we do not enclose the arguments of anonymous functions in brackets. It will take some getting used to. The rest of the tools are fully available:
- Named arguments
*argswith**kwargs
And you should also pay attention to the fact that the functions return something in our examples, but the word return is not given anywhere. The body of a lambda function is always one expression, and the result of its calculation will be the value it returns.
Yes, you will not be able to perform several actions in the body of the lambda function, and it will not be possible to use multi-line constructions like for and while. However, anonymous functions are usually easy to read, which would be difficult to achieve if the authors allowed multi-line lambdas.
The function declarations are expressions, so we can construct and call them immediately without finishing the expression:
1 + (lambda x: x * 5)(8) + 1
# 42
This example looks funny, but lambdas in this form are rare. However, you can often find a lambda return from a function:
def caller(arg):
return lambda f: f(arg)
call_with_five = caller(5)
call_with_five(str)
# '5'
call_with_five(lambda x: x + 1)
# 6
By the way, this example shows that lambdas are closures. The returned lambda remembers the value of the arg variable.
For full access to the course you need a professional subscription.
A professional subscription will give you full access to all Hexlet courses, projects and lifetime access to the theory of lessons learned. You can cancel your subscription at any time.
