Conditional Logic: If, Elif, and Else

1. The Anatomy of a Decision: if, else, and elif

At its most basic, a conditional statement checks if a condition is true and executes a block of code if it is. The structure is simple, but the rules, especially regarding indentation, are strict and crucial to how Python interprets your code.

We will start with the fundamental if statement, then add else to handle the alternative case, and finally use elif to manage multiple, sequential conditions.

Let's recap the key points from the video with an example relevant to market analysis. Imagine you're classifying a company based on its annual revenue.

revenue = 750_000_000  # A company with $750M in revenue

if revenue > 1_000_000_000:
    print("Classification: Large-Cap")
elif revenue > 50_000_000:
    print("Classification: Mid-Cap")
else:
    print("Classification: Small-Cap")




# Output: Classification: Mid-Cap

Here's how Python processes this:

1. if check: Is revenue > 1_000_000_000? No, 750_000_000 is not greater than 1_000_000_000. Python skips the first print statement.
2. elif check: Is revenue > 50_000_000? Yes, 750_000_000 is greater than 50_000_000. Python executes the code in this block, printing "Classification: Mid-Cap".
3. Execution stops: Because a condition was met, Python skips the rest of the chain, including the else block.

This sequential, one-and-done logic is what makes if-elif-else so efficient for handling a series of checks. The following diagram illustrates this flow for three different input values.

2. Crafting Complex Conditions

Real-world business rules are rarely simple. You often need to check multiple criteria simultaneously. For instance, a "high-potential market" might be defined by both high growth and a large size. In the previous lesson, you learned about the logical operators and, or, and not. Now, we'll put them to work inside our if statements.

• and: Requires all conditions to be True.
• or: Requires at least one condition to be True.
• not: Inverts a condition (from True to False or vice-versa).

Consider a practical application in investment screening. An analyst might be looking for companies that have high income or good credit, but must not be a startup (let's assume startups are tracked by a is_startup flag).

high_income = False
good_credit = True
is_startup = False

if (high_income or good_credit) and not is_startup:
    print("Eligible for further analysis.")
else:
    print("Not eligible.")




# Output: Eligible for further analysis.

In this case, (high_income or good_credit) evaluates to True because good_credit is True. not is_startup also evaluates to True because is_startup is False. Since both sides of the and are True, the overall condition is met.

3. Hands-on Challenge: Classifying a Number

It's time to apply what you've learned. The following exercise requires you to combine if-elif-else logic with multiple conditions using logical operators. It also involves the modulo operator (%) for checking divisibility, which we touched upon in the last lesson.

Here is the code that solves the challenge, which you can also find in the article.

4. Advanced Conditional Techniques

While if-elif-else forms the core of conditional logic, Python offers a few more concise and powerful ways to write decision-making code.

Nested if Statements

You can place if statements inside other if statements. This is called nesting and is useful for creating more granular logic. For example, after identifying a "Pass" grade, you might want to further classify it.

Chaining Comparison Operators

Python allows you to write range checks in a way that is very similar to standard mathematical notation, making your code clean and intuitive.

Instead of writing if age >= 18 and age < 65:, you can write:
if 18 <= age < 65:

This more readable style is preferred by Python developers.

The Ternary Operator

For simple if-else assignments, you can use a compact, one-line syntax called the ternary operator.

Instead of this:

if score >= 60:
    result = "Pass"
else:
    result = "Fail"

You can write this:

result = "Pass" if score >= 60 else "Fail"

This is read almost like a sentence: "result is 'Pass' if score is 60 or more, else it's 'Fail'."

Conclusion

In this lesson, you've gained a crucial skill: the ability to make your programs think. You can now write code that responds to different inputs and conditions, a fundamental requirement for any form of automation or analysis.

Here are your key takeaways:

• The if-elif-else structure allows you to execute different code blocks based on a series of conditions.
• Indentation is not just for style; it is mandatory Python syntax that defines which code belongs to which conditional block.
• Logical operators (and, or, not) are used to create complex conditions that reflect nuanced business rules.
• Python evaluates conditions sequentially and uses short-circuiting for efficiency.
• Advanced techniques like nested ifs, chained comparisons, and the ternary operator can make your code more powerful and readable.

So far, we have learned to make a single decision. But what if you need to perform an action or check a condition for every item in a list of companies or every data point in a market survey? In our next lesson, we will explore loops, which allow you to execute code repeatedly, unlocking the ability to process large datasets efficiently.