Up next in 10
Python LAMBDA Function and Expression (for Beginners)
1K views
Dec 10, 2024
In this python for beginners tutorial, you will learn how to all the ways use the lambda function in Python ----- Install Python: - MacOS: https://www.jcchouinard.com/install-python-on-macos/ - Windows: https://www.jcchouinard.com/install-python-on-windows/ - Anaconda: https://www.jcchouinard.com/install-python-with-anaconda-on-windows/ Subscribe to my Python Course waitlist: https://ba995fe7.sibforms.com/serve/MUIEAPv50TFkNuoknCNvzRUKLLhvvZd5jzCwEZvi9BNjtkhVuEtLpEG58-Khdquyg9v5V-1qeGDwIXy739I4eFIVcCqeqqV3UUisW_-hAd5ljC1dGMrQvXHC7JvORh9TbnLA1CHqWro4N7YVZ4730-D5dXGxqd3CbaVHSJpS5fyylPMVzCe1_y9xOTl2-CsvEuhO01E0Ytv59HEJ Support my work: https://www.buymeacoffee.com/jcchouinard Subscribe to this channel: https://www.youtube.com/channel/UCthJJqyUGdI5EA0YjnjXthw?sub_confirmation=1 Follow me: https://twitter.com/ChouinardJC https://www.linkedin.com/in/jeanchristophechouinard/ https://www.buymeacoffee.com/jcchouinard
View Video Transcript
0:00
hello everyone my name is and today I'm
0:02
going to teach you about Lambda
0:04
functions in Python what is a Lambda
0:07
function in Python it is an anonymous
0:11
expression it is essentially a function
0:14
without a function name so it can take
0:17
any number of argument including no
0:19
arguments but it only has a single
0:21
expression so let's look at how this
0:25
works so essentially Lambda is just a
0:27
shorter way to define a simple function
0:30
that has a single
0:33
expression so how it works the Lambda
0:35
syntax is that you taken some argument
0:39
one zero or multiple and you have just
0:42
one expression and you can uh execute it
0:46
so let's make a simple example of how uh
0:50
is structured a Lambda function so the
0:53
first thing is you can say okay I have
0:56
Lambda x and x + one so that's our
1:00
structure for a Lambda function if we uh
1:04
run this you'll see that it just
1:06
returned function name so it hasn't been
1:08
called yet uh in order to call this uh
1:12
we'll see later how to call it uh next
1:15
you can have a different number of
1:17
arguments so you can say x y z and say
1:23
uh print XY Z so you can see the Lambda
1:28
function can have have multiple
1:31
arguments here but has a single
1:33
expression you can also have Lambda
1:36
without a single argument by saying just
1:39
uh print hello
1:43
Lambda uh so you don't need actually uh
1:46
any argument if we run this we still
1:49
have just a function and we have an
1:53
example of how we can use this you can
1:57
say uh Lambda
2:00
function and you can assign it to a
2:02
variable and in this case you get print
2:06
a Lambda and if we call that variable
2:09
then we can see it still returns that
2:12
function main if you want to execute the
2:14
Lambda function you have some uh some
2:18
idea what's going on here is you use a
2:21
parentheses right there and then you
2:23
call that Lambda function and that's how
2:26
you use Lambda that's the simplest way
2:30
if you have multiple Arguments for
2:33
example uh you can uh let's see later uh
2:38
there's a second way you can actually
2:41
execute a Lambda function without
2:43
assigning it to a variable because
2:45
Lambda functions want to be anonymous so
2:48
uh you don't want to assign it for
2:50
example so you could just say uh okay
2:56
Lambda
2:57
x equals
3:00
friends
3:02
hello and then you return
3:07
this uh it's missing the argument okay
3:10
yeah sorry you just print and you return
3:13
this if you want to add an argument then
3:15
you would say uh print you could say
3:19
Lambda X and you could say hello X and
3:23
then here you could say hello JC and
3:26
then you can provide that argument
3:29
within the next parenthesis so that's a
3:33
second way you can execute a Lambda
3:37
function if you have a single argument
3:40
in your Lambda we've just looked at it
3:43
but single argument and you do
3:46
Lambda x x + one as we have just seen
3:50
then in order to call the single
3:52
argument function uh Lambda function you
3:55
just use this parenthesis if you run it
3:58
will have the same type error that we
4:00
just discussed uh then you can put a
4:04
number instead and get the actual
4:08
result you can also have multiple
4:11
arguments as we hinted
4:13
earlier and to do this you do
4:17
Lambda x y and then you can say x + y so
4:22
that's can be one function with multiple
4:25
arguments and you have to think that the
4:28
order that you define Define them is the
4:30
order that you're going to have to
4:32
Define them so 3 + one and that's how
4:35
you can call a Lambda function with any
4:38
number of
4:40
arguments so what exactly does Lambda do
4:44
in Python Lambda it's a function and it
4:48
returns Panda expression for that
4:49
argument it is very similar uh to um how
4:55
function uh identity function works so
4:59
if you are used to uh defining function
5:03
using the def keyword let's say a def
5:06
funk you have X put the argument and
5:10
then return x + one so that's
5:15
essentially if you run this uh function
5:18
uh and you
5:20
do X2 you will do replace X by2 and it's
5:25
going to return three the Lambda
5:27
function is very similar and as we have
5:30
seen Lambda Funk equal
5:34
Lambda x x +
5:38
one so if we do check whether or not
5:42
Lambda function does the same thing we
5:44
can see that X2 and Lambda function 2 is
5:50
equal to three uh true in that case
5:53
showing that the results of this
5:55
function and the result of this function
5:57
will return the same thing
6:01
you can use Panda python Lambda inside
6:06
functions so python supports functional
6:09
programming so you can return a function
6:12
as the result of another function so we
6:15
can take a
6:16
function that we say it will increment
6:21
n uh and return and instead of just
6:24
doing some number n + one for example as
6:27
an incremental
6:30
what we want to know is we want to use a
6:32
Lambda
6:33
function that will have x x + n so in
6:38
this case if we take the incremental
6:41
function and we assign it to F and we
6:44
say that the increment is 10 uh we're
6:48
still missing something here we don't
6:50
know what x is we've defined n here
6:54
using 10 so n equal 10 so in order to
6:57
use this what we want to do do is we
7:00
want to take F the Lambda function and
7:02
we want to give it the value of x and if
7:05
we re return this we'll see that it
7:08
returns 12 so we can print some results
7:11
and we can also use it to assign it to a
7:16
new function so we can say instead of
7:18
the increment of n equal 10 we can say
7:21
the increment is n equal uh three
7:25
instead and then if we print all of this
7:28
we'll see the difference
7:30
uh between changing the incrementer we
7:33
can see that we're calling a function
7:35
another function using the Lambda
7:40
expression so when should you use uh
7:43
python
7:45
Lambda you can use Python Lambda to sort
7:48
a list of two Poes so here we have a
7:52
list of two
7:53
poles and let's say we want to sort that
7:56
list using the one two three so we want
7:58
to sort them in order of
8:01
appearance uh we can use Lambda for that
8:04
so we can say Okay sorted pair so that's
8:07
the variable when we want to sort this
8:10
we can use the sorted function in Python
8:13
we pass in the pairs and you know we can
8:16
Define which key we want to
8:19
use uh and in this case for the key
8:22
we're going to pass in the Lambda X and
8:26
we're going to select the first value of
8:28
x that means X will be the two pole that
8:32
will passed be passed and we will return
8:35
the first value here so that's what we
8:38
do we sort based on the first key and if
8:41
we do sorted pair here you'll see that
8:44
it's sorted from one to four and if we
8:46
were to use Lambda 1 it would be sorted
8:49
alphabetically 41 32 instead of by
8:54
numbers we can also Define a function by
8:57
using IF else state
9:00
so we can say result equal and we want
9:04
to so the the structure it does is it
9:07
takes a a on line IFL so we say Lambda
9:12
X and we say return greater than five if
9:17
x is greater than
9:19
five else return smaller than five so
9:24
that's a oneliner IFL statement you can
9:27
learn about this in a separate video
9:29
tutorial uh but let's say if we want to
9:32
test we can say that this one should uh
9:35
return greater than five and this one
9:36
should return smaller than five and that
9:39
is indeed the
9:41
case there are other very cool things
9:44
that we can do with Lambda functions is
9:47
that we can take a list range six let's
9:50
start with this and show the nums uh and
9:53
we say that we have a list of 0 1 2 3 4
9:57
five let's say we want to just keep the
10:00
even
10:01
numbers so what we can do is we can use
10:05
the filter function so when I say we
10:09
want to keep just the the the the even
10:12
number that means I want to filter use
10:15
the filter to to to keep holding these
10:18
so I can do
10:19
Lambda X and in order to get filters
10:24
there is the very useful module function
10:28
that we can use so if module 2 equals
10:31
equals z and then the filter function
10:34
requires me to pass in the list and then
10:37
I can see I have indeed managed to
10:39
filter to keep only even
10:43
numbers if I want to do other
10:45
mathematical operations I can do so by
10:48
using the map function instead so if I
10:51
want to square every single item I would
10:55
do list map I will map Lambda
11:00
x x 2 and nums and that will return the
11:06
Square value so essentially it will map
11:09
all the values from nums times
11:13
two here you can see that it
11:17
works so it's super useful because you
11:20
can start by a project by putting all
11:23
your mathematical operations so you can
11:25
say I want to add subtract I want to
11:28
divide so you can see that I can create
11:31
a a single um function for every single
11:36
possible mathematical operation that I
11:38
want to do in my project so I can Define
11:40
it at first and then I can just call
11:42
them like that and not focus on doing it
11:46
ever again later on so that's is a very
11:49
useful way of using penda
11:53
functions you can also do this with
11:55
strings let's say I have a list of
11:57
emails I can also use list maps to do
12:02
other more complex operation list map
12:05
and I can say Lambda and let's not call
12:08
it X but email
12:10
instead just because we can uh and we do
12:14
split and then we split on the a
12:19
mcent uh and essentially we want to keep
12:23
just the domain so essentially what
12:25
we're doing here is we're mapping taking
12:27
a list here and we m
12:30
uh the M the Lambda function then we
12:32
return the emails and we get those
12:34
strings as we can see here we're
12:37
starting to get in the realm of the a
12:39
little bit more complex notation and
12:41
maybe a loop uh would be simpler but
12:46
I'll add that up to
12:49
you so the next piece is the most the
12:53
the place where I use Lambda function
12:55
the most is generally I have a panda
12:58
data frame and I want to apply some
13:00
operation to the score uh column so I
13:03
want to apply something to every item in
13:05
a score column and that is a p one of
13:09
the powerful way that Lambda can do uh
13:12
of what Lambda can do so you can do
13:14
score Pur so let's say we want to
13:17
convert the point notation the float
13:21
notation to a percentage string we can
13:24
say DF score and we use the apply
13:27
function that will say essentially go
13:29
through each item and apply a function
13:32
and in this case the function is a
13:34
Lambda
13:36
function X will take in the value so it
13:39
will go first X second X and for each
13:43
item it will Loop X let's say I want to
13:45
create a a F string that ends up as a
13:49
percentage and I need to put in x * 100
13:54
so in that case if I run this and I
13:56
print the DF again
14:00
you can see I've added a new column with
14:03
the string notation for the
14:08
percentage uh now we can also use and
14:12
now we're getting into a little bit more
14:14
complex uh things uh but uh I want to
14:18
show you how you can use Lambda function
14:20
as a decorator so uh let's say you have
14:23
a function and you want to convert it so
14:26
let's I have let's start with the Lambda
14:28
function so I have my Lambda
14:31
function and the Lambda function
14:35
equals
14:37
the
14:38
is hello
14:41
world so I have that Lambda function
14:44
that just essentially just does hello
14:48
world and the output that I want is
14:51
something that is
14:54
calling something like hello
14:57
Lambda that that's the output that I
15:00
want to do so I can create a decorator
15:03
function so I can say my
15:07
decorator and it takes a function as an
15:10
input so it takes the Lambda function as
15:13
an input and I put the wrapper instead
15:18
inside so I'm not going too deep into
15:21
what decorators are but let's take
15:24
result and I have Lambda function
15:30
essentially it
15:32
runs it runs the Lambda function and it
15:39
Returns the corated
15:43
result so that's what the function does
15:46
and then it returns
15:51
rapper it takes in this so how you use
15:55
that decorator then you can use uh
15:58
decorate
16:00
Lambda
16:02
equals my
16:04
decorator my Lambda so you pass in the
16:07
Lambda function to The Decorator and if
16:11
we return this it should return what we
16:15
we trying to do which is decorated hello
16:19
world so this is it uh thanks for
16:22
following me uh please hit like And
16:25
subscribe and or follow me on one of my
16:29
uh website or social media thank you
16:31
very much see you next time