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

It's a function that has no name, can only contain one expression, and automatically returns the result of that expression. Here's a function named "double": def double(n): return 2 * n print(double(2)) results in: 4 You can do the same thing without first defining a named function by using a lambda instead - it's creating a function right as you use it: print((lambda n: 2 * n)(2)) You can pass functions into other functions. The map function applies some function to each value of a sequence: list(map(double, [1, 2, 3])) results in: [2, 4, 6] You can do exactly the same thing without having defined double() separately: list(map(lambda n: 2 * n, [1, 2, 3])) More on reddit.com

lambdas are callables, or in other words, functions. Specifically, they are anonymous functions. A better name for lambda would have been make_function lambda x: x + 1 is equivalent to def add_one(x): return x + 1 The major difference is that the lambda does not need to occupy a namespace, like the definition of add_one This is useful for inlining simple functions. If you were to assign the lambda to a name, it is essentially exactly the same thing as defining the function as we did before. >>> add_one = lambda x: x + 1 >>> add_one(1) 2 Note that the above is considered an anti-pattern in Python and, by assigning it a name, pretty much defeats the purpose of lambda to begin with. You might see lambdas used for inlining definitions, such as in the creation of a dictionary whose values hold callables (functions) operations = { 'DELETE': lambda dynamo, x: dynamo.delete_item(**x), 'GET': lambda dynamo, x: dynamo.scan(**x), 'POST': lambda dynamo, x: dynamo.put_item(**x), 'PUT': lambda dynamo, x: dynamo.update_item(**x), } The alternative to this would be to do def delete(x): return dynamo.delete_item(**x) def get(x): return dynamo.scan(**x) def post(x): return dynamo.put_item(**x) def put(x): return dynamo.update_item(**x) operations = { 'DELETE': delete, 'GET': get, 'POST': post, 'PUT': put, } You can see the lambda significantly reduced the amount of code to express the same idea, and did not occupy name spaces for get delete post and put -- That's the benefit of using lambda More on reddit.com

they're just...functions with different syntax That's exactly what they are. The main syntactical difference between the two is that a regular function definition is a statement, whereas a lambda function definition is an expression. Lambda functions can therefore be defined and then passed to another function in one step, without having to go through a local name (that's also why lambda functions are sometimes called anonymous functions, they don't necessarily have a particular name). Lambda is a convenience feature to more easily define small, one-off functions. More on reddit.com