Skip to main content

Lambda functions in Python


Lambda functions are simply functions that don't have a name. They are also called anonymous functions and are pretty useful for certain cases. They are extensively used in functional programming.
Lambda expression is useful for creating small, one time use functions though the functions can also be given a name.
It can have multiple arguments but just a single expression as the function body.
The basic syntax to create a lambda function is
lambda arguments: function body
For example
lambda x: x**2
This function takes in x and returns x2. Here, lambda is the keyword, x is the argument and the expression after the colon is the function body.
These functions can also be given a name,
sqr = lambda x: x**2
sqr(5) #output : 25

Multiple arguments can also be provided
lambda x,y: x * y
or
lambda x,y,z: x*y*z
These functions when given a name are equivalent to the functions defined by using the def keyword.
For example
def solve_quad(a,b,c):
   d = b**2 - (4*a*c)
   x1 = (-b + math.sqrt(d))/2*a
   x2 = (-b - math.sqrt(d))/2*a
   return (x1,x2)
This function takes in coefficients a, b, c of a quadratic equation and returns its roots as a tuple. It could be converted to a lambda function in the following way,
solve_quad = lambda a,b,c: ((-b + math.sqrt(b**2 - 4*a*c))/(2*a),(-b - math.sqrt(b**2 - 4*a*c))/(2*a) )

This function converted into a lambda expression is perhaps not the most motivating example but it nonetheless displays how to do it. This examples also shows that some functions are better written with a traditional def keyword rather than as a lambda expression as with def it can be spaced out on multiple lines which increases readability.

Using lambda with map()

Map is a higher order function and in commonly used in functional programming.
It is used to apply a same function to an iterable like list.
l = [x for x in range(100)]
t = list(map(lambda x, x**2, l)) #output: [0,1,4,9,16,25....,10000]
This simple application of map function takes in a list and returns and new list that consists the squares of all the elements in the argument that has been passed to it. So basically map can be used to replace loops where the body of the loop is just some function or multiple functions applied onto the element of the iterable.
Another example would be,
l = ["MaN", "Sun", "bUN"]
result = list(map(lambda x: x.lower(), l)) 
#output: ["man", "sun", "bun"]
This function takes in a list of strings and converts them to lower case.
This could also be achieved with a loop in the following way,
l = ["MaN", "Sun", "bUN"]
for string in l:
  string = string.lower()
But I personally prefer using map as its just clear, you see it and realise that it converts the elements of the collection passed into it to lower case plus you don't need to get into the mechanics of writing a loop.

Using lambda with reduce()

Reduce is also a higher order function. It takes in a collection and boils it down to one value or reduces it to one value, if you might. Lambda functions are used with reduce in a similar fashion to map.
NOTE - reduce needs to be imported from functools.
from functools import reduce
reduce(lambda acc, val: acc + val, [1,2,3,4])
This piece of code gives the output as 10. It simply adds all the value.
Now getting down to its specifics, acc over here is a variable that is being used to keep tally of the total, it is an accumulator. acc is the value being returned from the reduce function.
In cases like these, when the accumulator is not passed in by the user, reduce chooses first element of the collection as the accumulator and then starts its iteration from the second item. This would make sense in this use case but in multiple other applications accumulator needs to be passed in.
sentence = "It's a nice day!"
lenght = reduce(lambda acc, x: acc + len(x), sentence.split(),0)
Now, in this example accumulator's value has been passed in as 0 as it won't make sence to have the first word of the sentence as the accumulator.

Conclusion

Lambda expressions are extremely useful in functional programming and also to make functions that have to be only used once. Sometimes writing a function with the def keyword might be a better option because you won't want to trade off readability. Jumbling a lot of tasks into one lambda expression is not good practice as it only makes the code more obscure.

Comments

  1. Caesars Casino and Hotel - Dr. Maryland
    Caesars 안동 출장안마 Casino 경기도 출장안마 and Hotel · 1,888-GAMBLER - FESTIVAL. 속초 출장샵 FACTORY. 713,794. FINE. 제주 출장안마 717,854. FINDING. 718,914. FINDING. 경산 출장샵

    ReplyDelete

Post a Comment

Popular Posts

Fast Multiplication of Long Integeres | Karatsuba's Algorithm

This article is divided into 3 parts, so feel free to skip around to the part you find useful - Need for the algorithm Intuition and Algorithm Implementation Need for the algorithm Multiplication is an elementary concept known to all of us since a very early age. But multiplication of very large numbers becomes a difficult problem that can't be solved mentally unless you're a mathematical genius and hence we use calculators and computers. Computers too can efficiently multiply numbers but as the length of digits of the number increases, the time complexity also increases along with it quadratically. To calculate the product of humongous numbers we need a better algorithm. Any algorithm that even slightly increases the runtime will prove to be very beneficial for large values of n, say 100000. Karatsuba multiplication algorithm brings down the number of operations by a factor of one and gives a huge boost. Intuition and Algorithm Okay so, to boost up the speed of

Tuple data structure in Python

Tuple is a linear data structure which more or less behaves like a python list but with a really important difference, that a tuple is immutable . Immutable means that this structure can't be changed after it has been created, it can't be mutated if I may. Tuples being immutable are more memory efficient than list as they don't over allocate memory . Okay, so what this means is, when a list is created it takes up and reserves extra spaces of memory than needed for the original elements as new elements might be added to the list later and allocating memory on every addition would be quite inneficient but tuples, once created surelly won't change the numbers of elements in it later on, so it allocates exactly how much memory is needed. Almost all the list operations work for tuples except the ones which mutate it, for example, insert, append, remove etc. Declaring a tuple : Tuples can be initialise in a manner similar to list, But there's an important c

Python for competitive programming

WHY USE PYTHON FOR COMPETITIVE CODING Well a very good reason is that python is a language which radically cuts short the time you spend writing code ,rather you could spend that time thinking about the logic that is needed for the question. In these kind of competitions speed is necessary,I am not talking about the speed of the language but rather about the speed of the programmer.Python syntax is extremely clutter free and elegant which allows us to not get tangled up in complicated details of a programming language. Python also has a very vast variety of tools in its standard library and these tools can be very well utilised in competitive programming. Here's a list of a whole lot of other reasons why you would want to use python: Common inbuilt functions: Python has common functions like count,min,max,sorted etc.These functions allow you to easily go ahead and skip writing code for these trivial procedures which often prove to be very helpful,rest assured: Pytho

Random Numbers in Java

In this post we will go through the basics of generating random numbers and also see how they can be generated within a range along with best practices. Java provides support to either generate random numbers through java.lang.Math package or java.util.Random . Using java.lang.Math There exists a static method inside this class, Math.random . It is very convenient to use and returns a double between the range 0.0 and 1.0 i.e. it returns a floating point number between 0 and 1. public static void main(String[] args){ double randNum = Math.random(); System.out.println(randNum); } Random number within a range - To generate a random number within a range we need to further process the number returned by Math.random() public static void main (String[] args){ double min = 10.0; double max = 100.0; double randNum = randRange(min, max); System.out.println(randNum); } public static double randRange(double min, double max){ double x = (Math.rando

Evaluating expressions using Stacks | Dijkstra's Two-Stack Algorithm

We are going to look at Dijkstra's two-stack algorithm and see how it's implemented. This algorithm is used to evaluate infix expressions. It uses stacks at its core, so if you don't know about stacks or if you'd want to learn more about them, click this link There are three types of expressions, Infix : Infix expressions are the ones where the operators are used between values, like a + b - c . Postfix : These are the expressions where operators are written after the values, like a b c +- , this translates to a + b - c in infix. Prefix : In these expressions, the operators are written before the values, for example + - a b c . This expression will also be equal to a + b - c in infix. Okay, so what this algorithm does is evaluate expressions like ( ( 3 + 4 ) * 83 ) . It starts by breaking down this expression into a list of stings and create two empty stack, one for housing the values and other for the operators. Then we go through the list one by one. Whenev

Balanced Brackets | Stacks

In this post we will explore and implement an algorithm which helps us verify that if the brackets are balanced or validly used. This is a very important application of stacks as a lot of programming languages use brackets very extensively in their syntax and one of the job of a compiler is to check if the brackets are balanced or not. For simplicity's sake we will just use a list with the methods append() and pop(). This will help us emulate a stack without actually needing to implement it. If you want to, you can go and learn about stacks on this link . A set of brackets can be called balanced if all of the brackets in it are properly matched. Examples of balanced brackets : (([]{}{})) ({{}}[]) Examples of unbalanced brackets : (([)]) {{}]}]]) So now getting to the algorithm, what we simply do is that we go through a string of brackets and check that for every closing bracket there is a properly nested opening bracket. This is how we do it - Convert the input string into a

Kattis | The coding platform

Recently I came across a new website for competitive coding, Kattis and I love it. It is such an amazing platform and has a plethora of question along with multiple long duration contests. The quality of questions is also good and the interface is also very intutive. Follow this link to go to Kattis .

Greedy Algorithms

Greedy Algorithms is an algorithmic paradigm just like divide and conquer is. It is a design technique that depends on locally optimal choices to produce an overall optimal solution. It makes a greedy choice at every step based on a condition and hopes that the choice it made will produce the most optimum solution. A lot of times this technique fails to generate algorithms that are optimal but it does make a lot of problems very very easy. Its used in several different algorithms, most famous of them being: Huffman Coding Dijstrika's Shortest path Kruskal’s Minimum Spanning Tree Greedy algorithms basically make up a solution step by step fashion choosing the next piece which offers the most immediate benefit. Some problems based on Greedy Algorithms are - Grocery Bagger School Assembly Boxing Chopsticks Receipt

Coding questions on Stack and Queue

If you want to learn about Stack or Queue, follow the link to the tutorials- Queue Stack Questions- Maximum Element Equal Stacks Balanced brackets Simple Text Editor Queue using two stacks Castle on the grid Stock Span Problem Celebrity Problem Next greater element