Python Conditional Statements

In data science, raw data is inert—it's your program's ability to make decisions that transforms numbers into insights. Whether you're filtering datasets, validating inputs, or implementing business logic, conditional statements are the fundamental mechanism that gives your code the power to choose its path. Mastering them is not just about learning syntax; it's about structuring clear, efficient, and logical decision trees that can handle the messy, unpredictable nature of real-world data.

Understanding the if, elif, and else Workflow

At its core, a conditional statement asks a question. If the answer is True, the code executes a specific block. The simplest form uses only the if keyword.

temperature = 30
if temperature > 25:
    print("It's a warm day.")  # This line executes because 30 > 25 is True

The colon (:) and indentation (typically four spaces) are non-negotiable in Python; they define the code block that belongs to the if statement. To provide an alternative path when the condition is False, you add an else block.

data_point = -5
if data_point >= 0:
    print("Value is non-negative.")
else:
    print("Value is negative. Applying absolute value.")  # This path executes

For decisions with more than two possible outcomes, you chain conditions using elif (short for "else if"). Python evaluates each condition in order from top to bottom and executes the block for the first condition that evaluates to True.

score = 82
if score >= 90:
    grade = 'A'
elif score >= 80:  # Checked only if the first 'if' was False
    grade = 'B'    # This block executes
elif score >= 70:
    grade = 'C'
else:
    grade = 'F'
print(f"The grade is: {grade}")

In data workflows, this is essential for categorizing continuous variables, such as classifying customer spending as "low," "medium," or "high" tier.

Combining Conditions and Truthy/Falsy Evaluation

Real-world decisions often depend on multiple criteria. Python's logical operators—and, or, and not—allow you to build complex conditions.

age = 25
has_subscription = True
if age >= 18 and has_subscription:
    print("Access granted to premium content.")

The or operator requires only one condition to be True, while not inverts a Boolean value. You can use parentheses to control the order of evaluation, much like in arithmetic.

A powerful and sometimes subtle feature of Python is truthy and falsy evaluation. In conditional contexts, Python doesn't just check for the literal True or False. It evaluates whether an object is "truthy" (treated as True) or "falsy" (treated as False). Common falsy values include:

• None
• False
• Zero of any numeric type: 0, 0.0
• Empty sequences and collections: '', [], (), {}
• An empty pandas.DataFrame or numpy.array

All other values are typically truthy. This allows for concise, Pythonic checks.

user_input = ""  # An empty string is falsy
data_list = []   # An empty list is falsy

if not user_input:
    print("Warning: Input field is empty.")  # Executes

if data_list:
    print("Processing dataset...")
else:
    print("Dataset is empty. Loading defaults.")  # Executes

In data science, this is invaluable for checking if a list of results is populated, if a DataFrame has loaded correctly, or if a required function argument was provided.

Advanced Constructs: Nested Conditionals and Ternary Expressions

For highly complex decision logic, you can place conditionals inside other conditionals, creating nested conditionals. The key is maintaining strict, consistent indentation to define the hierarchy.

account_active = True
balance = 150
request = 200

if account_active:
    if request <= balance:  # This 'if' is nested inside the outer one
        print("Transaction approved.")
    else:
        print("Insufficient funds.")
else:
    print("Account is inactive.")

While powerful, deep nesting can harm readability. Often, combining conditions with and or using elif is a cleaner alternative.

For assigning one of two values based on a simple condition, Python offers a concise ternary expression (or conditional expression). Its syntax is: value_if_true if condition else value_if_false.

# Traditional way
value = -10
if value >= 0:
    category = "Non-negative"
else:
    category = "Negative"

# Using a ternary expression
category = "Non-negative" if value >= 0 else "Negative"

This is extremely useful for creating new columns in a DataFrame based on a condition or for inline value assignments within a list comprehension, keeping your code compact and expressive.

Best Practices for Clean Conditional Code

Writing conditionals is easy; writing readable and maintainable ones is a skill. Follow these principles to elevate your code:

1. Keep Conditions Simple and Readable: Avoid overly complex one-line conditions. If a condition is long, store parts of it in descriptive Boolean variables.

Hard to read

if (df['sales'].mean() > threshold and not df[df['region'] == 'North'].empty) or override_flag: pass

Better

issaleshigh = df['sales'].mean() > threshold hasnorthdata = not df[df['region'] == 'North'].empty if (issaleshigh and hasnorthdata) or override_flag: pass

1. Use if-elif Chains for Mutually Exclusive Paths: If only one outcome is possible, an if-elif-else chain is clearer than several independent if statements, as it explicitly signals the relationship between the checks.
2. Leverage Truthy/Falsy Checks Appropriately: Use if items: instead of if len(items) > 0:. It's more Pythonic and directly checks the property you care about—whether the object has content.
3. Consider Early Returns/Exits: In functions, checking for error conditions or simple cases at the start can simplify the rest of your logic by reducing indentation and cognitive load.

Common Pitfalls

Mistake 1: Using = (assignment) instead of == (comparison). This is a classic syntax error that can cause unexpected behavior.

# WRONG
if status = "active":  # SyntaxError: invalid syntax
    print("Running")

# CORRECT
if status == "active":
    print("Running")

Mistake 2: Assuming elif and else Catch Everything. An elif or else only catches cases where the preceding if/elif conditions were False. If your logic needs multiple independent checks, use separate if statements.

# This might not do what you intend
value = 10
if value > 5:
    print("Greater than 5")
elif value > 7:  # This line will NEVER execute for value=10.
    print("Greater than 7") # Why? Because the first if (value > 5) was True,
                            # so Python skips all following elif/else blocks.

Mistake 3: Overlooking Operator Precedence in Complex Conditions. The logical and operator has higher precedence than or. This can lead to logic errors.

# Ambiguous logic
if x > 5 or y < 10 and z == 0:  # Evaluates as: if x > 5 or (y < 10 and z == 0)
    pass

# Clearer logic with parentheses
if (x > 5 or y < 10) and z == 0:  # Different meaning!
    pass

Always use parentheses to make complex condition groupings explicit.

Mistake 4: Neglecting the None Sentinel. When checking if a variable is None, use is and is not instead of == and !=. This is because is checks for object identity, which is the correct way to test for None.

result = get_data()  # This function might return None or a DataFrame

# PREFERRED
if result is None:
    print("No data retrieved.")

# LESS IDIOMATIC
if result == None:
    print("No data retrieved.")

Summary

• Conditional statements (if, elif, else) are the backbone of decision-making in Python, directing program flow based on Boolean logic.
• Logical operators (and, or, not) combine simple conditions, while truthy/falsy evaluation allows you to write concise checks for empty data structures or missing values—a daily task in data science.
• For embedding simple conditionals within expressions or assignments, the ternary operator (x if cond else y) provides a compact syntax.
• Avoid common errors like misusing assignment (=), misunderstanding elif chains, and incorrect operator precedence by writing clear conditions and using parentheses.
• Prioritize readability by breaking complex conditions into named Boolean variables, using Pythonic truthy checks, and structuring your logic to minimize deep nesting. Clean conditional code is not just correct; it's a form of clear communication.