List Comprehension in Python – Syntax & Examples

Introduction

Python is known for its clean and readable syntax. One of the features that makes Python powerful and concise is List Comprehension. It provides a shorter and more elegant way to create lists compared to traditional loops.

When working with lists, developers often need to create new lists based on existing data. Using a for loop for every such task can make the code longer and less readable. List comprehension solves this problem by allowing you to create and modify lists in a single line of code.

What is List Comprehension in Python?

List Comprehension is a concise way to create a new list from an existing iterable such as a list, tuple, string, or range.

Instead of using multiple lines of code with loops, list comprehension allows you to generate a list in a single expression.

Traditional Method

numbers = []
for i in range(5):
    numbers.append(i)
print(numbers)

Output:

Using List Comprehension

numbers = [i for i in range(5)]
print(numbers)

Output:

Both approaches produce the same result, but list comprehension is shorter and easier to read.

Why Use List Comprehension?

List comprehension offers several benefits:

• Reduces code length
• Improves readability
• Faster than traditional loops in many cases
• Makes data transformation easier
• Simplifies filtering operations
• Widely used in professional Python projects

Syntax

The basic syntax is:

[expression for item in iterable]

Components

• expression → Value to be added to the new list
• item → Current element from the iterable
• iterable → Source of data

Example:

numbers = [x for x in range(5)]
print(numbers)

Output:

Creating a List Using List Comprehension

Example:

squares = [x * x for x in range(1, 6)]
print(squares)

Output:

Here:

• range(1, 6) generates numbers from 1 to 5.
• x * x calculates the square of each number.
• The results are stored in a new list.

List Comprehension with Conditions

You can add conditions to filter elements.

Syntax

[expression for item in iterable if condition]

Example:

even_numbers = [x for x in range(10) if x % 2 == 0]
print(even_numbers)

Output:

Only even numbers are included in the new list.

Creating a List of Odd Numbers

odd_numbers = [x for x in range(10) if x % 2 != 0]
print(odd_numbers)

Output:

Converting Strings to Uppercase

List comprehension can also transform data.

Example:

names = ["john", "emma", "alex"]
uppercase_names = [name.upper() for name in names]
print(uppercase_names)

Output:

Using if-else in List Comprehension

Python supports conditional expressions inside list comprehensions.

Syntax

[expression_if_true if condition else expression_if_false for item in iterable]

Example:

numbers = [1, 2, 3, 4, 5]
result = ["Even" if x % 2 == 0 else "Odd" for x in numbers]
print(result)

Output:

Working with Strings

List comprehension can iterate through characters of a string.

Example:

letters = [char for char in "Python"]
print(letters)

Output:

Working with Existing Lists

Example:

prices = [100, 200, 300]
discounted_prices = [price * 0.9 for price in prices]
print(discounted_prices)

Output:

This creates a new list containing discounted prices.

Nested List Comprehension

List comprehension can also work with nested loops.

Example:

pairs = [(x, y) for x in [1, 2] for y in [3, 4]]
print(pairs)

Output:

This generates all possible combinations.

Real-Life Example

Imagine you are developing an e-commerce application.

You have a list of product prices:

prices = [1000, 1500, 2000, 2500]
Apply a 10% discount to all products:
discounted_prices = [price * 0.9 for price in prices]
print(discounted_prices)

Output:

This is much cleaner than using a traditional loop.

Traditional Approach

discounted_prices = []

for price in prices:

  discounted_prices.append(price * 0.9)

List comprehension achieves the same result in one line.

Advantages of List Comprehension

1. Cleaner Code

Traditional loops:

 numbers = []
for i in range(5):
    numbers.append(i)

List comprehension:

numbers = [i for i in range(5)]

2. Better Readability

The code clearly shows what data is being generated.

3. Faster Execution

List comprehensions are generally faster than equivalent loops because they are optimized internally by Python.

4. Easy Filtering

Filtering data becomes straightforward.

positive_numbers = [x for x in numbers if x > 0]

Common Mistakes

1. Forgetting the Expression

Incorrect:

[x in range(5)]

Correct:

[x for x in range(5)]

2. Using Complex Logic

Avoid writing extremely complex comprehensions.

Bad Example:

result = [
    x * 2 if x % 2 == 0 else x + 1
    for x in numbers
    if x > 0
]

While valid, it can reduce readability.

3. Modifying the Original List Unintentionally

numbers = [1, 2, 3]
numbers = [x * 2 for x in numbers]

This replaces the original list.

If you need both lists, store the result in a new variable.

4. Confusing List Comprehension with Generator Expressions

List comprehension:

[x for x in range(5)]

Generator expression:

(x for x in range(5))

The first creates a list immediately, while the second creates a generator object.

List Comprehension vs Traditional Loop

Conclusion

List comprehension is one of Python’s most powerful and elegant features. It provides a concise and readable way to create, transform, and filter lists. By replacing traditional loops with list comprehensions, developers can write cleaner, shorter, and often faster code.

Related Python Operators Topics