Comprehensions

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

# With filter: [expression for item in iterable if condition]
evens = [x for x in range(20) if x % 2 == 0]
# [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

# Transform and filter
words = ["hello", "world", "foo", "bar"]
long_upper = [w.upper() for w in words if len(w) > 3]
# ['HELLO', 'WORLD']

# With ternary (if-else in the expression, not the filter)
labels = ["even" if x % 2 == 0 else "odd" for x in range(5)]
# ['even', 'odd', 'even', 'odd', 'even']

# Nested loops (outer first, then inner — same order as nested for loops)
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [val for row in matrix for val in row]
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Cartesian product
pairs = [(x, y) for x in range(3) for y in range(3) if x != y]
# [(0,1),(0,2),(1,0),(1,2),(2,0),(2,1)]

# Calling a function
results = [process(x) for x in data]

# Unpacking tuples
sums = [a + b for a, b in [(1, 2), (3, 4), (5, 6)]]
# [3, 7, 11]

# Basic: {key_expr: val_expr for item in iterable}
squares = {x: x**2 for x in range(5)}
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# With filter
{k: v for k, v in d.items() if v > 0}

# Invert dict (assumes unique values)
inv = {v: k for k, v in original.items()}

# Transform keys and values
{k.lower(): v.strip() for k, v in raw.items()}

# From two lists
{k: v for k, v in zip(keys, values)}

# Group by
words = ["apple", "banana", "avocado", "blueberry"]
by_letter = {
    ch: [w for w in words if w[0] == ch]
    for ch in set(w[0] for w in words)
}
# {'a': ['apple', 'avocado'], 'b': ['banana', 'blueberry']}

# Basic: {expression for item in iterable}
unique_squares = {x ** 2 for x in range(-5, 6)}
# {0, 1, 4, 9, 16, 25}

# With filter
vowels = {ch for ch in "hello world" if ch in "aeiou"}
# {'e', 'o'}

# Lowercase unique words
vocab = {word.lower() for word in text.split()}

# Basic: (expression for item in iterable)
gen = (x ** 2 for x in range(10))

next(gen)         # 0
next(gen)         # 1
list(gen)         # [4, 9, ..., 81]  (already consumed 0, 1)

# Use directly in function calls (single-arg functions: no extra parens)
total = sum(x ** 2 for x in range(100))
any(x > 50 for x in data)
all(x > 0 for x in data)
max(len(word) for word in words)
",".join(str(x) for x in lst)

# With filter
total = sum(x for x in lst if x > 0)

# First match
first = next((x for x in lst if x > 5), None)

# Build 3x3 identity matrix
identity = [[1 if i == j else 0 for j in range(3)] for i in range(3)]
# [[1,0,0],[0,1,0],[0,0,1]]

# Transpose a matrix
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
transposed = [[row[i] for row in matrix] for i in range(3)]
# [[1,4,7],[2,5,8],[3,6,9]]

# Or using zip
transposed = [list(row) for row in zip(*matrix)]

# Without walrus — transform(x) called twice
[transform(x) for x in data if transform(x) is not None]

# With walrus — called once
[y for x in data if (y := transform(x)) is not None]

# Keep only valid results
results = [parsed for line in lines if (parsed := parse(line))]

# Comprehensions vs loops — comprehensions are generally faster
# but avoid when logic is complex enough to obscure intent

# Readable: simple expression, one filter condition
good = [x.strip() for x in lines if x.strip()]

# Less readable: complex nested logic — use a regular loop instead
bad = [f(g(x)) for x in d.values() if x > 0 for g in transforms if g(x)]

# Memory: use generator expressions for large data
# Bad for large N:
total = sum([x**2 for x in range(10**7)])  # creates full list in memory
# Good:
total = sum(x**2 for x in range(10**7))    # lazy, O(1) memory

# Avoid side effects in comprehensions
# Bad: [print(x) for x in lst]  — use a for loop
# Good: [process(x) for x in lst]  — when you need the results list

# Flatten one level
flat = [item for sublist in nested for item in sublist]

# Unique values preserving order
seen = set()
unique = [x for x in lst if not (x in seen or seen.add(x))]

# Zip + comprehension
totals = [a + b for a, b in zip(list1, list2)]

# Conditional expression in comprehension
clamped = [max(0, min(100, x)) for x in values]

# Count with sum
count_positive = sum(1 for x in data if x > 0)

# Dict from two lists with transformation
grade_map = {name: grade * 1.1 for name, grade in zip(names, grades)}