# Does Python Have Ternary Operator?

Does Python have a ternary operator? If so, how does it work?

A ternary operator, otherwise known as a conditional expression , is a simple if-else statement that is performed on one line of code to evaluate a condition. The value entered before the ``` if ``` clause is the ``` True ``` value returned, whereas the value after the ``` else ``` clause is the ``` False ``` value returned. The expression between the ``` if ``` and the ``` else ``` is the conditional clause that determines what value is returned.

In Python the ternary operator has the following schematic:

``value_if_true if condition else value_if_false``

Here’s how this would work in the Python REPL:

``````>>> my_age = 45
>>> "Your odd this year" if my_age % 2 == 1 else "Your even this year"

As you can see from the simple example above the ternary operator performs a simple check on whether the ``` my_age ``` variable will have a remainder of 1 when divided by 2 (the ``` % ``` modulo division returning the remainder of the division). In this case as the number ``` 45 ``` is an odd number this evaluates to ``` True ``` and therefore the ``` value_if_true ``` part of the ternary operator is returned.

Here’s what would have happened if the number was even:

``````>>> my_age = 44
>>> "Your odd this year" if my_age % 2 == 1 else "Your even this year"

As the condition in the expression evaluates to ``` False ``` in this example the expression after ``` else ``` is returned.

## How Do You Assign A Ternary Operator To A Variable?

To assign the result of a ternary operator in Python to a variable simply declare the name of the variable before the ternary operator followed by the assignment symbol ``` = ``` .

Something like the following:

``````>>> my_age = 44
>>> odd_or_even = "odd" if my_age % 2 == 1 else "even"

From the above example, the code has changed a little so the ternary operator can return the essential ingredient needed: determining whether to output ``` "odd" ``` or ``` "even" ``` . As you can also see from this ternary operator it is assigned to the variable ``` odd_or_even ``` and this variable is then used in an f-string to help output the intended result.

## Can You Use A Ternary Operator Without ``` else ``` ?

Can you use the ternary operator syntax without the ``` else ``` clause? By its nature, a ternary operator needs to have both the result to return if ``` True ``` and the result to return if ``` False ``` .

If you’re looking to create an expression with just an ``` if ``` statement then the only alternative would be something that would have the following schema:

``if condition: value_if_true``

Unfortunately, it isn’t deemed to Pythonic as the nature of ``` if ``` statements in Python is the result is inserted on a new line, like so:

``````if condition:
value_if_true``````

But the single line if statement does work, as demonstrated below:

``````>>> my_age = 45
>>> if 50 > my_age >= 40: print("The roaring forties")
...
The roaring forties``````

As you can see the Python REPL requires a second carriage return after entering that second line containing the ``` if ``` statement. It isn’t something recommended, but can be done.

## What Is A Ternary Operator Alternative?

What can you use instead of the ternary operator? Is there something similar in Python that can be used?

In older versions of Python a way to perform the ternary operator was using tuples. Here’s an example of the format of that tuple:

``(value_if_false, value_if_true)[condition]``

The only problem with this approach is that the ``` value_if_false ``` isn’t true it will still run.

Here’s an example demonstrating the problem with this approach:

``````>>> my_age = 44

As you can see both expressions print out, this could easily be fixed by moving the ``` print ``` statement outside like so:

``````>>> my_age = 44

However, if you don’t want the ``` False ``` side of the tuple to evaluate or run then the syntax will need a little tweak by inserting lambda expressions. Using the previous example where ``` print ``` functions were used in both tuple elements, let’s prefix these with ``` lambda ``` statements are run again:

``````>>> my_age = 44
>>> (lambda: print("Even"), lambda: print("Odd"))[my_age % 2 == 1]()
Even``````

Notice this time that the REPL didn’t output the ``` print ``` from the ``` False ``` tuple (being the first element, or the element with an index of ``` 0 ``` )?

Therefore, to use this syntax if there is an expression that could evaluate and impact your code with the non-returning side then prefix each of the tuple elements with the ``` lambda: ``` expression.

Here’s the syntax using ``` lambda ``` :

``(lambda: value_if_false, lambda: value_if_true)[condition]()``

## Summary

The ternary operator provides Python developers with the ability to code a conditional expression using a single line of code that is succinct and easy to follow.

If you’re looking to use the ternary operator in your code follow the format: ``` value_if_true if condition else value_if_false ``` .

If you’re looking to use an alternative that uses tuples use the format: ``` (lambda: value_if_false, lambda: value_if_true)[condition]() ``` .

Do remember both approaches have different ordering of the ``` True ``` and ``` False ``` values, so it might be best to use one approach consistently throughout your code.

Ryan Sheehy
Ryan has been dabbling in code since the late '90s when he cut his teeth exploring VBA in Excel. Having his eyes opened with the potential of automating repetitive tasks, he expanded to Python and then moved over to scripting languages such as HTML, CSS, Javascript and PHP.