Python List Comprehension: Write Cleaner Code with Practical Examples

If you've been learning Python, you've probably written code like this:

numbers = [1, 2, 3, 4, 5]

squares = []

for number in numbers:
    squares.append(number ** 2)

print(squares)

Output:

[1, 4, 9, 16, 25]

There's nothing wrong with this code.

But Python gives us a shorter and often more readable way to create the same list:

numbers = [1, 2, 3, 4, 5]

squares = [number ** 2 for number in numbers]

print(squares)

Same result. Much less code.

Welcome to list comprehensions.

In this beginner-friendly guide, we'll understand their syntax, use conditions, compare them with regular loops, and look at situations where you should not use them.

---

What Is a List Comprehension?

A list comprehension is a concise way to create a new list from an iterable such as another list, tuple, or range.

The basic syntax is:

[expression for item in iterable]

For example:

numbers = [1, 2, 3, 4]

doubled = [x * 2 for x in numbers]

print(doubled)

Output:

[2, 4, 6, 8]

Let's break this down:

x * 2

is the value we want to add to the new list.

for x in numbers

loops through every value in numbers.

So Python essentially reads it as:

For every x in numbers, calculate x * 2 and put the result into a new list.

---

Regular Loop vs List Comprehension

Here's a traditional loop:

numbers = [1, 2, 3, 4, 5]

squares = []

for x in numbers:
    squares.append(x * x)

Using list comprehension:

squares = [x * x for x in numbers]

Both approaches create the same result:

[1, 4, 9, 16, 25]

The list comprehension is shorter, but shorter doesn't automatically mean better.

Readability should always come first.

---

Filtering Values with if

List comprehensions become even more useful when we add conditions.

Suppose we only want even numbers.

Traditional approach:

numbers = [1, 2, 3, 4, 5, 6]

evens = []

for x in numbers:
    if x % 2 == 0:
        evens.append(x)

print(evens)

We can write the same logic as:

numbers = [1, 2, 3, 4, 5, 6]

evens = [x for x in numbers if x % 2 == 0]

print(evens)

Output:

[2, 4, 6]

The pattern becomes:

[expression for item in iterable if condition]

---

Transform and Filter at the Same Time

You can also transform only the values that match a condition.

For example, let's square only the even numbers:

numbers = [1, 2, 3, 4, 5, 6]

even_squares = [
    x ** 2
    for x in numbers
    if x % 2 == 0
]

print(even_squares)

Output:

[4, 16, 36]

Here Python first checks whether the number is even and then calculates its square.

---

Using if-else

There's an important syntax difference when you need both if and else.

Suppose we want to label numbers as even or odd:

numbers = [1, 2, 3, 4]

labels = [
    "Even" if x % 2 == 0 else "Odd"
    for x in numbers
]

print(labels)

Output:

['Odd', 'Even', 'Odd', 'Even']

Notice where the condition appears:

"Even" if condition else "Odd"

comes before the for.

Compare these two patterns:

Filtering

[x for x in numbers if x > 5]

Conditional transformation

["Even" if x % 2 == 0 else "Odd" for x in numbers]

This difference is a common source of confusion for beginners.

---

Working with Strings

List comprehensions aren't limited to numbers.

languages = ["python", "javascript", "php"]

uppercase = [language.upper() for language in languages]

print(uppercase)

Output:

['PYTHON', 'JAVASCRIPT', 'PHP']

Another example:

names = ["Anjali", "Alex", "Sam", "Michael"]

short_names = [name for name in names if len(name) <= 4]

print(short_names)

Output:

['Alex', 'Sam']

---

Using range()

You can create lists directly from range().

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

print(squares)

Output:

[1, 4, 9, 16, 25]

This can be useful when generating predictable sequences.

---

Nested List Comprehensions

List comprehensions can also contain multiple loops.

For example:

matrix = [
    [1, 2],
    [3, 4]
]

flattened = [
    number
    for row in matrix
    for number in row
]

print(flattened)

Output:

[1, 2, 3, 4]

This is powerful, but it's also where list comprehensions can become harder to understand.

If a comprehension starts looking complicated, a regular loop may be the better choice.

---

When Should You Use List Comprehension?

List comprehensions work well when the operation is simple and easy to understand.

Good:

squares = [x ** 2 for x in numbers]

Good:

evens = [x for x in numbers if x % 2 == 0]

But imagine trying to squeeze several conditions and transformations into one line.

Technically valid Python isn't always readable Python.

For complex logic, prefer:

result = []

for item in items:
    # multiple steps
    # conditions
    # calculations
    result.append(value)

Readable code is more valuable than clever code.

---

List Comprehension vs map() and filter()

Python also provides map() and filter().

For example:

numbers = [1, 2, 3, 4]

doubled = list(map(lambda x: x * 2, numbers))

The list comprehension equivalent is:

doubled = [x * 2 for x in numbers]

For filtering:

evens = list(filter(lambda x: x % 2 == 0, numbers))

Equivalent comprehension:

evens = [x for x in numbers if x % 2 == 0]

Neither approach is universally better.

But for many straightforward transformations and filters, comprehensions can be easier to read.

---

Common Beginner Mistakes

1. Forgetting the for

Incorrect:

[x * 2 x in numbers]

Correct:

[x * 2 for x in numbers]

2. Putting a Filtering Condition in the Wrong Place

Correct filtering syntax:

[x for x in numbers if x > 5]

3. Making the Comprehension Too Complex

If you need several nested conditions and transformations, don't force everything into one expression.

Use a regular loop.

Your future self—and anyone reviewing your code—will thank you.

---

Quick Challenge

What will this code print?

numbers = [1, 2, 3, 4, 5]

result = [
    x * 2
    for x in numbers
    if x % 2 != 0
]

print(result)

Can you work it out before running the code?

The answer is:

[2, 6, 10]

Only the odd values 1, 3, and 5 pass the condition, and each is then multiplied by 2.

---

Quick Recap

List comprehension:

[expression for item in iterable]

With filtering:

[expression for item in iterable if condition]

With if-else:

[value_if_true if condition else value_if_false for item in iterable]

The main idea is simple:

Transform → Iterate → Optionally Filter

Once this pattern becomes familiar, you'll start noticing many places where a long loop can be expressed more clearly.

---

Watch the Video Tutorial

I've also explained Python List Comprehension step by step in Hinglish on my YouTube channel, Anjali Gupta Techverse.

🎥 Add your Lesson 20 YouTube URL here.

If you're learning Python from the beginning, you can follow the complete Python series lesson by lesson.

---

What's Next?

After list comprehensions, you can explore:

• Dictionary Comprehension
• Set Comprehension
• Exception Handling
• More practical Python projects

I'll continue covering these topics in the upcoming tutorials.

---

If this guide helped you, feel free to leave a comment.

What do you prefer for simple transformations: a traditional for loop or list comprehension?

Happy coding! 🐍