124

I sometimes find myself wanting to make placeholder 'do nothing' lambda expressions, similar to saying:

def do_nothing(*args):
    pass

But the following syntax is illegal since lambda expressions attempt to return whatever is after the colon, and you can't return pass.

do_nothing = lambda *args: pass

So I was wondering, would the following expression be a suitable replacement for the above?

do_nothing = lambda *args: None

Since the do_nothing function above technically returns None, is it okay to make a lambda expression that returns None to use as a placeholder lambda expression? Or is it bad practice?

user3002473
  • 4,835
  • 8
  • 35
  • 61
  • It does do the same thing as the `do_nothing` function, but it's not clear why you need to use a `lambda` for it. – BrenBarn Mar 29 '14 at 23:47
  • I wanted to use `lambda` purely for readability of code, since I'm personally not a fan of nested functions and the application I wanted to use the expression in would be a third nested function. I'm also simply just interested in other opinions about using this coding trope. – user3002473 Mar 29 '14 at 23:50
  • 1
    In idiomatic Python, most places where you would need a do-nothing function accept `None`, even though it isn't callable. To wit: `filter(None, alist)` – kojiro Mar 29 '14 at 23:51
  • 8
    Since all do-nothing functions do the same nothing, you could just define `do_nothing` in one place and then pass `do_nothing` whenever you want to pass a do-nothing. There's no need to redefine it with a new lambda (or full function def) every time you want to use it. – BrenBarn Mar 29 '14 at 23:51
  • `mock.Mock()` can be your dummy callable, accepting any parameters. But it returns another Mock and it may result in weird bugs. Changing it to `mock.Mock(return_value=None)` can be still buggy since you can try to get an attribute from it and it will work, returning another Mock. – Ctrl-C May 19 '17 at 11:23

6 Answers6

148

This:

def do_nothing(*args):
    pass

is equivalent to:

lambda *args: None

With some minor differences in that one is a lambda and one isn't. (For example, __name__ will be do_nothing on the function, and <lambda> on the lambda.) Don't forget about **kwargs, if it matters to you. Functions in Python without an explicit return <x> return None. This is here:

A call always returns some value, possibly None, unless it raises an exception.

I've used similar functions as default values, say for example:

def long_running_code(progress_function=lambda percent_complete: None):
    # Report progress via progress_function.
Thanatos
  • 42,585
  • 14
  • 91
  • 146
  • This also works in ternary conditional expressions: DEBUG = print if DEBUGSW == True else lambda *args: None – JayJay123 Mar 25 '23 at 07:55
66

If you truly want a full do nothing lambda function, make sure to gobble up *args and *kwargs.

noop = lambda *args, **kwargs: None

In all its glorious action

>>> noop = lambda *args, **kwargs: None
>>> noop("yes", duck_size="horse", num_ducks=100)
>>>

Side Note

Since the accepted answer is only using *args, I must point out that you will do yourself a favor for the future by including the **kwargs handling. If you ever try to use the noop somewhere deep away in your code and you forgot that it doesn't take kwargs, it will be quite the Exception to doing nothing:

In [2]: do_nothing('asdf', duck="yes")
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-2-efbd722f297c> in <module>()
----> 1 do_nothing('asdf', duck="yes")

TypeError: <lambda>() got an unexpected keyword argument 'duck'
Kyle Kelley
  • 13,804
  • 8
  • 49
  • 78
27

Sometimes lambda functions are used for data transformation, and in that case 'do nothing' means to return the input, i.e.

lambda x: x

To return none you can write

lambda x: None

Paul
  • 26,170
  • 12
  • 85
  • 119
21

This is the simplest lambda expression:

do_nothing = lambda: None

No arguments required and the minimal required return.

Rafa0809
  • 1,733
  • 21
  • 24
6

In Python 3 you don't even need to define any functions for that. Calling type(None) will return you the NoneType constructor, which you can use for doing nothing: type(None)(). Keep in mind that the NoneType constructor only takes 0 arguments.

In Python 2, though, creating instances of NoneType is impossible, so lambda: None would make the most sense.

Arthur Khazbs
  • 705
  • 8
  • 19
1

Besides this expression

lambda *args: None

there is another graceful expression using Ellipsis:

lambda *args: ...

This can also be useful in case the function has no arguments (callback for example):

lambda: None

lambda: ...
Anton Ermakov
  • 461
  • 3
  • 13