Skip to content
logo
Home / Fundamentals

Python Comprehensions

Comprehensions are a concise way to create new sequences (such as lists, dictionaries, and sets) from existing iterables. They allow you to apply operations to each element in an iterable and include the results in a new sequence.

Comprehension Syntax

The general syntax for a comprehension is:

[expression for item in iterable]

Here, expression is a value or operation to be applied to each element in iterable, and item is a variable that takes on each element in iterable in turn.

For example, the following list comprehension creates a new list of the squares of the numbers 0 through 9:

squares = [x**2 for x in range(10)]
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

You can also include an optional if clause to filter the elements of the iterable:

even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares)  # [0, 4, 16, 36, 64]

You can also use else clauses in comprehensions, similar to how you would use them in regular if-else statements. However, the else clause must come after the if clause, and it will only be executed if the if clause evaluates to False:

even_or_odd = ['even' if x % 2 == 0 else 'odd' for x in range(10)]
print(even_or_odd)  # ['even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd']

List Comprehensions

List comprehensions are a concise way to create a list from an iterable. They are often used to transform and filter data, as in the examples above.

For example, suppose you have a list of strings and you want to create a new list with all the strings that are upper case. You can use a list comprehension to do this in one line:

strings = ['hello', 'world', 'FOO', 'bar']
uppercase_strings = [s.upper() for s in strings if s.isupper()]
print(uppercase_strings)  # ['FOO']

You can also use list comprehensions to create a list of lists, by including additional for clauses:

pairs = [(x, y) for x in range(3) for y in range(3)]
print(pairs)  # [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

Dictionary Comprehensions

Dictionary comprehensions are a concise way to create a dictionary from an iterable. They have a similar syntax to list comprehensions, but use curly braces instead of square brackets and include a key-value pair separated by a colon:

squares = {x: x**2 for x in range(10)}
print(squares)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

Generator Comprehensions

Generator comprehensions are similar to list comprehensions, but instead of creating a list, they create a generator object that produces the values on the fly. This can be more memory-efficient when working with large iterables, since the generator only produces the values as they are needed, rather than creating a whole list in memory at once.

To create a generator comprehension, you use the same syntax as a list comprehension, but enclose it in parentheses instead of square brackets:

squares = (x**2 for x in range(10))
print(squares)  # <generator object <genexpr> at 0x10e8b2f48>

To get the values from a generator, you can use the next() function or iterate over it using a for loop:

print(next(squares))  # 0
print(next(squares))  # 1
print(next(squares))  # 4

for square in squares:
    print(square)  # 9 16 25 36 49 64 81

Filtering with if and else

As mentioned earlier, you can use if clauses to filter the elements of an iterable in a comprehension. This can be useful for selecting only certain elements or modifying the value of an element based on a condition.

For example, suppose you have a list of numbers and you want to create a new list with only the even numbers doubled:

numbers = [1, 2, 3, 4, 5, 6]
even_doubles = [x * 2 for x in numbers if x % 2 == 0]
print(even_doubles)  # [4, 8, 12]

You can also use else clauses in comprehensions, similar to how you would use them in regular if-else statements. However, the else clause must come after the if clause, and it will only be executed if the if clause evaluates to False:

numbers = [1, 2, 3, 4, 5, 6]
even_or_tripled = [x * 3 if x % 2 == 0 else x for x in numbers]
print(even_or_tripled)  # [1, 6, 3, 12, 5, 18]

Best Practices

  • Keep it simple: Comprehensions are a concise way to create sequences, but they can become difficult to read if you try to do too much in one line. If your comprehension is becoming too complex, consider breaking it up into multiple lines or using a regular loop instead.
  • Avoid nested comprehensions: Nested comprehensions (comprehensions within comprehensions) can be difficult to read and understand. If you find yourself needing to use a nested comprehension, consider refactoring your code to use a regular loop or a utility function.
  • Prefer readability over brevity: Comprehensions are a great way to write concise code, but they should not be used at the expense of readability. If a comprehension is making your code difficult to understand, consider using a regular loop instead.
  • Use comprehensions for appropriate data types: Comprehensions are most commonly used to create lists and dictionaries, but they can also be used to create sets and generators. Choose the appropriate data type for your needs, and use the corresponding comprehension syntax (square brackets for lists and dictionaries, curly braces for sets, and parentheses for generators).
  • Use meaningful variable names: In comprehensions, the variable names you choose can significantly impact the readability of your code. Choose descriptive and meaningful names for your variables to make it easier for others (or yourself) to understand what the comprehension is doing.