# Conditional statement in a one line lambda function in python?

65

Apologies if this has been asked before, but I couldn't see it anywhere.

Essentially I've come across a scenario where i need to make use of an if statement inside a lambda function. What makes it difficult is that ideally it needs to be in a single line of code (if thats even possible?)

Normally, i would write this:

``````T = 250

if (T > 200):
rate = 200*exp(-T)
else:
rate = 400*exp(-T)

return (rate)
``````

However i need it to look like this:

``````rate = lambda(T) : if (T>200): return(200*exp(-T)); else: return(400*exp(-T))
``````

I realize the easier thing to do would to take the decision making outside of the lambda functions, and then have a separate lambda function for each case, but its not really suitable here. The lambda functions are stored in an array and accessed when needed, with each array element corresponding to a particular "rate" so having two separate rows for the same "rate" would mess things up. Any help would be greatly appreciated, or if its not possible, some confirmation from others would be nice :)

This question is tagged with `python` `if-statement` `lambda` `ternary-operator` `conditional-operator`

~ Asked on 2013-04-02 19:25:12

### The Best Answer is

98

Use the `exp1 if cond else exp2` syntax.

``````rate = lambda T: 200*exp(-T) if T>200 else 400*exp(-T)
``````

Note you don't use `return` in lambda expressions.

~ Answered on 2013-04-02 19:27:55

22

The right way to do this is simple:

``````def rate(T):
if (T > 200):
return 200*exp(-T)
else:
return 400*exp(-T)
``````

There is absolutely no advantage to using `lambda` here. The only thing `lambda` is good for is allowing you to create anonymous functions and use them in an expression (as opposed to a statement). If you immediately assign the `lambda` to a variable, it's no longer anonymous, and it's used in a statement, so you're just making your code less readable for no reason.

The `rate` function defined this way can be stored in an array, passed around, called, etc. in exactly the same way a lambda function could. It'll be exactly the same (except a bit easier to debug, introspect, etc.).

From a comment:

Well the function needed to fit in one line, which i didn't think you could do with a named function?

I can't imagine any good reason why the function would ever need to fit in one line. But sure, you can do that with a named function. Try this in your interpreter:

``````>>> def foo(x): return x + 1
``````

Also these functions are stored as strings which are then evaluated using "eval" which i wasn't sure how to do with regular functions.

Again, while it's hard to be 100% sure without any clue as to why why you're doing this, I'm at least 99% sure that you have no reason or a bad reason for this. Almost any time you think you want to pass Python functions around as strings and call `eval` so you can use them, you actually just want to pass Python functions around as functions and use them as functions.

But on the off chance that this really is what you need here: Just use `exec` instead of `eval`.

You didn't mention which version of Python you're using. In 3.x, the `exec` function has the exact same signature as the `eval` function:

``````exec(my_function_string, my_globals, my_locals)
``````

In 2.7, `exec` is a statement, not a function—but you can still write it in the same syntax as in 3.x (as long as you don't try to assign the return value to anything) and it works.

In earlier 2.x (before 2.6, I think?) you have to do it like this instead:

``````exec my_function_string in my_globals, my_locals
``````

~ Answered on 2013-04-02 19:45:37