Why are Python lambdas useful? [closed] Why are Python lambdas useful? [closed] python python

# Why are Python lambdas useful? [closed]

Are you talking about lambda functions? Like

``lambda x: x**2 + 2*x - 5``

Those things are actually quite useful. Python supports a style of programming called functional programming where you can pass functions to other functions to do stuff. Example:

``mult3 = filter(lambda x: x % 3 == 0, [1, 2, 3, 4, 5, 6, 7, 8, 9])``

sets `mult3` to `[3, 6, 9]`, those elements of the original list that are multiples of 3. This is shorter (and, one could argue, clearer) than

``def filterfunc(x):    return x % 3 == 0mult3 = filter(filterfunc, [1, 2, 3, 4, 5, 6, 7, 8, 9])``

Of course, in this particular case, you could do the same thing as a list comprehension:

``mult3 = [x for x in [1, 2, 3, 4, 5, 6, 7, 8, 9] if x % 3 == 0]``

(or even as `range(3,10,3)`), but there are many other, more sophisticated use cases where you can't use a list comprehension and a lambda function may be the shortest way to write something out.

• Returning a function from another function

``>>> def transform(n):...     return lambda x: x + n...>>> f = transform(3)>>> f(4)7``

This is often used to create function wrappers, such as Python's decorators.

• Combining elements of an iterable sequence with `reduce()`

``>>> reduce(lambda a, b: '{}, {}'.format(a, b), [1, 2, 3, 4, 5, 6, 7, 8, 9])'1, 2, 3, 4, 5, 6, 7, 8, 9'``
• Sorting by an alternate key

``>>> sorted([1, 2, 3, 4, 5, 6, 7, 8, 9], key=lambda x: abs(5-x))[5, 4, 6, 3, 7, 2, 8, 1, 9]``

I use lambda functions on a regular basis. It took me a while to get used to them, but eventually I came to understand that they're a very valuable part of the language.

`lambda` is just a fancy way of saying `function`. Other than its name, there is nothing obscure, intimidating or cryptic about it. When you read the following line, replace `lambda` by `function` in your mind:

``>>> f = lambda x: x + 1>>> f(3)4``

It just defines a function of `x`. Some other languages, like `R`, say it explicitly:

``> f = function(x) { x + 1 }> f(3)4``

You see? It's one of the most natural things to do in programming.

The two-line summary:

1. Closures: Very useful. Learn them, use them, love them.
2. Python's `lambda` keyword: unnecessary, occasionally useful. If you find yourself doing anything remotely complex with it, put it away and define a real function.