Simplify Your Python Loops with Comprehensions [Tutorial]

If you’ve been wondering how to simplify your Python loops—or write cleaner, more concise code for common tasks—Python comprehensions are the answer.

Comprehensions allow you to embed loops and conditional logic directly into a single line of code, making it easy to replace multi-line loops with compact, readable expressions.

In this article, we’ll explore how to use list, dictionary, set, and generator comprehensions to streamline your code, along with the latest best practices for writing efficient and Pythonic loops.

What Are Comprehensions?

Comprehensions are constructs that allow you to generate a new collection in a concise, readable way by embedding loops and conditional logic directly within the collection’s definition. The most commonly used comprehension is the list comprehension, but similar constructs exist for dictionaries, sets, and generators.

Here’s the basic structure of a list comprehension:

[expression for item in iterable]

Let’s explore how to use list comprehensions with an example.

Doubling Values in a List

Suppose we want to double the values of all items in a list. First, let’s write a traditional function to achieve this:

my_list = [21, 2, 93]

def list_doubler(lst):
    doubled = []
    for num in lst:
        doubled.append(num * 2)
    return doubled

my_doubled_list = list_doubler(my_list)
print(my_doubled_list)  # Output: [42, 4, 186]

While this function works, it’s unnecessarily verbose for such a simple task. Let’s rewrite it using a list comprehension:

def list_doubler(lst):
    return [num * 2 for num in lst]

my_doubled_list = list_doubler(my_list)
print(my_doubled_list)  # Output: [42, 4, 186]

Now the function is much more concise and easier to read. The list comprehension directly creates the new list by iterating over lst and applying the num * 2 operation to each element.

Why Use Comprehensions?

List comprehensions and other types of comprehensions:

• Save Space: Reduce boilerplate code and improve readability.
• Performance: In many cases, they’re faster than manually appending to a list due to Python’s optimized implementation. However, it’s important to note that in some specific cases, traditional loops might be slightly more performant.
• Clarity: Keep the logic inline, which makes simple operations easier to understand at a glance.

Adding Conditional Statements

Comprehensions become even more powerful when combined with conditional logic. For example, let’s write a function that filters a list to only include words longer than 5 characters:

Traditional Loop:

def long_words(lst):
    words = []
    for word in lst:
        if len(word) > 5:
            words.append(word)
    return words

print(long_words(['blog', 'Treehouse', 'Python', 'hi']))
# Output: ['Treehouse', 'Python']

Using a List Comprehension:

def long_words(lst):
    return [word for word in lst if len(word) > 5]

print(long_words(['blog', 'Treehouse', 'Python', 'hi']))
# Output: ['Treehouse', 'Python']

This approach not only saves space but also keeps the filtering logic closer to the data generation, improving readability.

Beyond Lists: Other Comprehensions

Dictionary Comprehensions

Dictionary comprehensions allow you to create dictionaries in a concise manner, similar to list comprehensions, by defining key-value pairs within the comprehension.

squares = {num: num**2 for num in range(1, 6)}
print(squares)  # Output: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Set Comprehensions

Set comprehensions are used to create sets, which are unordered collections of unique elements. They follow a similar syntax to list comprehensions but utilize curly braces {}.

unique_lengths = {len(word) for word in ['Python', 'blog', 'Treehouse', 'Python']}
print(unique_lengths)  # Output: {8, 4, 9}

Generator Expressions

Generator expressions are memory-efficient because they don’t create the entire list in memory at once:

gen = (num * 2 for num in range(1, 6))
print(list(gen))  # Output: [2, 4, 6, 8, 10]

Tips for Using Comprehensions

• Keep Them Simple: Avoid nesting comprehensions too deeply. If a comprehension becomes hard to read, consider using a traditional loop.
  • Example of a poorly nested comprehension:

    nested = [[x*y for x in range(3)] for y in range(3)] 
    

• Use Readable Names: Make sure the variables in your comprehensions are descriptive.
• Leverage Built-In Functions: Combine comprehensions with Python’s built-in functions like sum(), max(), or sorted() for even more concise code.

Practice Makes Perfect

Here are a few exercises to try:

1. Write a list comprehension that extracts all even numbers from a list.
2. Use a dictionary comprehension to create a mapping of numbers to their cubes.
3. Create a set comprehension that removes duplicates from a list of words.
4. Challenge: Using a comprehension, create a list of tuples, where each tuple contains an element from two different lists.
5. Challenge: Using a comprehension, flatten a nested list.

Where to Go from Here

Comprehensions are just the beginning. If this has whetted your appetite, explore more advanced topics like:

• Functional Programming: Learn about map(), filter(), and reduce().
• Advanced Itertools: Dive into Python’s powerful itertools library for complex iterators.
• Async Comprehensions: Introduced in Python 3.6, they enable asynchronous iteration.

With practice, comprehensions will become a natural and powerful part of your Python toolkit. Happy coding!

Frequently Asked Questions (FAQs)

Q: What is a list comprehension in Python?

A list comprehension is a concise way to create lists in Python. It uses a single line of code to iterate over an iterable, apply an expression to each item, and optionally filter elements using conditions. Example:

Q: When should I use a list comprehension instead of a loop?

Use a list comprehension when the operation is simple and can be clearly expressed in one line. For complex logic or multiple nested conditions, traditional loops may be more readable and maintainable.

Q: Are comprehensions faster than loops?

In many cases, yes. Python internally optimizes comprehensions, making them slightly faster than manually appending items to a list in a loop. However, the difference is usually minor unless you’re working with large datasets or performance-critical code.

Q: Can I use if and else inside a comprehension?

Yes. You can use an inline if...else expression in list comprehensions.
Example:

Q: What’s the difference between a list comprehension and a generator expression?

A list comprehension creates the entire list in memory, while a generator expression returns a generator that yields items one by one, saving memory. Use generators for large or infinite sequences where you don’t need all items at once.

Q: Do comprehensions work with dictionaries and sets?

Yes. Python supports:

• Dictionary comprehensions: {key: value for item in iterable}

• Set comprehensions: {expression for item in iterable}

These help you build collections quickly with clean, readable code.

Q: Are nested comprehensions a good idea?

Only in moderation. Nested comprehensions are powerful but can quickly become unreadable. If the logic gets too complex, break it into multiple lines or use traditional loops instead.

Q: What are async comprehensions?

Async comprehensions, introduced in Python 3.6, allow you to use async for inside a comprehension. They’re useful when working with asynchronous generators in asyncio code.

Learn Python with Treehouse

Learning with Treehouse starts at only $25 per month. If you think you’re ready to start exploring if tech is right for you, sign up for your free seven day trial.

Hang out with us on Discord to learn our favorite tips, to network with like-minded peers, and to share how your learning is going. We’ll see you there!

If you liked reading this article, have a look at this one: