# Python One-Line If Else Statement

![Python One-Line If Else Statement](https://raw.githubusercontent.com/mateenkiani/milddev-resources/main/images/1754504890913_python-one-line-if-else.webp)

## Introduction
Python makes it easy to write simple conditionals in a single line using its ternary expression. This compact form helps keep your code concise, especially for quick assignments or return values in functions. But how do you balance readability with brevity when packing logic into one line?

By mastering Python's `a if condition else b` syntax, you can write clean, concise code without confusing your teammates. Understanding when—and when not—to use it will help you make informed decisions and avoid unreadable one-liners.

## Basic Syntax
The core form of Python's one-line if-else (often called the ternary operator) is:

```python
value = X if condition else Y
```

- `condition` is evaluated first.
- If `condition` is true, `X` is returned; otherwise `Y`.

Example:

```python
score = 85
status = "Pass" if score >= 60 else "Fail"
print(status)  # Pass
```

> Tip: Always put the expression for `True` first to avoid confusion.

## Nested Conditionals
You can nest these expressions, but readability can suffer quickly.

```python
x, y = 5, 10
result = (
    "both equal" if x == y
    else "x greater" if x > y
    else "y greater"
)
print(result)  # y greater
```

Using nested ternaries can be handy for short checks, but switch to `if/elif/else` blocks once it gets too dense.

## In List Comprehensions
One-liners shine in list comprehensions for quick transformations:

```python
numbers = [-2, 0, 3, 7]
labels = ["Positive" if n > 0 else ("Zero" if n == 0 else "Negative") for n in numbers]
print(labels)  # ['Negative', 'Zero', 'Positive', 'Positive']
```

> Tip: For more complex dict or object transformations, see how to [convert Python objects to dict](https://milddev.com/converting-python-objects-to-dict) for structured output.

## In Lambda Functions
Lambdas must be single expressions, so ternary ops are perfect:

```python
max_val = lambda a, b: a if a > b else b
print(max_val(4, 9))  # 9
```

This lets you write inline callbacks or short utilities without full `def` syntax.

## Common Pitfalls
- Over-nesting leads to unreadable code.
- Long expressions defeat the purpose of conciseness.
- Avoid mixing side-effects (like I/O) in one-liners.

```python
# Hard to read, avoid this:
print("Even") if x % 2 == 0 else print("Odd")
```

Use a normal `if` block if your logic spans multiple actions.

## Best Practices
- Use one-line if-else only for simple assignments or returns.
- Keep the condition and expressions short.
- Prefer multiline `if` blocks for complex logic.

> For error-handling one-liners, check out [Python try without except](https://milddev.com/python-try-without-except).

## Conclusion
Python’s one-line if-else expression is a powerful tool for writing concise, readable code when used wisely. It shines in assignments, returns, comprehensions, and lambdas. However, always weigh brevity against clarity—complex nested or side-effect-laden one-liners can hinder maintenance and comprehension. By following best practices and keeping expressions short, you can leverage Python’s ternary operator to write clean, efficient, and understandable code.