# Using “if else” in a List Comprehension

How to use if-else in a list comprehension in Python. Python’s list comprehensions are a concise and elegant way to create lists by performing operations on existing iterables. They offer a more readable and expressive alternative to traditional for loops. While you might be familiar with basic list comprehensions, did you know you can also include conditional statements, such as “if” and “else,” within them?

In this article, we’ll explore Python’s list comprehensions with “if else” statements. We’ll cover the basics of list comprehensions and their efficiency. We’ll also dive into using conditional statements for concise and conditional operations.

## 1. Quick Examples – if/else in a List Comprehension

In these Quick Examples section, we’re providing brief glimpses of using “if/else” statements in list comprehensions, and we’ll explore each concept in detail shortly.

``````
# Quick Examples - if/else in a list comprehension
my_list = [1, 2, 3, 4, 5]
even_odd_list = ['Even' if x % 2 == 0 else 'Odd' for x in my_list]

# List Comprehension and if/else Statement
squared_list = [x**2 for x in my_list]

# if/else in List Comprehension
pass_fail_labels = ['Pass' if score >= 70 else 'Fail' for score in my_list]

# Using Only "if" Statement in a List Comprehension
odd_numbers = [x for x in my_list if x % 2 != 0]

# Multiple "if/else" in List Comprehension
categorized_numbers = ['Positive' if x > 0 else 'Negative' if x  0 else x for x in row] for row in nested_list]
``````

## 2. List Comprehension and if/else Statement

A list comprehension is a compact way to generate a new list by applying a specific operation to each element of an iterable. It is Python’s way of performing concise and efficient operations on iterable objects, such as lists, tuples, or ranges. It offers a good alternative to traditional loops, allowing you to create new lists by applying an expression to each item in an existing iterable.

Syntax of List Comprehension:

``````# Syntax of List Comprehension
new_list = [expression for item in iterable]``````
• `new_list`: The resultant list.
• `expression`: The operation to apply to each item.
• `item`: A variable representing an element from the iterable.
• `iterable`: The source collection for iteration.

### 2.1 Example of List Comprehension

Let’s illustrate the power of list comprehension using a simple example:

``````
# Example of List Comprehension
my_list = [1, 2, 3, 4, 5]

# Create a new list with squared values from my_list
squared_list = [x**2 for x in my_list]

print(squared_list)

# Output:
# [1, 4, 9, 16, 25]
``````

The `if/else` statement is fundamental for controlling program flow and executing different actions depending on whether a condition is met.

Consider this basic structure of an `if/else` statement:

`````` # Syntax of if/else condition
if condition:
# Code to execute if the condition is True
else:
# Code to execute if the condition is False
``````

By integrating `if/else` statements into list comprehensions, we can perform conditional operations while constructing lists with remarkable brevity.

### 2.2 Example of if/else in List Comprehension

`````` # Even odd Example with List Comprehension
my_list = [1, 2, 3, 4, 5]

# Create a new list with "Even" for even numbers and "Odd" for odd numbers
even_odd_list = ['Even' if x % 2 == 0 else 'Odd' for x in my_list]

print(even_odd_list)
``````

## 3. if/else in List Comprehension

List comprehensions combined with if/else statements offer the best tool for flexible data manipulation in Python. The syntax of `if/else` statements is a bit different inside the list comprehension so before diving into practical examples, let’s start with the fundamental syntax of incorporating `if/else` within list comprehensions.

### 3.1 General Syntax of if/else in List Comprehension

As mentioned above the syntax of if/else is completely different within the list comprehension. There is no indentation needed inside the list comprehension. See the following general syntax of if/else in list comprehension.

`````` # Syntax of if/else within List Comprehension
new_list = [result if condition else alternative_result for item in iterable]
``````
• `new_list`: The resulting list.
• `result`: The outcome when the condition is met.
• `alternative_result`: The outcome when the condition is not met.
• `condition`: The rule or check that determines whether to use the result or the alternative_result.
• `item`: Represents an element from the iterable.
• `iterable`: The source collection for iteration.

### 3.2 Example

Suppose you have a list of exam scores, and you want to classify each score as “Pass” if it’s above a certain threshold, and “Fail” otherwise. This task can be elegantly achieved with if/else in a list comprehension:

`````` # Example Using if/else in List Comprehension
my_list = [75, 88, 62, 95, 42]

# Categorize scores as "Pass" or "Fail" based on a threshold
pass_fail_labels = ['Pass' if score >= 70 else 'Fail' for score in my_list]

print(pass_fail_labels)
# Output:
# ['Pass', 'Pass', 'Fail', 'Pass', 'Fail']
``````

## 4. Using Only “if” Statement in a List Comprehension

It is not always necessary to use both the “if” and “else” blocks. While list comprehensions often make use of both “if” and “else” statements for conditional operations, there are situations where you can achieve the desired results using only the “if” statement.

In many cases, you may find that you can simplify your list comprehension by omitting the “else” clause when the goal is to include or exclude items from the resulting list based on a condition.

### 4.1 Example

Suppose you have a list of numbers, and you want to create a new list containing only the odd numbers. Using just the “if” statement, you can accomplish this:

`````` # Exanoke Using only "if" statement
my_list = [1, 2, 3, 4, 5, 6]

# Create a new list with only odd numbers
odd_numbers = [x for x in my_list if x % 2 != 0]

print(odd_numbers)

# Output:
# [1, 3, 5]
``````

### 4.2 Example

Consider a scenario where you have a list of mixed numeric values, and you want to generate a new list containing only the positive numbers. Here’s how you can achieve this using only the “if” statement:

`````` # Example Using only if Statement
my_list = [1, -2, 3.5, -4, 5, -6]

# Create a new list with only positive values
positive_values = [x for x in my_list if x > 0]

print(positive_values)
# Output:
# [1, 3.5, 5]
``````

## 5. Mulitple if/else in List Comprehension

List comprehensions in Python provide remarkable flexibility when it comes to applying multiple conditions to filter, transform, or customize elements in an iterable. By combining multiple “if” and “else” clauses within a single list comprehension, you can create intricate logic that handles various scenarios with elegance and efficiency.

In Python, you can employ the `if` and `else` statements sequentially within a list comprehension to evaluate different conditions for each element in the source iterable. This sequential evaluation allows you to create complex filtering or transformation logic in a concise and readable manner.

A general structure to demonstrate the use of multiple “if” and “else” conditions within a list comprehension:

`````` # syntax of multiple if/else statement
new_list = [
expression_if_condition_1 if condition_1 else expression_if_condition_2 if condition_2 else expression_if_no_condition
for item in iterable
]
``````

Remember no indentation is required when using if/else inside the list comprehension.

### 5.1 Example of Using Multiple if/else

Imagine you have a list of numbers, and you want to categorize them into three groups: “Positive,” “Negative,” and “Zero.” You can use multiple conditions to accomplish this task efficiently:

`````` # Example of using multiple if/else
my_list= [3, -1, 0, 5]

# Categorize numbers as "Positive," "Negative," or "Zero"
categorized_numbers = [
'Positive' if x > 0 else 'Negative' if x < 0 else 'Zero'
for x in my_list
]

print(categorized_numbers)

# Output:
# ['Positive', 'Negative', 'Zero', 'Positive']
``````

## 6. Nested List Comprehensions with “if/else”

A nested list comprehension is essentially a list comprehension within another list comprehension. This technique allows you to create lists of lists and apply operations or conditions at multiple levels, providing a structured way to handle multidimensional data.

Suppose you have a matrix represented as a list of lists, and you want to create a new matrix where each element is squared if it’s positive and left unchanged if it’s negative or zero. Nested list comprehensions with “if/else” statements provide an elegant solution:

`````` # Using if/else statement in nested list comprehension
nested_list = [
[1, -2, 3],
[-4, 0, 5],
[6, -7, 8]
]

# Create a new matrix with squared positive values
squared_matrix = [
[x**2 if x > 0 else x for x in row]
for row in nested_list
]

for row in squared_matrix:
print(row)

# Output:
# [1, -2, 9]
# [-4, 0, 25]
# [36, -7, 64]
``````

## 7. Summary and Conclusion:

In this article, we’ve explored the “if/else” statements within list comprehension in Python. We discussed the basics of list comprehensions, highlighting their efficiency and readability. We also showcased scenarios where using only the “if” statement simplifies code. Furthermore, we explained how to employ multiple “if/else” conditions for intricate data processing. If you have any questions or need further clarification, please feel free to leave them in the comment section below.

### AlixaProDev

I am an astute software engineer with extensive 3+ years of experience in developing full-stack web applications. My skillets include building backend services for different databases. Mainly I work with Python, Flask, Django, and FastAPIs. Being Python Specialist, I have worked with Numpy, Pandas, and other Python Libraries to build tools that make ETL normalization easier. 