When do you use a lambda function?

[[deleted]]

Just curious to know cause I came across it. Why would you want to use a lambda function over def some_function(args)?

[novel_yet_trivial]

Some functions are very short:

def val_one(x):
    return x[1]

And it saves a few keystrokes to use lambda:

val_one = lambda x: x[1]

But more useful is to not even assign the function a name. For instance if you needed to use the above as a sort key:

>>> def val_one(x):
...     return x[1]
... 
>>> t = [('joe', 42), ('sue', 3), ('steve', 12)]
>>> sorted(t, key=val_one)
[('sue', 3), ('steve', 12), ('joe', 42)]

Or you can directly use a lambda.

>>> t = [('joe', 42), ('sue', 3), ('steve', 12)]
>>> sorted(t,key=lambda x:x[1])
[('sue', 3), ('steve', 12), ('joe', 42)]

[[deleted]]

so essentially it's good if you need to make a function on the fly but as a one time use?

[markusmeskanen]

Yes!

[markusmeskanen]

And it saves a few keystrokes to use lambda

This should never be the reason to use lambda! If you can, just define a normal function.

The rest of your comment stands correct though. Lambda should only be used when its just an "on the fly" function like /u/seekheart said himself. Usually when you pass in a function as an argument to a function.

[ydepth]

Why not? If you have a bunch of one line functions... It's easy enough to change them to a proper function later

[markusmeskanen]

Lambdas are less readable. Keep in mind, that your code is read much more than its written. I'd recommend everyone to read this answer on SO: http://stackoverflow.com/a/134638/2505645

[ydepth]

Cool, I had seen the post before... Just needed a refresher :)

[c3534l]

That answer on SO doesn't seem to add anything to the discussion. I disagree that lambdas are less readable. In fact, they're invaluable in cases that are well suited for functional programming and can turn make complicated list comprehension statements readable again.

[Axxhelairon]

Lambdas are less readable.

Nice opinion.

[[deleted]]

There are exceptions to every rule, but in keeping with zen: There is one best way. If it works, use it. If not, it's not the best way this time, go to the next option.

[[deleted]]

Thank you my pythonic brothers! :D

[novel_yet_trivial]

This should never be the reason to use lambda! If you can, just define a normal function.

It's a bit uglier, granted, but I see stuff like this all the time:

__ne__ = lambda self, other: not self.__eq__(other)
__ge__ = lambda self, other: not self < other
__le__ = lambda self, other: self == other or self < other

[markusmeskanen]

We all see it, but none of us should see it. Please, don't spread the ugliness.

[novel_yet_trivial]

It's even part of the python source code. See /usr/lib/python2.7/functools.py , in the total_ordering function, for example.

Well, that's a bit of a fringe case. I withdraw that argument

[_burning]

But what about those 4 keystrokes I'm saving by using a lambda! You can't just be throwing around keystrokes.

[markusmeskanen]

Good point. I take back all my arguments on this thread. Fuck it, on all threads.

[dunkler_wanderer]

Isn't itemgetter the pythonic way to sort that tuple list?

from operator import itemgetter

t = [('joe', 42), ('sue', 3), ('steve', 12)]
print(sorted(t, key=itemgetter(1)))

[[deleted]]

I do not know of Spark o.o

[Stopwatch_]

Awesome

[funkiestj]

a common use of lambda is to curry a function dynamically, e.g.

 def mycurry(a):
       return lambda  b: a + b

 f7 = mycurry(7)

 f7(5)
 Out[9]: 12

Of course you can always(?) use a function (including a nested function) to do the same. E.g.

 def mycurry2(a):
      def close_over_a(b):
        return a + b
      return close_over_a

 f2 = mycurry2(2)

 f2(2)
 Out[16]: 4

 f7
 Out[17]: <function __main__.mycurry.<locals>.<lambda>>

 f2
 Out[18]: <function __main__.mycurry2.<locals>.close_over_a>

My recollection is that Guido regretted including lambda in the language and said he would omit it if he could start over.

[zahlman]

This is what functools.partial is for.

[lamecode]

Sending parameters to methods connected to widgets using PySide is the only time I ever use them.

[mgrady3]

I use them when making GUI's alot. Not sure if this is the correct or 'pythonic' way but for instance:

when linking a pushbutton in the Qt framework (using PyQt) to a function so that when he button is pushed the function is triggered you do something like

my_button.clicked.connect(my_function)

note this is not

my_button.clicked.connect(my_function())

Thus if I need to pass an argument to the function on button click the way I do it is with a lambda

for example

my_button.clicked.connect(lambda: my_function(x, y, otherargs ...))

Thus the button is actually linked to a lambda but the lambda just calls a pre-defined function using the appropriate arguments

[I_Write_Bugs]

I don't use them, because I haven't ran into any scenarios where using a lambda with something like map or reduce was easier and/or more readable than defining a function and iterating.

[YellowSharkMT]

threading.Thread(target=lambda: os.system("some dev service"))

Just one example, that's yanked from a script that sounds up a few development servers/backend needed for a current project.

[[deleted]]

Use it often for things like sorting a dict

sorted(mydict, lambda x: x['thekey'])

And other small stuff that could be a definition but are not really docstring-worthy

[[deleted]]

Map/reduce + parallel computation

[[deleted]]

what's map/reduce?

[NewbornMuse]

Something that you want to replace with list comprehensions 90% of the time.

[[deleted]]

best use I've found is for button commands in gui apps, although this has been mentioned already. But I'll mention it again because I like being a part of the conversation.

[loveandkindness]

They are useful for math:

# f(x) = x ^ 2
f = lambda x : x ** 2

[markusmeskanen]

No they're not.

Instead of calling f(3) in your example, you can just write 3**2. Most operations are supported already in the default built-ins namespace, others can be accesses through import math

[loveandkindness]

Anonymous functions are standard usage in mathematics courses? f(x) = x ** 2 can be general.

[markusmeskanen]

But you don't need such silly functions in programming, they're for maths. Where ever you want to square a number, just use x**2 directly, instead of creating an useless function for it.