Conditional Expressions: Concise One-Liner Implementation of if-else in Python

In Python programming, we often need to decide the choice or operation of a value based on conditional judgments. The most basic approach is to use the if-else statement, but when we only need a simple logic like “return A if the condition is met, otherwise return B”, Python provides a more concise way to write it—the conditional expression (also known as the ternary operator). It allows you to complete the work that traditional if-else requires in multiple lines with just one line of code, making the code more compact.

一、Limitations of Traditional `if-else`¶

Let’s first review the traditional if-else syntax. For example, to determine if a number is odd or even:

num = 7
if num % 2 == 0:
    result = "偶数"
else:
    result = "奇数"
print(result)  # Output: 奇数

Here, two lines of code are used to complete the judgment. Although the logic is clear, the code volume seems redundant for simple binary choice scenarios.

二、Syntax of Conditional Expressions¶

The format of a conditional expression is very simple, structured as:
Expression1 if Condition else Expression2

If the Condition is True, the value of Expression1 is returned;
If the Condition is False, the value of Expression2 is returned.

Rewriting the above example with a conditional expression:

num = 7
result = "偶数" if num % 2 == 0 else "奇数"
print(result)  # Output: 奇数

A single line of code completes the same logic as the traditional if-else, which is very concise!

三、Basic Usage Examples¶

1. Simple Binary Choice Judgment¶

Judge whether a score is passing (with 60 as the passing threshold):

score = 55
result = "及格" if score >= 60 else "不及格"
print(result)  # Output: 不及格

2. Nested Conditional Expressions (Multi-condition Judgment)¶

If multiple conditions need to be judged (e.g., “excellent”, “passing”, “failing”), nested conditional expressions can be used. Note that nested conditional expressions are judged sequentially, and the next condition is entered only if the previous condition is not met:

score = 85
result = "优秀" if score >= 90 else "及格" if score >= 60 else "不及格"
print(result)  # Output: 及格

First, check score >= 90? 85 is not satisfied, so move to the next condition;
Then check score >= 60? 85 is satisfied, so return “及格”.

四、Why Use Conditional Expressions?¶

Concise Code: Reduces indentation and lines, making the logic more compact;
Suitable for Small Logic: Only used for simple “binary choice” or “multi-condition nesting” (no more than 2-3 levels);
Improved Readability: For simple judgments, one line of code is more intuitive than multi-line indentation.

五、Precautions¶

Can Only Return Values, Not Execute Statements: A conditional expression is an “expression”, not a “statement”, so it cannot contain assignments, print operations, etc. For example:

   # Error example: Conditional expressions cannot contain assignment statements
   x = 5
   result = (x if x > 0 else y = 0)  # Syntax error!

Avoid Over-Nesting: If there are more than 3 levels of nesting (e.g., multiple if-else stacks), readability decreases. In such cases, the traditional if-elif-else structure is recommended:

   # Use traditional if-elif-else for complex conditions
   score = 75
   if score >= 90:
       result = "优秀"
   elif score >= 60:
       result = "及格"
   else:
       result = "不及格"

Priority Issue: The operation priority of conditional expressions is higher than that of ordinary if-else. It is recommended to use parentheses to clarify the logic during operations. For example:

   a, b = 3, 5
   # Correct: First judge a > b, then judge c > d (if written as a > b else c > d, it may be misunderstood)
   result = a if a > b else c if c > d else d

六、Summary¶

A conditional expression is a “syntactic sugar” in Python, which implements simple binary choice logic in one line of code, making the code more concise. Remember: Use conditional expressions for simple logic and traditional if-elif-else for complex multi-branch scenarios. This ensures both code conciseness and readability. Try using conditional expressions to optimize small logic, and your code will be cleaner!