f = lambda x,y: lambda z: (x)(y)(z) Here, f is a function that takes two things. It returns a function that takes one thing. From this line, we can deduce that x is a function that returns a function, because we call it with y and then call that with z. But we're not sure about the types of y and z. One thing that helps is to take the parentheses off the first one, e.g. x(y)(z) instead of (x)(y)(z). I don't know why they put those on there, maybe to look cool or to look like the Lisp language, but they don't matter. You may look for info about combinators or higher-order functions in general, and not just limited to Python. These concepts really don't have much to do with the language. 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

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

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