In this article, I will teach you exactly what a python lambda is.<\/p>\n
As a matter of fact if you know what functions are and how to define functions in Python then you already know what a lambda is.<\/p>\n
A Python lambda is just a Python function.<\/p>\n
But may be like a special type of function that have limited capabilities \ud83d\ude42<\/p>\n
If you want to dive deeper and learn more about lambdas and how they are used in Python then this is what this article is about.<\/p>\n
Here is what I will be talking about in this article.<\/p>\n
Before trying to understand what a Python lambda is, let’s first try to understand what a Python function is at a much deeper level.<\/p>\n
This will require a little bit of a paradigm shift of how you think about functions.<\/p>\n
As you already know, everything in Python is an object<\/strong>.<\/p>\n For example, when we run this simple line of code.<\/p>\n What actually happens is we’re creating a Python object of type int<\/span> that stores the value 5.<\/p>\n x<\/span> is essentially a symbol that is referring to that object.<\/p>\n Now let’s check the type of x and the address it is referring to.<\/p>\n We can easily do that using the type<\/span> and the id<\/span> built-in functions.<\/p>\n As you can see, x<\/span> refers to an object of type int<\/strong> and this object lives in the address returned by the id<\/span><\/p>\n Pretty straightforward stuff.<\/p>\n Now what happens when we define a function like this one:<\/p>\n Let’s repeat the same exercise from above and inspect the type<\/strong> of f<\/strong> and its id<\/strong>.<\/p>\n hmm, very interesting.<\/p>\n So it turns out there is a function<\/strong> class in Python and the function f<\/span> that we just defined is an instance of that class.<\/p>\n Exactly like how x<\/span> was an instance of the integer<\/strong> class.<\/p>\n In other words, you can literally think about functions the same way you think about variables.<\/p>\n The only difference is that a variable stores data whereas a function stores code.<\/p>\n That also means you can pass functions as arguments to other functions, or even have a function be the return value of another function.<\/p>\n let’s look at a simple example where you can pass the above function f<\/span> to another function.<\/p>\n Give yourself a minute and try to understand what this code does before you read on…<\/p>\n As you can see, modify_list<\/strong> is a function that takes a list L<\/span> and a function fn<\/span> as arguments.<\/p>\n It then iterates over the list item-by-item and applies the function fn<\/strong> on each.<\/p>\n This is a very generic way of modifying the items of a list as it allows you to pass in the function that is responsible for the modification which can be very useful as you will see later.<\/p>\n So for example when we pass the function f<\/span> to modify_list<\/strong>, the result will be that each item in the list will be squared.<\/p>\n We could pass any other custom function that can modify the list in any arbitrary way.<\/p>\n That’s pretty powerful stuff right there!<\/p>\n Alright now that I have laid down some foundations, let’s talk about lambdas.<\/p>\n A Python lambda<\/em> is just another method to define a function<\/em>.<\/p>\n The general syntax of a Python lambda is:<\/p>\n lambda arguments: expression<\/p><\/blockquote>\n Lambda functions can accept zero<\/strong> or more<\/strong> arguments but\u00a0only one<\/strong> expression.<\/p>\n The return value of the lambda function is the value that this expression is evaluated to.<\/p>\n For example, if we want to define the same function f<\/strong> that we defined before using lambda syntax, this is how it will look like:<\/p>\n But you might be asking yourself why the need for lambdas in the first place when we can just define functions the traditional way?<\/em><\/p>\n Fair question!<\/p>\n Actually, lambdas are only useful when you want to define a one-off function.<\/p>\n In other words, a function that will be used only once in your program. These functions are called anonymous functions.<\/em><\/p>\n As you will see later, there are many situations where anonymous functions can be useful.<\/p>\n As you saw earlier, it was easy to define a lambda function with one argument.<\/p>\n But if you want to define a lambda function that accepts more than one argument, you can separate the input arguments by commas.<\/p>\n For example, say we want to define a lambda that takes two integer arguments and returns their product.<\/p>\n Nice!<\/p>\n How about if you want to have a lambda that accepts no arguments whatsoever?<\/p>\n Say you want to define a lambda function that takes no arguments and returns True<\/strong>.<\/p>\n You can achieve this with the following code.<\/p>\n Yes, at some point in your life you will be wondering if you can have a lambda function with multiple lines.<\/p>\n And the answer is:<\/p>\n No you can’t \ud83d\ude42<\/p>\n Python lambda functions accept only one and only one expression.<\/p>\n If your function has multiple expressions\/statements, you are better off defining a function the traditional way instead of using lambdas.<\/p>\n Now let’s discuss some of the most common places where python lambdas are heavily used.<\/p>\n One common operation you will apply to Python lists is to apply an operation to each item.<\/p>\n Map<\/strong> is a Python built-in function that takes in a function<\/strong> and a sequence<\/strong> as arguments and then calls the input function on each item of the sequence.<\/p>\n For example, assume we have a list of integers and we want to square each element of the list using the map<\/strong> function.<\/p>\n Note that in Python3, the map function returns a Map<\/strong> object whereas in Python2 it returns a list<\/strong>.<\/p>\n See, instead of defining a function and then passing it to map as an argument, you can just use lambdas to quickly define a function inside the map parentheses.<\/p>\n This makes sense especially if you are not going to use this function again in your code.<\/p>\n Let’s take a look at another case where lambdas can be useful.<\/p>\n As the name suggests, filter<\/strong> is another built-in function that actually filters a sequence or any iterable object.<\/p>\n In other words, given any iterable object (like a list), the filter<\/strong> function filters out<\/em> some of the elements while keeping some based on some criteria.<\/p>\n This criteria is defined by the caller of filter<\/strong> by passing in a function as an argument.<\/p>\n This function is applied to each element of the iterable.<\/p>\n If the return value is True<\/strong>, the element is kept. Otherwise, the element is disregarded.<\/p>\n for example, let’s define a very simple function that returns True<\/strong> for even numbers and False<\/strong> for odd numbers:<\/p>\n That said, With the magic of lambdas you can do the same thing more succinctly.<\/p>\n The above code will transform into this one-liner<\/p>\n And that, my friend, is the power of lambdas<\/em>.<\/p>\n Sorting a Python list<\/a> is a very common operation.<\/p>\n In fact I have a whole in-depth article<\/a> dedicated to this topic.<\/p>\n If you have a list of numbers or strings, then sorting a list is very straightforward.<\/p>\n You can just use the sort<\/span> or sorted<\/span> built-in functions.<\/p>\n However, sometimes you have a list of custom objects and may be you want to sort the list based on a specific object field.<\/p>\n In this case, you can pass an optional key<\/strong> parameter to either sort<\/strong> or sorted<\/strong>.<\/p>\n This key<\/strong> parameter is actually of type function.<\/strong><\/p>\n The function is applied to all the list items and the return value is what’s going to be sorted.<\/p>\n Let’s take an example.<\/p>\n Assume you have an Employee<\/span> class that looks like this<\/p>\n Now Let’s create some Employee<\/span> objects and append them to a list.<\/p>\n Now say we want to sort this list based on the age<\/span> of the employees, here is what we should do:<\/p>\n See how we used a lambda expression as the key<\/strong> parameter instead of having to define a function externally and then passing this function to sort<\/strong>.<\/p>\n Like I mentioned earlier, lambdas can use only one expression<\/em> as the body of the lambda function.<\/p>\n Notice I didn’t say one statement<\/em>.<\/p>\n Statements and expressions are two different things but they can be confusing so let me try to clarify the differences.<\/p>\n In programming languages, a statement is a line of code that does something but it doesn’t evaluate to a value.<\/p>\n For example, an if statement<\/strong>, a for loop<\/strong>, a while loop<\/strong>, all of these are examples of statements.<\/p>\n You can’t simply replace the statement with a value because statements don’t evaluate to a value.<\/p>\n Expressions on the other hand are evaluated to a value.<\/p>\n You can easily replace all the expressions in your programs with some values and your program will work correctly.<\/p>\n For example:<\/p>\n 3 + 5<\/span> is an expression that is evaluation to 8<\/strong><\/p>\n 10 > 5<\/span> is an expression that is evaluated to True<\/strong><\/p>\n True and (5 < 3)<\/span> is an expression that is evaluated to False<\/strong><\/p>\n Lambda’s body has to be an expression because the value of this expression is the return value of the function.<\/p>\n Make sure you remember this point when you are writing your next lambda function \ud83d\ude42<\/p>\n Check out the Courses section!<\/a><\/p>\n\n And so much more…<\/p>\nx = 5<\/code><\/pre>\n>>> type(x)\r\n<class 'int'>\r\n>>> id(x)\r\n4308964832<\/code><\/pre>\n>>> def f(x):\r\n... return x * x\r\n...<\/code><\/pre>\n>>> def f(x):\r\n... return x * x\r\n...\r\n>>> type(f)\r\n<class 'function'>\r\n>>> id(f)\r\n4316798080<\/code><\/pre>\ndef f(x):\r\n return x * x\r\n\r\ndef modify_list(L, fn):\r\n for idx, v in enumerate(L):\r\n L[idx] = fn(v)\r\n\r\nL = [1, 3, 2]\r\nmodify_list(L, f)\r\nprint(L)\r\n\r\n#output: [1, 9, 4]<\/code><\/pre>\n>>> f = lambda x: x * x\r\n>>> type(f)\r\n<class 'function'><\/code><\/pre>\nLambdas with multiple arguments<\/h2>\n
>>> f = lambda x: x * x\r\n>>> f(5)\r\n25<\/code><\/pre>\n>>> f = lambda x, y: x * y\r\n>>> f(5, 2)\r\n10<\/code><\/pre>\nLambdas with no arguments<\/h2>\n
>>> f = lambda: True\r\n>>> f()\r\nTrue<\/code><\/pre>\nMultiline lambdas<\/h2>\n
Examples of Lambda in action<\/h2>\n
Using lambdas with map<\/h3>\n
>>> L = [1, 2, 3, 4]\r\n>>> list(map(lambda x: x**2, L))\r\n[1, 4, 9, 16]<\/code><\/pre>\nUsing lambdas with filter<\/h3>\n
def even_fn(x):\r\n if x % 2 == 0:\r\n return True\r\n return False\r\n\r\nprint(list(filter(even_fn, [1, 3, 2, 5, 20, 21])))\r\n\r\n#output: [2, 20]<\/code><\/pre>\nprint(list(filter(lambda x: x % 2 == 0, [1, 3, 2, 5, 20, 21])))<\/code><\/pre>\nUsing lambdas with list sorting<\/h3>\n
class Employee:\r\n def __init__(self, name, age):\r\n self.name = name\r\n self.age = age<\/code><\/pre>\nAlex = Employee('Alex', 20)\r\nAmanda = Employee('Amanda', 30)\r\nDavid = Employee('David', 15)\r\nL = [Alex, Amanda, David]<\/code><\/pre>\nL.sort(key=lambda x: x.age)\r\nprint([item.name for item in L])\r\n# output: ['David', 'Alex', 'Amanda']<\/code><\/pre>\nOne word on Expressions vs Statements<\/h2>\n
Learning Python?<\/h3>\n
Featured Posts<\/h2>\n
\n
Are you Beginning your Programming Career?<\/h2>\n
I provide my best content for beginners in the newsletter.<\/h3>\n
\n
Subscribe now. It’s Free.<\/h3>\n