What is If() Statement in Python?

Python if statement is a fundamental control structure that allows you to execute specific blocks of code based on certain conditions. With Python if statement, you can make your program decide which path to follow, leading to more dynamic and flexible code. Let’s dive into the details of how if Elif and Else statements works in Python and explore various aspects of their usage.

Python If Syntax and Structure

The syntax of Python if statement follows a specific structure:

if condition:
# Code block to execute when the condition is True

Here, condition represents a logical expression that evaluates to either True or False. If the condition is True, the code block indented under Python if statement is executed; otherwise, it is skipped.

How If Statements Works in Python?

To better understand how Python if statements works, let’s consider an example. Suppose we want to check if a user’s age is greater than or equal to 18 before granting access to a restricted area of a website:

In this example, the if statement checks if the user_age is greater than or equal to 18. If the condition is True, the code block indented under the if statement is executed, resulting in the two print statements being displayed.

Python If Comparison Operators and Logical Expressions

In Python, you can use various comparison operators and logical expressions within if statements to create complex conditions. These operators include:

1. == for equality
2. != for inequality
3. < for less than
4. > for greater than
5. <= for less than or equal to
6. >= for greater than or equal to

You can also combine conditions using logical operators such as and, or, and not. Let’s see an example that demonstrates the usage of comparison operators and logical expressions:

In this example, Python if statement checks if num is greater than 10 and less than or equal to 20. If the condition is True, the corresponding code block is executed.

Using If-Else Statements for Alternative Execution Paths

In addition to the basic if statement, Python also provides the else clause to handle alternative execution paths. The else block is executed when the condition in the if statement evaluates to False. Let’s consider an example to illustrate the usage of if-else statements:

In this example, the if statement checks if num is divisible by 2 (i.e., an even number). If the condition is True, the first code block is executed. Otherwise, the else block is executed, indicating that the number is odd.

Nested If Statements: Adding Complexity to Conditionals

Python allows nesting if statements within other if statements, providing more flexibility in handling complex conditions. Let’s explore an example of nested if statements:

In this example, the outer Python if statement checks if the age is greater than or equal to 18. If the condition is True, the first code block is executed. Inside that code block, there is another if statement to check if the name is Alice. Depending on the condition, the appropriate message is printed:

What is a Elif statement in Python?

In addition to the basic if and else statements, Python also provides the elif statement to handle multiple conditions. Python elif statement allows you to specify additional conditions to check if the previous conditions in the if statement are False. This provides a way to create a chain of conditions and execute the corresponding code block that matches the first True condition. Let’s explore the usage and benefits of the elif statement.

Syntax and Structure of Elif Statements

The syntax of an elif statement in Python is as follows:

if condition1:
# Code block to execute when condition1 is True
elif condition2:
# Code block to execute when condition2 is True
elif condition3:
# Code block to execute when condition3 is True
...
else:
# Code block to execute when all conditions are False

Here, each elif statement is followed by a condition, and the code block under the first True condition is executed. If none of the conditions are True, the code block under the else statement is executed as a fallback.

Using Elif Statements

To illustrate the usage of elif statements, let’s consider an example where we want to categorize a user’s age into different groups: child, teenager, adult, or senior.

In this example, the elif statements provide additional conditions to check if the previous conditions are False. Based on the user’s age, the corresponding code block is executed. Since the user’s age is 35, the condition user_age < 65 is True, and the code block under that condition is executed:

Chained Comparisons: Simplifying If Statements

Python allows chaining multiple comparisons together using logical operators to simplify if statements. By combining comparisons with logical operators such as and or or, you can create more concise and readable code. Let’s explore how to use chained comparisons in if statements.

Syntax and Structure of Chained Comparisons

The syntax of chained comparisons in Python is as follows:

if lower_bound < variable < upper_bound:
# Code block to execute when the condition is True

Here, lower_bound and upper_bound represent the lower and upper limits of the range, and variable is the variable being compared. If the variable falls within the specified range, the code block is executed.

Let’s consider an example where we want to check if a user’s age is between 18 and 30 (inclusive):

In this example, the chained comparison 18 <= user_age <= 30 checks if user_age is greater than or equal to 18 and less than or equal to 30. If the condition is True, the corresponding code block is executed:

Python If and Short Circuit Evaluation

Short-circuit evaluation is a concept that allows for the optimization of Python if statements involving logical operators. When evaluating a compound condition using logical operators and and or, Python employs short-circuit evaluation to minimize unnecessary evaluations. Let’s understand how short-circuit evaluation works and its benefits.

I. Short Circuit Evaluation with ‘and’ Operator

When using the and operator, Python evaluates the conditions from left to right. If any condition is False, the subsequent conditions are not evaluated because the entire expression will be False regardless of their results. This allows for skipping unnecessary evaluations and improving performance.

Consider the following example where we want to check if a number is positive and divisible by 2:

In this example, if the number is negative, the condition number > 0 is False, and the subsequent condition number % 2 == 0 is not evaluated. Since the first condition is False, the entire expression will be False, and the code block under the else statement is executed:

II. Short Circuit Evaluation with ‘or’ Operator

Similar to the and operator, the or operator also employs short-circuit evaluation. Python evaluates the conditions from left to right, and if any condition is True, the subsequent conditions are not evaluated because the entire expression will be True regardless of their results. This optimization helps improve performance by avoiding unnecessary evaluations.

Consider the following example where we want to check if a user has either a premium subscription or an admin role:

Above, if the subscription is premium, the condition subscription == "premium" is True, and the subsequent condition user_role == "admin" is not evaluated. Since the first condition is True, the entire expression will be True, and the code block under Python if statement is executed:

Python If and Ternary Operators

In Python, ternary operators provide a concise way to write conditional expressions. Ternary operators allow you to evaluate a condition and choose one of two expressions to execute based on the result. They are particularly useful when you need to assign a value or choose between two options in a single line of code. Let’s explore how ternary operators work and how they can simplify your conditional statements.

Syntax and Structure

expression_if_true if condition else expression_if_false

Here, the condition is evaluated, and if it is True, the expression_if_true is executed. If the condition is False, the expression_if_false is executed. The result of the entire expression is the value of the executed expression.

Using Ternary Operators with If

Let’s consider an example where we want to determine if a number is positive or negative using a ternary operator:

In this example, the condition number > 0 is evaluated. Since the number is negative, the condition is False, and the expression Negative is executed. The value of the expression Negative is then assigned to the variable result, which is printed as the output:

Ternary operators can also be used within larger expressions or assignments:

Here, the ternary operator is used to determine the maximum value between x and y. The expression x if x > y else y evaluates to the value of x if x is greater than y, otherwise it evaluates to the value of y. The resulting maximum value is then assigned to the variable max_value and printed as the output:

Python Truthiness and Falsy Values

In Python, condition evaluation relies on the concept of truthiness and falsy values. Understanding how truthiness works is crucial for writing effective conditional statements. Let’s learn truthiness and falsy values and see how they influence condition evaluation.

What is truthy value and falsy value?

Truthy values and falsy values are terms used to describe the evaluation of values in a boolean context. In Python, every value has an inherent truthiness or falsiness associated with it.

A truthy value is a value that evaluates to true in a boolean context. It represents something that is considered true or non-empty. For example, the boolean value True is truthy, as well as non-zero integers, non-empty strings, non-empty lists, and any other value that is not explicitly considered falsy.

On the other hand, a falsy value is a value that evaluates to false in a boolean context. It represents something that is considered false or empty. In Python, the following values are considered falsy:

• False: The boolean value False itself.
• None: The special value representing the absence of a value.
• 0: The integer zero.
• 0.0: The floating-point zero.
• '': The empty string.
• []: The empty list.
• (): The empty tuple.
• {}: The empty dictionary.
• set(): The empty set.

Any other value not listed above is considered truthy. Let’s consider a few examples to understand how truthiness affects condition evaluation:

In this example, the variable value is assigned the value 10, which is a non-zero integer. Since non-zero integers are considered truthy, the condition if value evaluates to True, and the corresponding block of code is executed:

Now let’s consider another example:

In this case, the variable value is assigned an empty list []. Since empty lists are considered falsy, the condition if value evaluates to False, and the else block is executed.

Avoiding Common Mistakes and Pitfalls in If Statement

While working with Python if statements, there are some common mistakes and pitfalls that you may encounter. Being aware of these pitfalls can help you write more robust and error-free code. Let’s explore some of these common mistakes:

I. Forgetting to use a colon after the if statement

In Python, it is important to include a colon : at the end of the if statement. This colon indicates the start of a new block of code that will be executed if the condition is true. Forgetting the colon will result in a syntax error.

Incorrect Example:

Correct Example:

II. Misplacing indentation

Python uses indentation to define blocks of code. It is crucial to ensure that the code inside the if statement is indented properly. Incorrect indentation can lead to unexpected results or syntax errors.

Incorrect Example:

Correct Example:

III. Mixing up assignment and equality operators

One common mistake is using the assignment operator = instead of the equality operator == when checking conditions. This mistake can lead to unintended consequences and logical errors in your code.

Incorrect Example:

Correct Example:

Using the wrong logical operator

When using multiple conditions in an if statement, it’s important to choose the correct logical operator to combine them. Using the wrong operator can lead to incorrect results.

Incorrect Example:

Correct Example:

Neglecting to consider edge cases

It’s important to consider all possible scenarios and edge cases when writing Python if statements. Neglecting to account for edge cases can result in unexpected behavior or errors.

For example, if you’re comparing floating-point numbers, be cautious of floating-point precision issues. Instead of checking for exact equality, consider using tolerance or rounding techniques to handle the comparisons.

Additionally, consider the order in which conditions are evaluated. If there are multiple conditions, ensure that they are evaluated in the correct order to avoid logical errors.

By being aware of these common mistakes and pitfalls, you can write more reliable and bug-free code when using Python if statements. It’s always a good practice to thoroughly test your code and handle all possible scenarios to ensure its correctness and robustness.

By mastering the usage of Python if statements and understanding these concepts, you can write more efficient and expressive Python code. So keep practicing and exploring different scenarios to enhance your programming skills. Happy coding!