ternary operator python assignment

• Subscription

Python Ternary: How to Use It and Why It’s Useful (with Examples)

What is a python ternary operator, and when is it useful this tutorial will walk you through everything you need to know..

The Python ternary operator (or conditional operator ), tests if a condition is true or false and, depending on the outcome, returns the corresponding value — all in just one line of code. In other words, it's a compact alternative to the common multiline if-else control flow statements in situations when we only need to "switch" between two values. The ternary operator was introduced in Python 2.5.

The syntax consists of three operands, hence the name "ternary":

Here are these operands:

• condition — a Boolean expression to test for true or false
• a — the value that will be returned if the condition is evaluated to be true
• b — the value that will be returned if the condition is evaluated to be false

The equivalent of a common if-else statement, in this case, would be the following:

Let's look at a simple example:

While the ternary operator is a way of re-writing a classic if-else block, in a certain sense, it behaves like a function since it returns a value. Indeed, we can assign the result of this operation to a variable:

my_var = a if condition else b

For example:

Before we had the ternary operator, instead of a if condition else b , we would use condition and a or b . For example, instead of running the following . . .

. . . we would run this:

However, if the value of a in the syntax condition and a or b evaluates to False (e.g., if a is equal to 0 , or None , or False ), we would receive inaccurate results. The example of a ternary operator below looks logically controversial (we want to return False if 2 > 1; otherwise, we want to return True ) but it is technically correct since it's up to us to decide which value to return if the condition evaluates to True — and which value to return if the condition evaluates to False . In this case, we expect False , and we got it:

Using the "old-style" syntax instead of the ternary operator for the same purpose, we would still expect False . However, we received an unexpected result:

To avoid such issues, it's always better to use the ternary operator in similar situations.

Limitations of Python Ternary Operator

Note that each operand of the Python ternary operator is an expression , not a statement , meaning that we can't use assignment statements inside any of them. Otherwise, the program throws an error:

If we need to use statements, we have to write a full if-else block rather than the ternary operator:

Another limitation of the Python ternary operator is that we shouldn't use it for testing multiple expressions (i.e., the if-else blocks with more than two cases). Technically, we still can do so. For example, take the following piece of code:

We can rewrite this code using nested ternary operators :

( Side note: In the above piece of code, we omitted the print() statement since the Python ternary operator always returns a value.)

While the second piece of code looks more compact than the first one, it's also much less readable. To avoid readability issues, we should opt to use the Python ternary operator only when we have simple if-else statements.

How to Use a Python Ternary Operator

Now, we'll discuss various ways of applying the Python ternary operator. Let's say we want to check if the water at a certain temperature is boiling or not. At standard atmospheric pressure, water boils at 100 degrees Celsius. Suppose that we want to know if the water in our kettle is boiling given that its temperature reaches 90 degrees Celsius. In this case, we can simply use the if-else block:

We can re-write this piece of code using a simple Python ternary operator:

( Side note: above, we omitted the print() statement since the Python ternary operator always returns a value.)

The syntax for both pieces of code above is already familiar. However, there are some other ways to implement the Python ternary operator that we haven't considered yet.

Using Tuples

The first way to re-organize the Python ternary operator is by writing its tupled form. If the standard syntax for the Python ternary operator is a if condition else b , here we would re-write it as (b, a)[condition] , like this:

In the syntax above, the first item of the tuple is the value that will be returned if the condition evaluates to False (since False==0 ), while the second is the value that will be returned if the condition evaluates to True (since True==1 ).

This way of using the Python ternary operator isn't popular compared to its common syntax because, in this case, both elements of the tuple are evaluated since the program first creates the tuple and only then checks the index. In addition, it can be counterintuitive to identify where to place the true value and where to place the false value.

Using Dictionaries

Instead of tuples, we can also use Python dictionaries, like this:

Now, we don't have the issue of differentiating between the true and false values. However, as with the previous case, both expressions are evaluated before returning the right one.

Using Lambdas

Finally, the last way of implementing the Python ternary operator is by applying Lambda functions. To do so, we should re-write the initial syntax a if condition else b in the following form: (lambda: b, lambda: a)[condition]()

Note that in this case, we can become confused about where to put the true and false values. However, the advantage of this approach over the previous two is that it performs more efficiently because only one expression is evaluated.

Let's sum up what we learned in this tutorial about the Python ternary operator:

• How the Python ternary operator works
• When its preferable to a common if-else block
• The syntax of the Python ternary operator
• The equivalent of the Python ternary operator written in a common if-else block
• The old version of the Python ternary operator and its problems
• The limitations of the Python ternary operator
• Nested Python ternary operators and their effect on code readability
• How to apply the Python ternary operator using tuples, dictionaries, and Lambda functions — including the pros and cons of each method

More learning resources

Python dictionary tutorial: analyze craft beer with dictionaries, python datetime tutorial: manipulate times, dates, and time spans.

Learn data skills 10x faster

Join 1M+ learners

Enroll for free

• Data Analyst (Python)
• Gen AI (Python)
• Business Analyst (Power BI)
• Business Analyst (Tableau)
• Machine Learning
• Data Analyst (R)

Home » Python Basics » Python Ternary Operator

Python Ternary Operator

Summary : in this tutorial, you’ll learn about the Python ternary operator and how to use it to make your code more concise.

Introduction to Python Ternary Operator

The following program prompts you for your age and determines the ticket price based on it:

Here is the output when you enter 18:

In this example, the following if...else statement assigns 20 to the ticket_price if the age is greater than or equal to 18. Otherwise, it assigns the ticket_price 5:

To make it more concise, you can use an alternative syntax like this:

In this statement, the left side of the assignment operator ( = ) is the variable ticket_price .

The expression on the right side returns 20 if the age is greater than or equal to 18 or 5 otherwise.

The following syntax is called a ternary operator in Python:

The ternary operator evaluates the condition . If the result is True , it returns the value_if_true . Otherwise, it returns the value_if_false .

The ternary operator is equivalent to the following if...else statement:

Note that you have been programming languages such as C# or Java, and you’re familiar with the following ternary operator syntax:

However, Python doesn’t support this ternary operator syntax.

The following program uses the ternary operator instead of the if statement:

• The Python ternary operator is value_if_true if condition else value_if_false .
• Use the ternary operator to make your code more concise.

Conditional Statements in Python

Table of Contents

Introduction to the if Statement

Python: it’s all about the indentation, what do other languages do, which is better, the else and elif clauses, one-line if statements, conditional expressions (python’s ternary operator), the python pass statement.

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Conditional Statements in Python (if/elif/else)

From the previous tutorials in this series, you now have quite a bit of Python code under your belt. Everything you have seen so far has consisted of sequential execution , in which statements are always performed one after the next, in exactly the order specified.

But the world is often more complicated than that. Frequently, a program needs to skip over some statements, execute a series of statements repetitively, or choose between alternate sets of statements to execute.

That is where control structures come in. A control structure directs the order of execution of the statements in a program (referred to as the program’s control flow ).

Here’s what you’ll learn in this tutorial: You’ll encounter your first Python control structure, the if statement.

In the real world, we commonly must evaluate information around us and then choose one course of action or another based on what we observe:

If the weather is nice, then I’ll mow the lawn. (It’s implied that if the weather isn’t nice, then I won’t mow the lawn.)

In a Python program, the if statement is how you perform this sort of decision-making. It allows for conditional execution of a statement or group of statements based on the value of an expression.

The outline of this tutorial is as follows:

• First, you’ll get a quick overview of the if statement in its simplest form.
• Next, using the if statement as a model, you’ll see why control structures require some mechanism for grouping statements together into compound statements or blocks . You’ll learn how this is done in Python.
• Lastly, you’ll tie it all together and learn how to write complex decision-making code.

Ready? Here we go!

Take the Quiz: Test your knowledge with our interactive “Python Conditional Statements” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Test your understanding of Python conditional statements

We’ll start by looking at the most basic type of if statement. In its simplest form, it looks like this:

In the form shown above:

• <expr> is an expression evaluated in a Boolean context, as discussed in the section on Logical Operators in the Operators and Expressions in Python tutorial.
• <statement> is a valid Python statement, which must be indented. (You will see why very soon.)

If <expr> is true (evaluates to a value that is “truthy”), then <statement> is executed. If <expr> is false, then <statement> is skipped over and not executed.

Note that the colon ( : ) following <expr> is required. Some programming languages require <expr> to be enclosed in parentheses, but Python does not.

Here are several examples of this type of if statement:

Note: If you are trying these examples interactively in a REPL session, you’ll find that, when you hit Enter after typing in the print('yes') statement, nothing happens.

Because this is a multiline statement, you need to hit Enter a second time to tell the interpreter that you’re finished with it. This extra newline is not necessary in code executed from a script file.

Grouping Statements: Indentation and Blocks

So far, so good.

But let’s say you want to evaluate a condition and then do more than one thing if it is true:

If the weather is nice, then I will: Mow the lawn Weed the garden Take the dog for a walk (If the weather isn’t nice, then I won’t do any of these things.)

In all the examples shown above, each if <expr>: has been followed by only a single <statement> . There needs to be some way to say “If <expr> is true, do all of the following things.”

The usual approach taken by most programming languages is to define a syntactic device that groups multiple statements into one compound statement or block . A block is regarded syntactically as a single entity. When it is the target of an if statement, and <expr> is true, then all the statements in the block are executed. If <expr> is false, then none of them are.

Virtually all programming languages provide the capability to define blocks, but they don’t all provide it in the same way. Let’s see how Python does it.

Python follows a convention known as the off-side rule , a term coined by British computer scientist Peter J. Landin. (The term is taken from the offside law in association football.) Languages that adhere to the off-side rule define blocks by indentation. Python is one of a relatively small set of off-side rule languages .

Recall from the previous tutorial on Python program structure that indentation has special significance in a Python program. Now you know why: indentation is used to define compound statements or blocks. In a Python program, contiguous statements that are indented to the same level are considered to be part of the same block.

Thus, a compound if statement in Python looks like this:

Here, all the statements at the matching indentation level (lines 2 to 5) are considered part of the same block. The entire block is executed if <expr> is true, or skipped over if <expr> is false. Either way, execution proceeds with <following_statement> (line 6) afterward.

Notice that there is no token that denotes the end of the block. Rather, the end of the block is indicated by a line that is indented less than the lines of the block itself.

Note: In the Python documentation, a group of statements defined by indentation is often referred to as a suite . This tutorial series uses the terms block and suite interchangeably.

Consider this script file foo.py :

Running foo.py produces this output:

The four print() statements on lines 2 to 5 are indented to the same level as one another. They constitute the block that would be executed if the condition were true. But it is false, so all the statements in the block are skipped. After the end of the compound if statement has been reached (whether the statements in the block on lines 2 to 5 are executed or not), execution proceeds to the first statement having a lesser indentation level: the print() statement on line 6.

Blocks can be nested to arbitrary depth. Each indent defines a new block, and each outdent ends the preceding block. The resulting structure is straightforward, consistent, and intuitive.

Here is a more complicated script file called blocks.py :

The output generated when this script is run is shown below:

Note: In case you have been wondering, the off-side rule is the reason for the necessity of the extra newline when entering multiline statements in a REPL session. The interpreter otherwise has no way to know that the last statement of the block has been entered.

Perhaps you’re curious what the alternatives are. How are blocks defined in languages that don’t adhere to the off-side rule?

The tactic used by most programming languages is to designate special tokens that mark the start and end of a block. For example, in Perl blocks are defined with pairs of curly braces ( {} ) like this:

C/C++, Java , and a whole host of other languages use curly braces in this way.

Other languages, such as Algol and Pascal, use keywords begin and end to enclose blocks.

Better is in the eye of the beholder. On the whole, programmers tend to feel rather strongly about how they do things. Debate about the merits of the off-side rule can run pretty hot.

On the plus side:

• Python’s use of indentation is clean, concise, and consistent.
• In programming languages that do not use the off-side rule, indentation of code is completely independent of block definition and code function. It’s possible to write code that is indented in a manner that does not actually match how the code executes, thus creating a mistaken impression when a person just glances at it. This sort of mistake is virtually impossible to make in Python.
• Use of indentation to define blocks forces you to maintain code formatting standards you probably should be using anyway.

On the negative side:

• Many programmers don’t like to be forced to do things a certain way. They tend to have strong opinions about what looks good and what doesn’t, and they don’t like to be shoehorned into a specific choice.
• Some editors insert a mix of space and tab characters to the left of indented lines, which makes it difficult for the Python interpreter to determine indentation levels. On the other hand, it is frequently possible to configure editors not to do this. It generally isn’t considered desirable to have a mix of tabs and spaces in source code anyhow, no matter the language.

Like it or not, if you’re programming in Python, you’re stuck with the off-side rule. All control structures in Python use it, as you will see in several future tutorials.

For what it’s worth, many programmers who have been used to languages with more traditional means of block definition have initially recoiled at Python’s way but have gotten comfortable with it and have even grown to prefer it.

Now you know how to use an if statement to conditionally execute a single statement or a block of several statements. It’s time to find out what else you can do.

Sometimes, you want to evaluate a condition and take one path if it is true but specify an alternative path if it is not. This is accomplished with an else clause:

If <expr> is true, the first suite is executed, and the second is skipped. If <expr> is false, the first suite is skipped and the second is executed. Either way, execution then resumes after the second suite. Both suites are defined by indentation, as described above.

In this example, x is less than 50 , so the first suite (lines 4 to 5) are executed, and the second suite (lines 7 to 8) are skipped:

Here, on the other hand, x is greater than 50 , so the first suite is passed over, and the second suite executed:

There is also syntax for branching execution based on several alternatives. For this, use one or more elif (short for else if ) clauses. Python evaluates each <expr> in turn and executes the suite corresponding to the first that is true. If none of the expressions are true, and an else clause is specified, then its suite is executed:

An arbitrary number of elif clauses can be specified. The else clause is optional. If it is present, there can be only one, and it must be specified last:

At most, one of the code blocks specified will be executed. If an else clause isn’t included, and all the conditions are false, then none of the blocks will be executed.

Note: Using a lengthy if / elif / else series can be a little inelegant, especially when the actions are simple statements like print() . In many cases, there may be a more Pythonic way to accomplish the same thing.

Here’s one possible alternative to the example above using the dict.get() method:

Recall from the tutorial on Python dictionaries that the dict.get() method searches a dictionary for the specified key and returns the associated value if it is found, or the given default value if it isn’t.

An if statement with elif clauses uses short-circuit evaluation, analogous to what you saw with the and and or operators. Once one of the expressions is found to be true and its block is executed, none of the remaining expressions are tested. This is demonstrated below:

The second expression contains a division by zero, and the third references an undefined variable var . Either would raise an error, but neither is evaluated because the first condition specified is true.

It is customary to write if <expr> on one line and <statement> indented on the following line like this:

But it is permissible to write an entire if statement on one line. The following is functionally equivalent to the example above:

There can even be more than one <statement> on the same line, separated by semicolons:

But what does this mean? There are two possible interpretations:

If <expr> is true, execute <statement_1> .

Then, execute <statement_2> ... <statement_n> unconditionally, irrespective of whether <expr> is true or not.

If <expr> is true, execute all of <statement_1> ... <statement_n> . Otherwise, don’t execute any of them.

Python takes the latter interpretation. The semicolon separating the <statements> has higher precedence than the colon following <expr> —in computer lingo, the semicolon is said to bind more tightly than the colon. Thus, the <statements> are treated as a suite, and either all of them are executed, or none of them are:

Multiple statements may be specified on the same line as an elif or else clause as well:

While all of this works, and the interpreter allows it, it is generally discouraged on the grounds that it leads to poor readability, particularly for complex if statements. PEP 8 specifically recommends against it.

As usual, it is somewhat a matter of taste. Most people would find the following more visually appealing and easier to understand at first glance than the example above:

If an if statement is simple enough, though, putting it all on one line may be reasonable. Something like this probably wouldn’t raise anyone’s hackles too much:

Python supports one additional decision-making entity called a conditional expression. (It is also referred to as a conditional operator or ternary operator in various places in the Python documentation.) Conditional expressions were proposed for addition to the language in PEP 308 and green-lighted by Guido in 2005.

In its simplest form, the syntax of the conditional expression is as follows:

This is different from the if statement forms listed above because it is not a control structure that directs the flow of program execution. It acts more like an operator that defines an expression. In the above example, <conditional_expr> is evaluated first. If it is true, the expression evaluates to <expr1> . If it is false, the expression evaluates to <expr2> .

Notice the non-obvious order: the middle expression is evaluated first, and based on that result, one of the expressions on the ends is returned. Here are some examples that will hopefully help clarify:

Note: Python’s conditional expression is similar to the <conditional_expr> ? <expr1> : <expr2> syntax used by many other languages—C, Perl and Java to name a few. In fact, the ?: operator is commonly called the ternary operator in those languages, which is probably the reason Python’s conditional expression is sometimes referred to as the Python ternary operator.

You can see in PEP 308 that the <conditional_expr> ? <expr1> : <expr2> syntax was considered for Python but ultimately rejected in favor of the syntax shown above.

A common use of the conditional expression is to select variable assignment. For example, suppose you want to find the larger of two numbers. Of course, there is a built-in function, max() , that does just this (and more) that you could use. But suppose you want to write your own code from scratch.

You could use a standard if statement with an else clause:

But a conditional expression is shorter and arguably more readable as well:

Remember that the conditional expression behaves like an expression syntactically. It can be used as part of a longer expression. The conditional expression has lower precedence than virtually all the other operators, so parentheses are needed to group it by itself.

In the following example, the + operator binds more tightly than the conditional expression, so 1 + x and y + 2 are evaluated first, followed by the conditional expression. The parentheses in the second case are unnecessary and do not change the result:

If you want the conditional expression to be evaluated first, you need to surround it with grouping parentheses. In the next example, (x if x > y else y) is evaluated first. The result is y , which is 40 , so z is assigned 1 + 40 + 2 = 43 :

If you are using a conditional expression as part of a larger expression, it probably is a good idea to use grouping parentheses for clarification even if they are not needed.

Conditional expressions also use short-circuit evaluation like compound logical expressions. Portions of a conditional expression are not evaluated if they don’t need to be.

In the expression <expr1> if <conditional_expr> else <expr2> :

• If <conditional_expr> is true, <expr1> is returned and <expr2> is not evaluated.
• If <conditional_expr> is false, <expr2> is returned and <expr1> is not evaluated.

As before, you can verify this by using terms that would raise an error:

In both cases, the 1/0 terms are not evaluated, so no exception is raised.

Conditional expressions can also be chained together, as a sort of alternative if / elif / else structure, as shown here:

It’s not clear that this has any significant advantage over the corresponding if / elif / else statement, but it is syntactically correct Python.

Occasionally, you may find that you want to write what is called a code stub: a placeholder for where you will eventually put a block of code that you haven’t implemented yet.

In languages where token delimiters are used to define blocks, like the curly braces in Perl and C, empty delimiters can be used to define a code stub. For example, the following is legitimate Perl or C code:

Here, the empty curly braces define an empty block. Perl or C will evaluate the expression x , and then even if it is true, quietly do nothing.

Because Python uses indentation instead of delimiters, it is not possible to specify an empty block. If you introduce an if statement with if <expr>: , something has to come after it, either on the same line or indented on the following line.

Consider this script foo.py :

If you try to run foo.py , you’ll get this:

The Python pass statement solves this problem. It doesn’t change program behavior at all. It is used as a placeholder to keep the interpreter happy in any situation where a statement is syntactically required, but you don’t really want to do anything:

Now foo.py runs without error:

With the completion of this tutorial, you are beginning to write Python code that goes beyond simple sequential execution:

• You were introduced to the concept of control structures . These are compound statements that alter program control flow —the order of execution of program statements.
• You learned how to group individual statements together into a block or suite .
• You encountered your first control structure, the if statement, which makes it possible to conditionally execute a statement or block based on evaluation of program data.

All of these concepts are crucial to developing more complex Python code.

The next two tutorials will present two new control structures: the while statement and the for statement. These structures facilitate iteration , execution of a statement or block of statements repeatedly.

🐍 Python Tricks 💌

Get a short & sweet Python Trick delivered to your inbox every couple of days. No spam ever. Unsubscribe any time. Curated by the Real Python team.

About John Sturtz

John is an avid Pythonista and a member of the Real Python tutorial team.

Each tutorial at Real Python is created by a team of developers so that it meets our high quality standards. The team members who worked on this tutorial are:

Master Real-World Python Skills With Unlimited Access to Real Python

Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas:

Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas:

What Do You Think?

What’s your #1 takeaway or favorite thing you learned? How are you going to put your newfound skills to use? Leave a comment below and let us know.

Commenting Tips: The most useful comments are those written with the goal of learning from or helping out other students. Get tips for asking good questions and get answers to common questions in our support portal . Looking for a real-time conversation? Visit the Real Python Community Chat or join the next “Office Hours” Live Q&A Session . Happy Pythoning!

Keep Learning

Related Topics: basics python

Recommended Video Course: Conditional Statements in Python (if/elif/else)

Keep reading Real Python by creating a free account or signing in:

Already have an account? Sign-In

Python Ternary Operator - If Else One Line

In this tutorial, we will learn about the Python ternary operator. Moreover, we will look at its syntax, usage, and examples.

Table Of Contents - Python Ternary Operator

Ternary operator syntax

• python ternary operator example
• python ternary assignment
• Nested ternary operator
• python ternary operator multiple conditions
• python ternary operator without else

Ternary Operator In Python

The ternary operator in Python is a conditional operator that has three operands. The ternary operator is used to evaluate a condition and return either of the two values depending on the condition.

The ternary operator is just like a python if else statement but more clean, concise, and easy to understand.

The syntax of Python ternary operator is as follows:

The 'condition' is the condition that is to be evaluated. The 'expression1' and 'expression2' are the expressions that are evaluated based on the condition.

The first condition is evaluated. If the condition is true, then the 'expression1' is evaluated and the value is returned. Otherwise, the 'expression2' is evaluated and the value is returned.

Note : Python ternary operator is the same as condition ? expression1 : expression2 in other programming languages like C, C++, JavaScript, etc.

Python Ternary Operator Example

The following example shows the usage of the ternary operator in python and also compares its code with the if-else statement.

• Ternary Operator

Here is another simple example of a ternary operator.

a is less than b

The above example compares the value of a and b, if a is greater than b then it prints "a is greater than b" otherwise it prints "a is less than b".

Python Ternary Assignment

The ternary operator is mostly used in assigning values to variables . When you have to decide different values of a variable based on the condition, then you can use the ternary operator.

Using a ternary operator for assigning values also makes the code more readable and concise.

Nested Ternary Operator

The ternary operator can also be nested. This means you can have a ternary operator inside another ternary operator.

A nested ternary operator is used to evaluate results based on multiple conditions.

Code explanation: Return the value of a if a is greater than b [ a if a > b else (b if a < b else a) ] , else return the value of b if a is less than b, else return the value of a [ b if a < b else a ].

Here is an example of 3 nested ternary operators.

Python Ternary Operator Multiple Conditions

You can also use multiple conditions in a ternary operator by using logical operator keywords like and , or , not

Separate as many conditions with logical operators like and , or , not and wrap them in parenthesis.

The above code checks if a and b are divisible by 2, 3, and 5 using multiple conditions. If all conditions are true then it prints "Yes" otherwise it prints "No".

Python Ternary Operator Without Else

Python does not allow using ternary operator without else.

But you can create similar functionality by using the and operator.

Here is an example of that:

Code explanation

• The above code has the format of True/False and string
• If the first statement is false then the and operator will return False and the second statement will not be executed.
• If the first statement is true then the and operator will return second statement.

Python Ternary Operator Conclusion

Ternary operator in python is an alternate way of writing if-else which is concise and simple.

It first evaluates the given condition, then executes expression based on the condition then returns the value.

The ternary operator is not always useful. It is helpful when you have only one statement to execute after the condition is evaluated.

Conditional expression (ternary operator) in Python

Python has a conditional expression (sometimes called a "ternary operator"). You can write operations like if statements in one line with conditional expressions.

• 6. Expressions - Conditional expressions — Python 3.11.3 documentation

Basics of the conditional expression (ternary operator)

If ... elif ... else ... by conditional expressions, list comprehensions and conditional expressions, lambda expressions and conditional expressions.

See the following article for if statements in Python.

• Python if statements (if, elif, else)

In Python, the conditional expression is written as follows.

The condition is evaluated first. If condition is True , X is evaluated and its value is returned, and if condition is False , Y is evaluated and its value is returned.

If you want to switch the value based on a condition, simply use the desired values in the conditional expression.

If you want to switch between operations based on a condition, simply describe each corresponding expression in the conditional expression.

An expression that does not return a value (i.e., an expression that returns None ) is also acceptable in a conditional expression. Depending on the condition, either expression will be evaluated and executed.

The above example is equivalent to the following code written with an if statement.

You can also combine multiple conditions using logical operators such as and or or .

• Boolean operators in Python (and, or, not)

By combining conditional expressions, you can write an operation like if ... elif ... else ... in one line.

However, it is difficult to understand, so it may be better not to use it often.

The following two interpretations are possible, but the expression is processed as the first one.

In the sample code below, which includes three expressions, the first expression is interpreted like the second, rather than the third:

By using conditional expressions in list comprehensions, you can apply operations to the elements of the list based on the condition.

See the following article for details on list comprehensions.

• List comprehensions in Python

Conditional expressions are also useful when you want to apply an operation similar to an if statement within lambda expressions.

In the example above, the lambda expression is assigned to a variable for convenience, but this is not recommended by PEP8.

Refer to the following article for more details on lambda expressions.

• Lambda expressions in Python

Related Categories

Related articles.

• Shallow and deep copy in Python: copy(), deepcopy()
• Composite two images according to a mask image with Python, Pillow
• OpenCV, NumPy: Rotate and flip image
• pandas: Check if DataFrame/Series is empty
• Check pandas version: pd.show_versions
• Python if statement (if, elif, else)
• pandas: Find the quantile with quantile()
• Handle date and time with the datetime module in Python
• Get image size (width, height) with Python, OpenCV, Pillow (PIL)
• Convert between Unix time (Epoch time) and datetime in Python
• Convert BGR and RGB with Python, OpenCV (cvtColor)
• Matrix operations with NumPy in Python
• pandas: Replace values in DataFrame and Series with replace()
• Uppercase and lowercase strings in Python (conversion and checking)
• Calculate mean, median, mode, variance, standard deviation in Python

{{ activeMenu.name }}

• Python Courses
• JavaScript Courses
• Artificial Intelligence Courses
• Data Science Courses
• React Courses
• Ethical Hacking Courses
• View All Courses

Fresh Articles

• Python Projects
• JavaScript Projects
• Java Projects
• HTML Projects
• C++ Projects
• PHP Projects
• View All Projects

• Python Certifications
• JavaScript Certifications
• Linux Certifications
• Data Science Certifications
• Data Analytics Certifications
• Cybersecurity Certifications
• View All Certifications

• IDEs & Editors
• Web Development
• Frameworks & Libraries
• View All Programming
• View All Development

• App Development
• Game Development
• Courses, Books, & Certifications
• Data Science
• Data Analytics
• Artificial Intelligence (AI)
• Machine Learning (ML)
• View All Data, Analysis, & AI

• Networking & Security
• Cloud, DevOps, & Systems
• Recommendations
• Crypto, Web3, & Blockchain
• User-Submitted Tutorials
• View All Blog Content
• Python Online Compiler
• JavaScript Online Compiler
• HTML & CSS Online Compiler
• Certifications
• Programming
• Development
• Data, Analysis, & AI
• Online Python Compiler
• Online JavaScript Compiler
• Online HTML Compiler

Don't have an account? Sign up

Forgot your password?

Already have an account? Login

Have you read our submission guidelines?

Go back to Sign In

Python Ternary Operator: How and Why You Should Use It

Writing concise, practical, organized, and intelligible code should be a top priority for any Python developer. Enter, the Python ternary operator.

What is this? I hear you ask. Well, you can use the ternary operator to test a condition and then execute a conditional assignment with only one line of code. And why is this so great? Well, this means we can replace those ever-popular if-else statements with a quicker and more practical way to code conditional assignments.

Now don’t get me wrong, we still need if-else statements (check out our comprehensive guide and Python cheat sheet for the best way to use conditional statements). But, it’s always good practice to make your code more Pythonic when there’s a simpler way to get the same result, and that’s exactly what you get with the ternary operator. 

• Why Use the Python Ternary Operator?

Ternary operators (also known as conditional operators) in Python perform evaluations and assignments after checking whether a given condition is true or false. This means that the ternary operator is a bit like a simplified, one-line if-else statement. Cool, right?

When used correctly, this operator reduces code size and improves readability .

Ternary Operator Syntax

A ternary operator takes three operands: 

• condition:  A Boolean expression that evaluates to true or false
• true_value:  A value or expression to be assigned if the condition evaluates to true
• false_value:  A value or expression to be assigned if the condition evaluates to false

This is how it should look when we put it all together:

So, this means that the variable "var" on the left side of the assignment operator (=), will be assigned either:

• true_value if the Boolean expression evaluates to true
• false_value if the Boolean expression evaluates to false
• How to Use the Ternary Operator Instead of If-Else

To better understand how we replace an if-else statement with the ternary operator in Python, let’s write a simple program with each approach. In this first example, we’ll assume the user enters an integer number when prompted, and we’ll start with the familiar if-else.

Program Using an If-Else Statement

Here’s what we get when the user enters 22 at the input prompt:

In this example, the if-else statement assigns “Yes, you are old enough to watch this movie!” to the movie_acess variable if the user enters an age that is greater than or equal to 18, otherwise, it assigns "Sorry, you aren't old enough to watch this movie yet!”. Finally, we use an f-string to print out the result to the screen.

Now, let's use the ternary operator syntax to make the program much more concise.

Program Using a Ternary Operator

In this version of the program, the variable that receives the result of the conditional statement (movie_access) is to the left of the assignment operator (=).

The ternary operator evaluates the condition:

If the condition evaluates to true, the program assigns “Yes, you are old enough to watch this movie!” to movie_access, else it assigns “Sorry, you aren't old enough to watch this movie yet!”.

Let’s take a look at another example that uses the Python ternary operator and if-else to achieve the same goal. This time, we’ll write a simple Python code snippet to check whether a given integer is even or odd.

In this program, we’ve used a ternary operator and an if-else statement block to determine whether the given integer produces a zero remainder when using modulo divide by 2 (if you’re unfamiliar with this operator, take a look at our cheat sheet). If the remainder is zero, we have an even number, otherwise, we have an odd number. 

Right away, we can tell what the if-else statement will do after evaluating the condition. With the ternary operator snippet, we can see the following:

• "Even" is assigned to msg if the condition (given_int % 2 == 0) is true
• "Odd" is assigned to msg if the condition (given_int % 2 == 0) is false

And, as we’ve set the given integer to an even number, the program will print “Even” to the screen. 

So, we can see again that a ternary conditional statement is a much cleaner and more concise way to achieve the same outcome as an if-else statement. We simply evaluate the ternary expression from left to right, then assign the return value for the true or false condition.

• Key Considerations for Python Ternary Statements

The ternary operator is not always suitable to replace if-else in your code.

If for example, we have more than two conditional branches with an if-elif-else statement, we can’t replace this with a single ternary operator. The clue here is in the name, as ternary refers to the number ‘three’, meaning that it expects three operands. But, if we try to replace an if-elif-else statement with a ternary operator, we’ll have four operands to handle (or possibly more if we have many ‘elif’ branches).

So what do we do here? Well, we need to chain together (or nest) multiple ternary operators (we cover this in the FAQs), but sometimes this can get a little messy, and it may be cleaner to use if-elif-else if the code becomes difficult to read.

Another thing to keep in mind is that we’re meant to use the ternary operator for conditional assignment. What does this mean? Well, we can’t use the ternary approach if we want to execute blocks of code after evaluating a conditional expression: in these situations, it’s best to stick with if-else.

But, we can use the ternary operator if we are assigning something to a variable after checking against a condition. See, it’s easy if we remember that we’re supposed to be assigning something to something else.

Distinct Features of Python Ternary Statements

• Returns A or B depending on the Boolean result of the conditional expression (a < b)
• Compared with C-type languages(C/C++), it uses a different ordering of the provided arguments
• Conditional expressions have the lowest priority of all Python operations

That's all. We did our best to fill you in on everything there is to know about the Python ternary operator. We also covered how to use ternary statements in your Python code, and we compared them to their close relatives, the ever-popular if-else statement.

If you’re a beginner that’s looking for an easy start to your Python programming career, check out our learning guide along with our up-to-date list of Python courses where you can easily enroll online.

Lastly, don’t forget that you can also check out our comprehensive Python cheat sheet which covers various topics, including Python basics, flow control, Modules in Python, functions, exception handling, lists, dictionaries, and data structures, sets, the itertools module, comprehensions, lambda functions, string formatting, the ternary conditional operator, and much more.

• Frequently Asked Questions

1. What are Ternary Operators (including an example)?

Programmers like to use the concise ternary operator for conditional assignments instead of lengthy if-else statements.

The ternary operator takes three arguments:

• Firstly, the comparison argument
• Secondly, the value (or result of an expression) to assign if the comparison is true
• Thirdly, the value (or result of an expression) to assign if the comparison is false

Simple Ternary Operator Example:

If we run this simple program, the "(m < n)" condition evaluates to true, which means that "m" is assigned to "o" and the print statement outputs the integer 10.

The conditional return values of "m" and "n" must not be whole statements, but rather simple values or the result of an expression.

2. How Do You Write a 3-Condition Ternary Operator?

Say you have three conditions to check against and you want to use a ternary conditional statement. What do you do? The answer is actually pretty simple, chain together multiple ternary operators. The syntax below shows the general format for this:

If we break this syntax down, it is saying:

• If condition_1 is true, return value_1 and assign this to var
• Else, check if condition_2 is true. If it is, return value_2 and assign it to var
• If neither conditions are true, return value_3 and assign this to var

We’ve now created a one-line version of an if-elif-else statement using a chain of ternary operators. 

The equivalent if-elif-else statement would be:

One thing to consider before chaining together ternary statements is whether it makes the code more difficult to read. If so, then it’s probably not very Pythonic and you’d be better off with an if-elif-else statement.

3. How Do You Code a Ternary Operator Statement?

We can easily write a ternary expression in Python if we follow the general form shown below:

So, we start by choosing a condition to evaluate against. Then, we either return the true_value or the false_value  and then we assign this to results_var . 

4. Is the Ternary Operator Faster Than If-Else?

If we consider that a ternary operator is a single-line statement and an if-else statement is a block of code, then it makes sense that if-else will take longer to complete, which means that yes, the ternary operator is faster.

But, if we think about speed in terms of Big-O notation (if I’ve lost you here, don’t worry, head on over to our Big-O cheat sheet ), then they are in fact equally fast. How can this be? This is because conditional statements are viewed as constant time operations when the size of our problem grows very large.

So, the answer is both yes and no depending on the type of question you’re asking. 

Jenna Inouye currently works at Google and has been a full-stack developer for two decades, specializing in web application design and development. She is a tech expert with a B.S. in Information & Computer Science and MCITP certification. For the last eight years, she has worked as a news and feature writer focusing on technology and finance, with bylines in Udemy, SVG, The Gamer, Productivity Spot, and Spreadsheet Point.

Subscribe to our Newsletter for Articles, News, & Jobs.

Disclosure: Hackr.io is supported by its audience. When you purchase through links on our site, we may earn an affiliate commission.

In this article

• 10 Vital Python Concepts for Data Science
• 10 Common Python Mistakes in 2024 | Are You Making Them? Python Data Science Programming Skills
• GitHub Copilot vs Amazon CodeWhisperer | Who's Best in 2024? Artificial Intelligence (AI) Code Editors IDEs AI Tools

Please login to leave comments

Always be in the loop.

Get news once a week, and don't worry — no spam.

{{ errors }}

{{ message }}

• Help center
• We ❤️ Feedback
• Advertise / Partner
• Write for us
• Privacy Policy
• Cookie Policy
• Change Privacy Settings
• Disclosure Policy
• Terms and Conditions
• Refund Policy

Disclosure: This page may contain affliate links, meaning when you click the links and make a purchase, we receive a commission.

Learn Python Programming from Scratch

• Learn Python

Python Ternary Operator with Example

From learning to earning – Courses that prepare you for job - Enroll now

Python is among the most user-friendly computer programming languages with few grammatical complexities and is quickly becoming one of the world’s fastest-growing computer languages. A vibrant community of Python users and developers contributes to the language’s improvement and growth. Python has always been quite dynamic from its birth in 1991, and it is continually developing with time, with new upgrades being added and old features being discarded.

A Python developer’s priority should always be to write short, clean, efficient, and understandable Python code. Ternary operators, which allow for a more concise manner of writing conditional statements in Python, can be utilized to do this. It was added as an enhancement in Python 2.5.

Today’s topic is Python Ternary Operator. In addition, we will go through an example and syntax of the Ternary Operator in Python. We will also learn about before and nested Python Ternary Operators. Finally, we will go over how to implement Ternary operators in Python.

Introduction to Python Conditional Statements

In Python, conditional statements conduct alternative computations or actions based on whether a given Boolean constraint evaluates to true or false. The if…else statement is how you execute this type of decision-making in a Python program. It enables the execution of a statement or collection of statements conditionally based on the value of an expression.

Assume we are developing an application that determines whether a customer is entitled to a 30% discount at a medical store. If the buyer is 65 or older, a discount should be given; otherwise, no discount should be granted. This program could be written using an if…else expression.

What is Python Ternary Operator?

In the Python programming language, the Ternary Operator is a condition expression that allows developers to evaluate statements. The Ternary Operators perform an action based on whether the statement is True or False. As a result, these operators are shorter than a standard if-else statement.

Syntax of Python Ternary Operator with Example

Python’s ternary operators, as the name implies, require three operands to function. The Python ternary statement has the following syntax:

The three operands are as follows:

1. condition: A Boolean expression must be evaluated to determine whether it is true or false.

2. true_value: A value assigned if the condition is true.

3. false_value: A value to be assigned if the condition is false.

Ternary Operators are commonly used to determine the value of a variable. If the condition is True, the variable takes on the value “true value,” else it takes on the value “false value.”

Example for Ternary Operator Implementation

Let’s return to the earlier-mentioned example, where we wish to provide a consumer at the medical store a discount if they are 65 or older. Customers who are not 65 or older are not eligible for a discount.

Code and Output for if-else Implementation

To grasp the difference between the Python ternary operator and the if-else statement approach, let’s start with the if-else statement.

Output if 67 is the input:

Code and Output for Ternary Operator Implementation We can now use the syntax of the ternary expression to make this program much more compact.

Output if 78 is the input:

Enter Your Age : 78

Yay! 30% Discount!

Ways to implement Python Ternary Operator

Now that we understand how Python’s ternary operator works let’s look at how it pertains to Tuples, Dictionary, and Lambda.

Before we get there, let’s start with a simple program that finds the smaller of two user-input numbers. Using the ternary approach with Python’s Tuples, Dictionary, and Lambda functions helps to have a clear picture of what we want to achieve.

Here is a simple and easy Python program that uses the ternary operator method to find the smaller of two values.

Output if a = 78 and b = 56 is the input:

Code and Output for Python ternary operator with Tuples

Let’s look at how ternary conditions are applied to Tuples now. The syntax to remember when using the ternary operator with Tuples is:

(false_value,true_value)[condition]

Output if a = 74 and b = 86 is the input:

Code and Output for Python ternary operator with Dictionary

Let’s look at how ternary conditions are applied to the Dictionary data structure.

If [a<b] is True, the True key’s value will be written in this scenario. Otherwise, if the condition is False, the value of the False key is printed.

Output if a = 44 and b = 86 is the input:

Code and Output for Python ternary operator with the Lambda function

Surprisingly, using the Lambda function to build the ternary operator is more efficient than the other two techniques. This is because Lambda guarantees that just one expression will be evaluated. In the case of Tuple or Dictionary, however, both expressions are evaluated.

Output if a = 94 and b = 66 is the input:

Implementation of Nested Ternary Operators

The term “nested” ternaries is a bit misleading because ternaries are so easy to write in a straight line that you never need to nest them with indent levels at all. They just read from top to bottom in a straight line, returning a value whenever they come across a true condition or the fallback.

There is no nesting to parse if you write ternaries correctly. It’s difficult to get lost when you’re following a straight line. Instead, we should term them “chained ternaries.”

Let’s make things easy to understand through an easy example.

Output if n = 90 is the input:

Here, we check for the value of no (given by the user). If it falls shorter than 0, we print “Negative Number”; if its value equals 0, we print “Number is Zero.” Else, we print “Positive Number.” Take note of how we nested them.

Before the Birth of Ternary Operators

Before Ternary Operators were introduced, programmers used to use alternatives to the operators. Look at the example code below.

The program checks for two conditions, i.e., (a>b) and (a or b). Let’s understand both conditions one after another.

Condition 1: a>b

The condition will return “True” if the value of a>value of b, otherwise it returns “False.”

Condition 2: a or b

We already know that when “or” is applied to two numbers, it will always return the first number.

Now, this might look like b will never come as an answer. But don’t forget the “and” in between the two conditions. If a>b comes out to be “False,” then (a>b and a) comes out as “False,” and the value of b is returned as an answer.

Suppose we consider the value of “a” as 45 and “b” as 89. The first condition becomes “False” as 45<89. Then “False and a” becomes “False” along with this, the final condition “False or b” will return b as the answer (which is the larger value).

Limitations of Ternary Operators

Here are examples of the ternary operator’s restrictions, as stated below: 1. While Ternary Operators can replace the if-else statement, they are only valid for a single if-else statement.

2. Ternary Operators are not used for numerous if-else expressions.

3. Ternary Operator can be utilized as a nested if-else; however, as seen above, that’s only possible for a condition with three possible values.

Python Interview Questions on Ternary Operator

Q1. Is there a Ternary operator in Python?

Ans. Yes, it has been included in version 2.5. The syntax of the expression is as follows: an if condition else b. The condition is first assessed, and then exactly one of a or b is evaluated and returned based on the condition’s Boolean value.

Q2. What exactly is the Python ternary operator symbol?

Ans. Many C-like programming languages provide a ternary operator?:, which defines a conditional statement. This operator is recognized as the conditional operator in some languages. In Python, the ternary operator is simply a one-line version of the if-else expression. There is no such thing as a symbol.

The Python ternary operator provides a quick and easy way to build if-else sentences. It first analyses the supplied condition and then returns a value based on whether that condition is True or False. In the following post, we addressed Ternary Operator, one of Python’s most effective tools, which has decreased code size by replacing typical if-else expressions, resulting in better code readability. The various applications of Ternary operators and their syntax and examples have been thoroughly addressed.

Did we exceed your expectations? If Yes, share your valuable feedback on Google | Facebook

Tags: Limitations of Python Ternary Operators Python Ternary Operator Python Ternary Operators ways to implement Ternary Operator

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

Save my name, email, and website in this browser for the next time I comment.

• Online Python Compiler
• Hello World
• Console Operations
• Conditional Statements
• Loop Statements
• Builtin Functions
• Type Conversion

Collections

• Classes and Objects
• File Operations
• Global Variables
• Regular Expressions
• Multi-threading
• phonenumbers
• Breadcrumbs
• ► Python Examples
• ► ► Conditional Statements
• ► ► ► Python Ternary Operator
• Python Datatypes
• Python - Conditional Statments
• Python - If
• Python - If else
• Python - Elif
• Python - If AND
• Python - If OR
• Python - If NOT
• Python - Ternary Operator
• Python Loops

Python Ternary Operator

Syntax of ternary operator.

• A simple example for Ternary Operator
• Print statements in ternary operator
• Nested Ternary Operator

Python Ternary operator is used to select one of the two values based on a condition. It is a miniature of if-else statement that assigns one of the two values to a variable.

In this tutorial, we will learn how to use Ternary Operator in Python, with the help of examples.

The syntax of Ternary Operator in Python is

value_1 is selected if expression evaluates to True . Or if the expression evaluates to False , value_2 is selected.

You can either provide a value, variable, expression, or statement, for the value_1 and value_2 .

In the following examples, we will see how to use Ternary Operator in selection one of the two values based on a condition, or executing one of the two statements based on a condition. We shall take a step further and look into nested Ternary Operator as well.

1. A simple example for Ternary Operator

In this example, we find out the maximum of given two numbers, using ternary operator.

The ternary operator in the following program selects a or b based on the condition a>b evaluating to True or False respectively.

Python Program

Run the program. As a>b returns False, b is selected.

You may swap the values of a and b , and run the program. The condition would evaluate to True and a would be selected.

2. Print statements in ternary operator

In this example, we will write print statements in the ternary operator. Based on the return value of condition, Python executes one of the print statements.

Run the program. As a>b returns False, second print statement is executed.

This example demonstrates that you can run any Python function inside a Ternary Operator.

3. Nested Ternary Operator

You can nest a ternary operator in another statement with ternary operator.

In the following example, we shall use nested ternary operator and find the maximum of three numbers.

After the first else keyword, that is another ternary operator.

Change the values for a, b and c, and try running the nested ternary operator.

In this tutorial of Python Examples , we learned what Ternary Operator is in Python, how to use it in programs in different scenarios like basic example; executing statements inside Ternary Operator; nested Ternary Operator; etc., with the help of well detailed Python programs.

Related Tutorials

Python Numerical Methods

This notebook contains an excerpt from the Python Programming and Numerical Methods - A Guide for Engineers and Scientists , the content is also available at Berkeley Python Numerical Methods .

The copyright of the book belongs to Elsevier. We also have this interactive book online for a better learning experience. The code is released under the MIT license . If you find this content useful, please consider supporting the work on Elsevier or Amazon !

< 4.1 If-Else Statements | Contents | 4.3 Summary and Problems >

Ternary Operators ¶

Most programming languages have ternary operators , which usually known as conditional expressions . It provides a way that we can use one-line code to evaluate the first expression if the condition is true, otherwise it evaluates the second expression. Python has its way to implement the ternary operator, which can be constructed as below:

CONSTRUCTION : ternary operator in Python

EXAMPLE: Ternary operator

From the above example, we can see this one-line code is equivalent to the following block of codes.

Ternary operator provides a simple way for branching, and it can make our codes concise. Besides, in the next chapter, you will also see it commonly be used in list comprehensions, which is quite useful.

Python Ternary Operator – Conditional Operators in Python

You can use conditional operators in Python to execute code based on a predefined condition(s).

In this article, you'll learn how to use the ternary operator in Python. You'll see its syntax along with some practical examples.

What Is the Ternary Operator Used for in Python?

The ternary operator in Python is simply a shorter way of writing an if and if...else statements.

Here's what an if...else statement looks like in Python:

In the code above, we created a variable user_score with a value of 90.

We then printed either of two statements based on a predefined condition — if user_score > 50 .

So if the user_score variable is greater than 50, we print "Next level". If it's less than user_score , we print "Repeat level".

You can shorten the if...else statement using the ternary operator syntax.

Python Ternary Operator Example

In the last example, we saw how to use an if...else statement in Python.

You can shorten it using the ternary operator. Here's what the syntax looks like:

In the syntax above, option1 will be executed if the condition is true. If the condition is false then option2 will be executed.

In other words, the ternary operator is just a shorthand of the if and if...else statements. You can use it in just a single line of code.

Here's a more practical example:

In the code above, "Next level" will be printed out because the condition is true.

In this article, we talked about the ternary operator in Python. It's a shorter way of writing if and if...else statements.

You can use ternary operators to execute code based on predefined conditions.

Happy coding! I also write about Python on my blog .

ihechikara[dot]com

If you read this far, thank the author to show them you care. Say Thanks

Learn to code for free. freeCodeCamp's open source curriculum has helped more than 40,000 people get jobs as developers. Get started

Currently Reading :

Currently reading:

What are ternary operators in Python?

Python ternary operators - how to use them.

Ancil Eric D'Silva

Software Developer

Published on  Fri Mar 11 2022

In this short tutorial, let us look at how we can write code using the Python ternary operator. One can make their Python code more concise using the ternary operator.

Here, Python’s ternary or conditional operators are operators that evaluate something based on a condition being true or false. They are also known as conditional expressions . To further simplify it, ternary operators can be thought of as one-line versions of the if-else statements.

As the name suggests, Python’s ternary operators need three operands to run. The three operands are: - condition: A boolean expression that needs to evaluate whether true or false. - val_true: A value that is to be assigned if the condition evaluates to be true. - val_false: A value that is to be assigned if the condition evaluates to be false. When it’s all put together this is how it should look like: some_var = val_ true if [condition] else val_ false

The variable some_var that you see on the left side of the equal-to sign “=” ( assignment operator ) will be assigned either one of the following: - val_true if the boolean expression evaluates to be true. Or - val_false if the boolean expression evaluates to be false.

Simple example of the Python ternary operator in a program

Let’s write a simple Python program that helps us understand the ternary operator’s usage. To understand the difference between the Python ternary operator and the if-else statement method, let's first write the program using the if-else statement.

The program using the "if-else" method:

And here is the output if 20 is the input:

In this example, the if-else statement assigns “Yes, you can drive!” to the driving_permit variable if the age entered is greater than or equal to 18. Otherwise, it assigns Sorry, you can’t drive yet!” to driving_permit.

Now, to make this program a lot more concise, we can make use of the syntax of the ternary expression.

The program using the ternary operator method

In this statement, the left side of the assignment operator (=) is the variable driving_permit . The ternary operator evaluates the condition which is if int(your_age) > = 18 . If the result is true, then it returns the val_true , which in this case is “Yes, you can drive!” . Else it returns val_false , which is Sorry, you can’t drive yet!”

Python ternary operator with Tuples, Dictionary and Lambda

As we now have an understanding of how Python’s ternary operator works, let’s see how it applies with Tuples, Dictionary and Lambda. Before that, let’s begin with a simple program on finding the greatest of 2 numbers. It helps with having a clear picture of what we want to accomplish when we apply the ternary method with Python’s Tuples, Dictionary and Lambda function.

Sample program of Python ternary operator.

Here is a simple Python program where we find the greatest of 2 numbers using the ternary operator method.

If [x>y] is true it returns 1, so the element with 1 index will be printed. Otherwise if [x>y] is false it will return 0, so the element with 0 index will be printed.

Python ternary operator with Tuples

Let’s now see how ternary conditions are used with Tuples. The syntax to be considered during the usage of the ternary operator with Tuples is ( if _ check _ is _f alse, if _ check _ is _ true)[check]

Python ternary operator with Dictionary

Let’s now see how ternary conditions are used with the Dictionary data structure.

In this case, if [x > y] is True then the value of the True key will be printed. Else if [x>y] is False then the value of the False key will be printed

Python ternary operator with the Lambda function

Interestingly, implementing the ternary operator with the Lambda function is more efficient than the other two methods. This is because with Lambda we are assured that only one expression will be evaluated. But in the instance of Tuple or Dictionary, both the expressions are evaluated.

Closing thoughts

The Python ternary operator is a concise and simple way of implementing if-else statements. It first evaluates the given condition, then returns a specific value depending on whether that condition turns out to be True or False .

Related Blogs

Sets In Python

Harsh Pandey

Using Python to print variable in strings

Python Max function - All you need to know

How to convert Float to int in Python?

Python Try Except

Python OOPs Concepts

10 min read

Browse Flexiple's talent pool

Explore our network of top tech talent. Find the perfect match for your dream team.

• Programmers
• React Native
• Ruby on Rails

Python Booleans: Hidden Gems I Wish I Knew Sooner

Booleans might seem simple – just True or False – but they’re the backbone of decision-making in Python. They control the flow of your programs, from simple if-else statements to complex algorithms. Let’s dive into some often-overlooked aspects of Booleans that can significantly enhance your Python coding.

1. Truthiness and Falsiness: Beyond True and False

While True and False are the explicit Boolean values, Python expands this concept with “truthiness” and “falsiness.” Many objects in Python can be evaluated as either True or False in a Boolean context.

• Truthy values: Non-empty lists, tuples, dictionaries, strings, and non-zero numbers are considered truthy.
• Falsy values: Empty lists, tuples, dictionaries, strings, the number 0, and the special value None are considered falsy.

This concept is crucial for conditional statements. For instance, if my_list: will execute if my_list is not empty.

2. Boolean Operators: More Than Just and and or

We’re familiar with and and or , but Python offers not for negation. Additionally, you can combine these operators for complex conditions.

• not : Reverses the Boolean value of its operand.
• Operator precedence: not has higher precedence than and and or .

Example: if not (condition1 and condition2):

3. Short-circuiting Evaluation: Optimize Your Logic

Python uses short-circuiting evaluation for Boolean operators. This means that the second operand is only evaluated if necessary.

• and : If the first operand is False, the second operand is not evaluated.
• or : If the first operand is True, the second operand is not evaluated.

This can be used for efficiency, especially when the second operand is expensive to compute.

4. Ternary Operator: Concise Conditional Assignments

The ternary operator provides a shorthand way to assign a value based on a condition:

This can make your code more readable in certain cases.

5. Boolean Indexing: Filter Your Data Effectively

You can use Boolean values to index lists, tuples, and NumPy arrays. This is powerful for filtering data based on conditions.

2. Practical Examples of Booleans in Python

Truthiness and falsiness: user authentication.

Here, the authenticate_user function returns a Boolean value based on the provided credentials. The if statement then uses this Boolean to decide whether to grant access.

2. Boolean Operators: Data Validation

This example demonstrates how Boolean operators can be used to create logical conditions for data validation.

3. Short-circuiting Evaluation: File Handling

By checking if the file exists before attempting to open it, we avoid unnecessary FileNotFoundError exceptions. This is an example of how short-circuiting can improve performance.

4. Ternary Operator: Conditional Formatting

This concisely assigns a value to result_message based on the is_success Boolean.

5. Boolean Indexing: Data Filtering

This efficiently filters even numbers from the numbers array using Boolean indexing.

These examples highlight the versatility of Booleans in Python

3. Conclusion

While often overlooked, Booleans are the unsung heroes of Python programming. Their simplicity belies their immense power in controlling program flow, making decisions, and manipulating data. By understanding the nuances of truthiness, Boolean operators, short-circuiting, and advanced applications, you can significantly elevate your Python coding skills. So, the next time you’re crafting Python code, remember the humble Boolean: it could be the key to unlocking more efficient, elegant, and effective solutions.

We will contact you soon.

Eleftheria Drosopoulou

Related articles.

Explore These 20 Cool Python Scripts for Fun and Productivity!

Python string append example.

Appium Cheatsheet

How to use playwright for web scraping with python, can dovpanda democratize data analysis with pandas, [mega deal] the python 3 complete masterclass certification bundle (97%), how to check if a key exists in a dictionary in python: in, get(), and more, python vs java: the most important differences.

This site uses Akismet to reduce spam. Learn how your comment data is processed .

• DSA with JS - Self Paced
• JS Tutorial
• JS Exercise
• JS Interview Questions
• JS Operator
• JS Projects
• JS Examples
• JS Free JS Course
• JS A to Z Guide
• JS Formatter

How to Define an Array with Conditional Elements in JavaScript?

Sometime we may need to define an array with elements that depend on certain conditions. Such situation may occur when we have to dynamically generate arrays based on runtime logic such as including or excluding elements based on specific criteria. In this article, we’ll explore various ways to define arrays with conditional elements in JavaScript.

Following are the different approaches to defining an array with conditional elements in JavaScript:

Table of Content

Using the Ternary Operator

Using spread operator with conditional logic, using filter() method.

In this approach, we are using the ternary operator which has a compact syntax that evaluates a condition and returns one of two values depending on whether the condition is true or false. When defining an array we use the ternary operator to include or exclude elements based on a condition. If the condition is true, value1 is included in the array otherwise value2 is included.

Example: This example demonstrates using the ternary operator to include elements in an array based on a simple condition.

In this approach we are using the spread operator (…) . It expands an iterable (like an array) into individual elements. By combining it with conditional logic, we can spread elements into an array only when the condition is met.

Example: This example demonstrates using the spread operator to build an array conditionally.

For more complex conditions we can use the filter() method it can be used to include elements based on a function’s return value. This is particularly useful when dealing with arrays of objects or more intricate logic.

Example: This example demonstrates how to use filter() to create a new array that only includes even numbers from the original array.

Please Login to comment...

Similar reads.

• Web Technologies

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
• OverflowAI GenAI features for Teams
• OverflowAPI Train & fine-tune LLMs
• Labs The future of collective knowledge sharing
• About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

Python ternary operator and assignment in else

Ternary operator is very useful, why it does not work in this particular case:

I don't see nothing wrong here since the same thing without the ternary operator works:

• conditional-operator

• For this case, use a defaultdict. from collections import defaultdict; d = defaultdict(int); d[c] += 1 . –  RemcoGerlich Commented Jan 22, 2014 at 8:38
• @RemcoGerlich: Why simulate a Counter with a defaultdict like that, when you can just use a Counter ? –  abarnert Commented Jan 22, 2014 at 8:41
• @abarnert: Force of habit? I always remember defaultdict first, because it came before Counter and because it's more general. –  user2357112 Commented Jan 22, 2014 at 8:46
• @abarnert: thanks, I always forget how cool Counter is –  RemcoGerlich Commented Jan 22, 2014 at 10:01
• 2 Can we at least call it the conditional expression . It is a ternary operator, but so is the SQL BETWEEN ... AND ... expression. –  Martijn Pieters Commented Feb 22, 2014 at 19:49

2 Answers 2

The ternary operator works on expressions, not statements. Assignment is a statement. Use a regular if / else .

• 3 Or use defaultdict and d[c] += 1 . Or maybe d[c] = d.get(c, 0) + 1 . –  Blender Commented Jan 22, 2014 at 8:39
• 2 @Blender: Don't use defaultdict(int) to simulate a Counter . Just use Counter when you want one. –  abarnert Commented Jan 22, 2014 at 8:42
• Counter gets no respect, I tell ya. A girl called it the other day and said "Come over, there's nobody home." It went over, nobody was home. I tell ya, it just can't get no respect. –  abarnert Commented Jan 22, 2014 at 8:53

The correct way to write this would be:

• I think Blender's d.get(c, 0) is clearer (and also avoids lookup up c twice), but this works, and if the OP can understand it, that's good. –  abarnert Commented Jan 22, 2014 at 8:54

Your Answer

Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more

Sign up or log in

Post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged python python-2.7 dictionary conditional-operator or ask your own question .

• The Overflow Blog
• Scaling systems to manage all the metadata ABOUT the data
• Navigating cities of code with Norris Numbers
• Featured on Meta
• We've made changes to our Terms of Service & Privacy Policy - July 2024
• Bringing clarity to status tag usage on meta sites
• Tag hover experiment wrap-up and next steps

Hot Network Questions

• Birthday of combinatorial game product
• Large scale structure/Single galaxy simulation on GPU
• Why do individuals with revoked master’s/PhD degrees due to plagiarism or misconduct not return to retake them?
• Energy and force, the basic formula
• What was I thinking when I drew this diagram?
• Would several years of appointment as a lecturer hurt you when you decide to go for a tenure-track position later on?
• How does the Israeli administration of the Golan Heights affect its current non-Jewish population?
• Tiling a rectangle with one-sided P-pentominoes
• How to make a case based on factual evidence that my colleague's writing style for submitted manuscripts has got to be overhauled?
• Are the US or its European allies offering Iran anything in return for de-escalation?
• How can I obscure branding on the side of a pure white ceramic sink?
• A post-apocalyptic short story where very sick people from our future save people in our timeline that would be killed in plane crashes
• Why is "a black belt in Judo" a metonym?
• GNOME Shell on Wayland was skipped because of an unmet condition
• Reference Request: Suttas that address avijja (ignorance) with respect to anatta (non-self)
• Can you fur up floor joists (rather than replace) to meet load requirements?
• Relative pronouns that don't start the dependent clause
• Unstable output C++: running the same thing twice gives different output
• efficiently reverse EISH to HSIE
• Shifted accordingly
• Is there a limit to how much power could be transmitted wirelessly?
• Using elastic-net only for feature selection
• What does it mean to echo multiple strings into a UNIX pipe?
• Can I continue using technology after it is patented