Lambda Functions
- Lambda, you can say, is a tool for building a function (or you can also say function objects).
- These are basically anonymous functions created at runtime which are not bound to the name of the functions.
- They return the definition of the function on the fly.
- Lambda functions don't contain a
return
statement, they always return an expression.
- You can always put a lambda definition anywhere a function is expected.
Why Use Lambda?
We can go along without using it, but:
- It makes your code cleaner and easier.
- When you are just going to need a function once.
- Functions you can say are used for:
- Modularity
- Code Reuse
- If your application contains duplicate chunks of code, as that code is being reused, why not wrap it up in a function and call it wherever necessary.
- But suppose we have a function which is to be used only once and called from only one place, then we can use lambda functions.
- So you don't need to give it a name and you can define the functionality there itself.
Why Use a Function If We Need It Only Once???
- The answer is in the question itself. Hence, we eliminate the use of a function and use Lambda.
- Anything which could be short and satisfies the need to eliminate the use of a function, hence we use a lambda expression.
Why Create a Short Anonymous Function???
Consider this snippet of code that uses lambda to define the behavior of buttons in a Tkinter
GUI interface. (This example is from Mike’s tutorial.)
frame = tk.Frame(parent)
frame.pack()
btn22 = tk.Button(frame,
text="22", command=lambda: self.printNum(22)) btn22.pack(side=tk.LEFT)
btn44 = tk.Button(frame,
text="44", command=lambda: self.printNum(44)) btn44.pack(side=tk.LEFT)
frame = tk.Frame(parent)
frame.pack()
btn22 = tk.Button(frame,
text="22", command=lambda: self.printNum(22)) btn22.pack(side=tk.LEFT)
btn44 = tk.Button(frame,
text="44", command=lambda: self.printNum(44))Colourised in 9ms
We could also write the code in the below way:
def __init__(self, parent):
"""Constructor"""
frame = tk.Frame(parent)
frame.pack()
btn22 = tk.Button(frame,
text="22", command=self.buttonCmd22)
btn22.pack(side=tk.LEFT)
btn44 = tk.Button(frame,
text="44", command=self.buttonCmd44)
btn44.pack(side=tk.LEFT)
def buttonCmd22(self):
self.printNum(22)
def buttonCmd44(self):
self.printNum(44)Colourised in 6ms
But it is much simpler to code like below:
def __init__(self, parent):
"""Constructor"""
frame = tk.Frame(parent)
frame.pack()
btn22 = tk.Button(frame,text="22", command=lambda: self.printNum(22))
btn22.pack(side=tk.LEFT)
btn44 = tk.Button(frame,
text="44", command=lambda: self.printNum(44))
btn44.pack(side=tk.LEFT)Colourised in 5ms
As you can see that it becomes much easier to code and we will just use the function once (in the place where it needs to be.)
Now, let us look at some simpler examples:
a = lambda x:x%2
print a(2)
Colourised in 0ms
This would give the result : 0
What am I trying to achieve here?
- I want a function which will simply return the modulus of a number, I don't want to define it, because I would use it just once on the fly.
- I would not reuse it more than once.
- So what we observe here is that the lambda returns an expression which is assigned to '
a
' and a
can be used as a function. As you can see above.
Now what if I say:
x = lambda x:x%2
Colourised in 0ms
This will also print 2 if I say x(2)
.
- Don't get confused between the variable to which the lambda is assigned. It is not necessary to have the same variable name and the variable used inside the lambda function.
- Both are different.
- One is the variable to which I am assigning the lambda expression and the one used in the expression is the argument which we pass in the function.
The above explanation can be interpreted like below:
Let us move ahead to some more examples on lambda functions:
For example:
- I have a list of numbers out of which I want to check the number which is divisible by '
2
'.
- Okay, so I will define a list first:
list=[1,2,3,4]Colourised in 0ms
Now I will say:
print map(lambda x:x%2 == 0,[1,2,3,4])Colourised in 0ms
The output will be:
[False, True, False, True]Colourised in 0ms
Ok.
One more example:
print filter(lambda x:x%2 == 0,[1,2,3,4])Colourised in 0ms
We get:
[2, 4]Colourised in 0ms
After all of this discussion, there is one more question unanswered: "What is a lambda expression?" OR "What is the difference between an expression and a function?"
The answer is:
- An expression evaluates to a value while a function does not.
- If you see at the top, I have said: Lambda is a tool to create an anonymous function, instead of that I can easily say that lambda is a tool to create an anonymous procedure.
I hope basics of Lambda have been covered.
The session should be interactive, so I request you to try out a simple exercise.
Exercise
- You can try out a program which would print the lengths of every
string
in a list?
- Try out an assignment statement in Lambda. What happens? What is the reason for the outcome?
- Pass a function call in a lambda expression, pass arguments in it and see what happens?
- What are the uses of
Map
and Filter
functions used in above examples?
References