Ternary Operator In Python

Explore the ternary operator in Python for concise conditional statements. Learn its syntax, usage, and limitations to simplify your coding process.

Python, known for its readability and concise syntax, offers various ways to write cleaner and more efficient code. One such feature is the ternary operator, a shortcut for conditional expressions. This operator is useful for writing short if-else statements. This blog explores what the ternary operator is, how it works, and when to use it in Python programming.

What Is Ternary Operator?

The ternary operator is a way to perform conditional assignments in a single line of code. It follows the basic form, given below.

[on_true] if [expression] else [on_false]

Advantages Of Ternary Operator

  • Conciseness: Reduces the number of lines of code for simple conditional assignments.
  • Readability: Once familiar, it makes it easy to understand the condition and outcomes.
  • In-line Usage: Can be used inside function arguments and other expressions.

Ternary Operators Examples

The different examples where the Ternary Operator is used in Python are as follows:

  • Ternary Operator in Python If-Else
  • Python Ternary Operator using Tuples
  • Python Ternary Operator using Dictionary
  • Python Ternary Operator using Lambda
  • Print in if Ternary Operator

Ternary Operator In Python If-Else Statement

The ternary operator in Python offers a compact syntax for conditional expressions, typically replacing a multi-line if-else block. It allows for quick decision-making in your code, evaluating conditions and determining the value of a variable in a single, concise line. This operator is particularly useful for simple, straightforward conditional assignments.

Syntax and Usage

The ternary operator in Python follows this basic structure.

x = value_if_true if condition else value_if_false

Here, condition is evaluated first. If it's true, value_if_true is assigned to x. Otherwise, value_if_false is assigned.


Consider a scenario where we want to classify a number as 'Even' or 'Odd'.

number = 5
classification = "Even" if number % 2 == 0 else "Odd"
print(classification)  # Output: Odd

In this example, the expression number % 2 == 0 checks if number is even. If true, classification is set to "Even"; otherwise, it's set to "Odd".

Nested Ternary Operators

Ternary operators can be nested for multiple conditions. However, this should be done sparingly to maintain readability.

age = 20
category = "Teen" if age < 18 else ("Adult" if age < 60 else "Senior")
print(category)  # Output: Adult

Here, the age is first checked against 18, then 60, to categorize as 'Teen', 'Adult', or 'Senior'.

Python Ternary Operator Using Tuples

The Python ternary operator can be implemented innovatively using tuples, providing an alternative syntax for conditional expressions. This method leverages the fact that in Python, tuples can hold expressions which are evaluated conditionally.

Tuple-based Ternary Syntax

The tuple-based approach follows this structure.

(result_if_false, result_if_true)[condition]

Here, the condition is used as an index to the tuple. Since False evaluates to 0 and True evaluates to 1, the appropriate value is selected based on the condition's truth value.


Consider a scenario where we want to determine if a number is positive or negative.

number = -3
sign = ("Negative", "Positive")[number > 0]
print(sign)  # Output: Negative

In this case, if number > 0 is True, "Positive" is selected; if False, "Negative" is chosen.


While this method is a clever use of Python's features, it evaluates both expressions before selecting one. This can be inefficient, especially if the expressions are complex or involve function calls.

Python Ternary Operator Using Dictionary

The ternary operator in Python can also be implemented using dictionaries, offering a unique and flexible approach to conditional assignments. This technique takes advantage of Python's dictionary data structure to map conditions to their respective outcomes.

Dictionary-based Ternary Syntax

In this approach, a dictionary is used where keys represent possible conditions and values represent corresponding outcomes. The syntax is as follows.

{True: value_if_true, False: value_if_false}[condition]

Here, the condition is evaluated, and the resulting boolean value (True or False) is used to select the appropriate outcome from the dictionary.


Let's say we want to assign a grade based on a student's score.

score = 85
grade = {True: 'Pass', False: 'Fail'}[score >= 60]
print(grade)  # Output: Pass

In this example, if score >= 60 evaluates to True, grade is set to 'Pass'. Otherwise, it's set to 'Fail'.

Advantages and Considerations

Using dictionaries for the ternary operator is particularly useful when dealing with multiple conditions. It enhances readability and makes the code more structured. However, like the tuple-based approach, this method evaluates all expressions in the dictionary, which might not be efficient for certain use cases.

Python Ternary Operator Using Lambda Function

The ternary operator in Python can be effectively implemented using lambda functions, offering a dynamic and functional programming approach to conditional expressions. This method utilizes the flexibility of lambda functions to create inline conditional expressions.

Lambda Function-based Ternary Syntax

A lambda function, in this approach, encapsulates the ternary logic.

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

Here, two lambda functions are defined for the true and false outcomes. The condition is used to select which lambda function to execute.


Assigning a response based on a boolean flag, for instance.

is_raining = True
activity = (lambda: "Stay indoors", lambda: "Go for a walk")[not is_raining]()
print(activity)  # Output: Stay indoors

In this example, if is_raining is True, the first lambda function is executed, resulting in "Stay indoors".

Benefits and Limitations

This lambda function-based method provides a high level of flexibility and is useful when the outcomes are more complex expressions or function calls. However, it's essential to note that this approach can reduce readability and might be less intuitive for those unfamiliar with lambda functions or functional programming concepts.

Print in if Ternary Operator

Incorporating print statements within the ternary operator in Python allows for concise, inline printing based on conditional logic. This method combines the efficiency of the ternary operator with the functionality of print, streamlining the process of outputting different messages based on a condition.

Syntax With Print

The syntax for using print in a ternary operator is as follows.

print(value_if_true) if condition else print(value_if_false)

Here, the condition is evaluated first. Depending on its truth value, either value_if_true or value_if_false is printed.


To print whether a number is positive or negative.

number = -10
print("Positive") if number >= 0 else print("Negative")
# Output: Negative

In this case, the script prints "Negative" since the number is less than 0.

Usage Considerations

This method is particularly useful for debugging or when you need to quickly output the result of a conditional check. However, it's important to use this approach judiciously to maintain code clarity and avoid overly complex one-liners.

Limitations Of Python Ternary Operator

The ternary operator in Python, while useful for concise conditional expressions, comes with certain limitations:

  • Complexity in Readability: When dealing with complex conditions or nested ternary operators, readability can significantly decrease. Code with multiple ternary operators can be hard to understand and maintain.
  • Single Expression Limitation: The ternary operator can only execute a single expression in each of its branches. It's not suitable for scenarios where multiple statements are required for each condition.
  • No Performance Gain: Using the ternary operator does not offer any performance advantages over traditional if-else statements. The benefit is purely syntactic, aimed at brevity rather than speed.
  • Overuse Can Lead to Confusion: Excessive use of ternary operators, especially in a single line, can make the code less intuitive and harder to debug, particularly for those who are new to Python.
  • Not Ideal for All Situations: The ternary operator is best used for simple, straightforward conditions. For more complex decision-making processes, traditional if-else statements or other control flow tools are more appropriate and readable.

Understanding these limitations is key to using the ternary operator effectively in Python, ensuring that it adds clarity and conciseness to the code without sacrificing maintainability and readability.

You can also check these blogs:

  1. Division Operator In Python