map applies a function to every element of an iterable. Sometimes these functions are very simple operations; for example, if I wanted to double every number in a list. It's wasteful to define an entire new function (with the def keyword) just for this one simple operation. Lambda creates a callable function that we can use. Here's an example of how we could create that and use it with map. numbers = [1, 5, 20, 50] map(lambda x:x * 2, numbers) More on reddit.com

Lambda is relatively simple and straightforward. You basically write a function/script (in a language like PHP, Python, Node.js, etc.) and then you can associate a trigger that will invoke that function on-demand whenever you need it to run. The trigger could be an HTTP endpoint for example. So you could have your web domain associated with a lambda function which generates and responds with the HTML content for the webpage that was requested. Lambda uses a "serverless" design where you don't have to worry about managing servers or scaling instances. Instead it's a simple pay per use model where you can trigger and execute your function/script on demand and just pay for what you use. One disadvantage of using Lambda (as opposed to an always-running compute service like EC2) is that you may experience slow 'cold start' times when a function hasn't been executed in a long time or suddenly there are multiple execution requests that happen concurrently. This sometimes causes a delay of a couple of seconds (or in some cases even longer). Another disadvantage is that you can't use Lambda for continuous/long-running processes. It's designed for a request-response model where you send a request to the Lambda function and wait for a response and the maximum execution time is a few minutes. If this is acceptable to you, then Lambda is a very powerful tool and is an easy way to get started with cloud computing without having to worry about managing servers. More on reddit.com

This is a typical example for beginners: x=lambda n:2*n print(x(7)) Otherwise I would create a function: def dbl(n): return 2*n print(dbl(7)) Of course: I can write simply 2*7, but the idea is to save a complex formula in an object once, and reuse it several times. More on discuss.python.org

Glad it's not just me. I had the same reaction the first time I met them. Sometimes people use them just for the sake of it, to be clever, or because they are in a hurry and can't be bothered to write a function. Sometimes it is consistent practice, especially if into functional programming, and is very common in some other programming languages (in fact, in some it is a core capability that is fundamental). I found the term anonymous function completely unhelpful. Realpython have a great article: How to Use Python Lambda Functions You can give a name to a lambda function. The below are essentially the same: def double(x): return x * 2 dbl = lambda x: x * 2 print(double(4)) print(dbl(4)) Note how the parameter names are defined slightly differently: inside the brackets for the def and immediately after the keyword for lambda. The former uses a return statement. The latter doesn't because it does a return of whatever the result of the expression that follows is. The lambda is effectively a one line function and that line is a return statement. Here's an example with two arguments, def times(x, y): return x * y tms = lambda x, y: x * y print(times(2, 3)) print(tms(2, 3)) You can use them inline as well: print((lambda x, y, z: x + y + z)(1, 2, 3)) See how the function is called with three arguments, which are matched to the function parameter names x, y, z. There are a number of methods and functions in Python (as well as any you write yourself and import from libraries) that will call a function multiple times for each iteration. For example, nums = [1, 2, 3, 4] nums2 = map(lambda x: x * 2, nums) print(*nums2) The map function iterates through an iterable (the second argument here), in this case the list of int objects referenced by nums, and on each iteration calls the function given as the first argument, in this case a lambda but it could have been a function name (like double or dbl from earlier), and passes to the function the object reference from the current iteration (each number in turn). You end up with a map object which when unpacked in the print on the last line using the * unpack operator outputs the result of doubling all of the numbers. There are use cases where a lambda is much easier to read (and therefore maintain), makes more sense, and is simpler than writing a distinct function and in some cases a regular function is not suitable. Check out the RealPython guide for more details. EDIT: corrected (some) typos. More on reddit.com