Python - Comprehensions

Comprehensions in Python

Introduction to Comprehensions

Comprehensions in Python provide a concise and readable way to create sequences like lists, dictionaries, and sets by iterating over iterables and optionally filtering data using conditions. Instead of using loops and the append() method to construct collections, comprehensions allow one-liner expressions that are efficient and expressive.

Why Use Comprehensions?

Comprehensions are popular in Python for several reasons:

• They are more concise than traditional loops.
• They can be faster due to internal optimizations.
• They are easier to read for simple transformations.

Types of Comprehensions

• List Comprehensions
• Dictionary Comprehensions
• Set Comprehensions
• Generator Expressions

List Comprehensions

Basic Syntax

[expression for item in iterable]

Example: Square Numbers

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

With Condition (Filtering)

evens = [x for x in range(20) if x % 2 == 0]
print(evens)
# Output: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

Nested List Comprehension

Nested comprehensions can be used to flatten lists or create matrices.

Example: Flatten a Matrix

matrix = [[1, 2], [3, 4], [5, 6]]
flattened = [num for row in matrix for num in row]
print(flattened)
# Output: [1, 2, 3, 4, 5, 6]

List Comprehension with Function Calls

def square(x):
    return x * x

squares = [square(x) for x in range(5)]
print(squares)
# Output: [0, 1, 4, 9, 16]

Set Comprehensions

Basic Syntax

{expression for item in iterable}

Example: Unique Squares

nums = [1, 2, 2, 3, 4, 4, 5]
squares = {x ** 2 for x in nums}
print(squares)
# Output: {1, 4, 9, 16, 25}

With Condition

even_squares = {x ** 2 for x in range(10) if x % 2 == 0}
print(even_squares)
# Output: {0, 64, 4, 36, 16}

Dictionary Comprehensions

Basic Syntax

{key_expr: value_expr for item in iterable}

Example: Mapping Numbers to Squares

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

With Condition

odd_squares = {x: x ** 2 for x in range(10) if x % 2 != 0}
print(odd_squares)
# Output: {1: 1, 3: 9, 5: 25, 7: 49, 9: 81}

Using zip()

names = ['Alice', 'Bob', 'Charlie']
scores = [85, 90, 95]
student_scores = {name: score for name, score in zip(names, scores)}
print(student_scores)
# Output: {'Alice': 85, 'Bob': 90, 'Charlie': 95}

Generator Expressions

Basic Syntax

(expression for item in iterable)

Difference from List Comprehension

Generator expressions use parentheses instead of square brackets. They do not store the entire list in memory, making them more memory-efficient.

Example

gen = (x * x for x in range(5))
for val in gen:
    print(val)
# Output: 0 1 4 9 16

Passing to Functions

sum_of_squares = sum(x * x for x in range(10))
print(sum_of_squares)
# Output: 285

Advanced Comprehension Techniques

Nested Comprehensions

Example: 3x3 Matrix

matrix = [[i * j for j in range(3)] for i in range(3)]
print(matrix)
# Output: [[0, 0, 0], [0, 1, 2], [0, 2, 4]]

Comprehensions with Multiple Conditions

filtered = [x for x in range(20) if x % 2 == 0 if x % 3 == 0]
print(filtered)
# Output: [0, 6, 12, 18]

Comprehensions with Else Clause

labels = ['Even' if x % 2 == 0 else 'Odd' for x in range(5)]
print(labels)
# Output: ['Even', 'Odd', 'Even', 'Odd', 'Even']

Common Mistakes in Comprehensions

Using List Comprehension When Generator is Better

List comprehensions store all values in memory. For large datasets or streaming data, prefer generators.

Overusing Nested Comprehensions

Readability suffers when nesting goes too deep. Prefer regular loops when the logic gets complex.

Confusing List, Set, Dict Syntax

# Wrong
{x, x**2 for x in range(5)}  # SyntaxError

# Right
{x: x**2 for x in range(5)}

Use Cases and Applications

Cleaning Data

raw_data = ['  apple', 'banana  ', '  mango ']
clean_data = [item.strip() for item in raw_data]
print(clean_data)
# Output: ['apple', 'banana', 'mango']

Reading and Filtering Files

with open("data.txt") as f:
    lines = [line.strip() for line in f if line.strip()]

Transforming Dictionaries

original = {'a': 1, 'b': 2, 'c': 3}
transformed = {k: v * 10 for k, v in original.items()}
print(transformed)
# Output: {'a': 10, 'b': 20, 'c': 30}

Flattening Nested Lists

nested = [[1, 2], [3, 4], [5]]
flat = [num for sublist in nested for num in sublist]
print(flat)
# Output: [1, 2, 3, 4, 5]

Working with APIs

import requests
urls = ['https://example.com', 'https://python.org']
responses = [requests.get(url).status_code for url in urls]

Performance Considerations

Time and Space Complexity

List comprehensions are generally faster than loops because they are optimized internally. However, they consume memory equal to the list they generate. If memory is a concern, use generators.

Timing Example

import time

start = time.time()
squares = [x**2 for x in range(10**6)]
print("List comprehension took:", time.time() - start)

start = time.time()
squares_gen = (x**2 for x in range(10**6))
for s in squares_gen:
    pass
print("Generator expression took:", time.time() - start)

Comprehensions are a powerful feature in Python that makes code more expressive, readable, and concise. Whether you are dealing with lists, dictionaries, or sets, comprehensions offer an elegant alternative to traditional loops. While they are efficient and compact, developers should be cautious with complex logic or memory-heavy operations. Using the right comprehension technique can greatly improve the performance and clarity of Python programs.