List Comprehensions and Generator Expressions in Python

The Problem They Solve

Traditional loops are verbose. Take this straightforward example: you want to square every number in a list.

numbers = [1, 2, 3, 4, 5]
squared = []
 
for num in numbers:
    squared.append(num ** 2)
 
print(squared)

Expected output:

[1, 4, 9, 16, 25]

This works, but it's four lines of setup for a simple transformation. You're building an empty list, looping through items, and appending results manually. That's the procedural way, clear, but verbose. Notice how the intent of your code, "square every number", is buried inside boilerplate: the empty list initialization, the loop header, and the append call all obscure what you're actually trying to accomplish. List comprehensions let you express the same idea in a single line, and Python handles the list-building machinery for you.

List Comprehensions: The Basics

A list comprehension takes the pattern [expression for item in iterable] and produces a new list. Here's the same squaring example using a comprehension:

numbers = [1, 2, 3, 4, 5]
squared = [num ** 2 for num in numbers]
 
print(squared)

Expected output:

[1, 4, 9, 16, 25]

One line. Same result. The comprehension syntax reads almost like English: "give me num squared for each num in numbers." Python evaluates the expression (num ** 2) for every item in the **iterable** (numbers) and collects the results into a new list. Your intent is now front and center, unobscured by bookkeeping code.

How the Syntax Works

The general form of a list comprehension is:

[expression for item in iterable]

Breaking this down:

• expression: What to compute for each item. Can be a simple value, a function call, a calculation, or even a conditional expression.
• for item in iterable: The loop part. item is a variable that takes on each value from iterable in sequence.
• iterable: Any object you can loop over, a list, string, range, dictionary, etc.

Here's a slightly more complex example:

words = ["hello", "world", "python"]
lengths = [len(word) for word in words]
 
print(lengths)

Expected output:

[5, 5, 6]

Here, the expression is len(word), which computes the length of each word. The result is a new list containing those lengths. Notice that we're calling a built-in function as the expression, you're not limited to simple arithmetic. Any Python expression that produces a value can go in that first position, which gives comprehensions enormous flexibility.

Adding Conditions

Real-world transformations usually include filtering. You can add an if clause to include only certain items:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
evens = [num for num in numbers if num % 2 == 0]
 
print(evens)

Expected output:

[2, 4, 6, 8, 10]

The syntax is [expression for item in iterable if condition]. The condition filters items before they're included. In this case, only numbers where num % 2 == 0 (even numbers) make it into the result. Think of the if clause as a gate, each item passes through the gate check before the expression is evaluated and the result is added to the output list.

You can combine transformation and filtering:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_squared = [num ** 2 for num in numbers if num % 2 == 0]
 
print(even_squared)

Expected output:

[4, 16, 36, 64, 100]

Here, we filter for even numbers and then square them. The expression (num ** 2) is evaluated only on items that pass the **condition** (num % 2 == 0). This is more efficient than filtering after the transformation because we skip the squaring step entirely for odd numbers, Python evaluates the if clause first, then only computes the expression for items that qualify.

Multiple Conditions

You can stack multiple if clauses to apply several filters:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = [num for num in numbers if num % 2 == 0 if num > 4]
 
print(result)

Expected output:

[6, 8, 10]

This filters for even numbers AND numbers greater than 4. Both conditions must be true for an item to be included. This is equivalent to using and in a single condition, but breaking them into separate if clauses can sometimes be more readable for complex logic. Each if clause is evaluated left to right, and Python short-circuits: if the first condition fails, Python doesn't bother checking the second one.

Why This Matters: The Hidden Layer

List comprehensions aren't just syntactic sugar. They're optimized at the bytecode level. When Python sees a list comprehension, it creates the list object once and appends items in a tight loop, there's no repeated list resizing happening behind the scenes like there can be with manual append() calls. Comprehensions are faster than their loop equivalents, especially on larger datasets. They're also more readable once you get used to the syntax, which means less mental overhead for anyone reading your code.

Comprehension Performance

Understanding why comprehensions perform better than explicit loops helps you make informed decisions about when to use them. The speed advantage comes from several compounding factors at the CPython implementation level.

First, attribute lookup overhead: when you write result.append(item) in a loop, Python has to look up the append attribute on the result object on every single iteration. That lookup involves searching the method resolution order (MRO) and is surprisingly expensive when repeated thousands of times. Comprehensions don't call append at all, they use a dedicated bytecode instruction (LIST_APPEND) that operates directly on the list object without the attribute resolution dance.

Second, comprehensions execute in their own optimized scope. Python's bytecode compiler generates more efficient instructions for comprehension bodies than for generic loop bodies. The compiler knows upfront that the comprehension produces a list and can pre-allocate memory hints accordingly, reducing the number of internal realloc calls as the list grows.

Third, the LOAD and STORE operations in a comprehension are simpler because the output list doesn't need to be resolved from the enclosing scope on every iteration. In a manual loop, Python re-looks up result in the local scope every time you write result.append(...). The comprehension's internal list reference is held directly, shaving microseconds off each iteration, microseconds that add up fast when you're processing a million items.

Benchmark numbers vary by Python version and hardware, but you can typically expect comprehensions to run 20–50% faster than equivalent explicit loops. For small lists (under ~100 items), the difference is negligible and readability should be your primary concern. For large datasets or hot paths called repeatedly, that 30% improvement is worth caring about.

Nested List Comprehensions

You can nest comprehensions to work with multi-dimensional data. Here's flattening a 2D list:

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
 
flattened = [num for row in matrix for num in row]
 
print(flattened)

Expected output:

[1, 2, 3, 4, 5, 6, 7, 8, 9]

Read this as: "for each row in matrix, for each num in row, include num." The order of the for clauses matters, you read them left to right, the same way you'd write nested loops. This is equivalent to:

flattened = []
for row in matrix:
    for num in row:
        flattened.append(num)

You can combine nested iteration with conditions:

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
 
# Get only even numbers from the flattened matrix
evens = [num for row in matrix for num in row if num % 2 == 0]
 
print(evens)

Expected output:

[2, 4, 6, 8]

The if clause at the end filters the final result, it applies to the innermost loop variable (num), not to row. If you wanted to filter rows instead of individual numbers, you'd need a different structure, this is where comprehensions start getting hard to read. A good rule of thumb: if your comprehension needs more than one for clause or the condition is getting complex, consider a traditional loop for clarity.

The Readability Trap

This comprehension is technically correct but practically unreadable:

result = [
    [num ** 2 for num in row if num % 2 == 0]
    for row in matrix
    if any(num > 5 for num in row)
]

It works, it creates a list of lists, where each inner list contains squared even numbers, but only from rows that contain at least one number greater than 5. It's powerful, but it requires significant cognitive load to parse. In production code, you'd want to break this into multiple steps or use a loop. Comprehensions are best when they're simple enough to read in one breath.

Generator Expressions: Lazy Evaluation

Here's a problem: what if you need to process a million numbers but only want the first 10? Creating a list of a million items just to use 10 is wasteful. Generator expressions solve this by using lazy evaluation, they compute values on-demand, only when you ask for them.

The syntax is almost identical to list comprehensions, except you use parentheses instead of brackets:

numbers = range(1, 11)
squared_gen = (num ** 2 for num in numbers)
 
print(squared_gen)

Expected output:

<generator object <genexpr> at 0x7f8b8c0d5e50>

Notice that it doesn't print a list. It prints a generator object. That object hasn't computed anything yet, it's just a recipe for how to compute values. The generator object holds a reference to the iterable and the expression, but the actual computation is deferred entirely. When you iterate over it, it computes values on the fly:

numbers = range(1, 11)
squared_gen = (num ** 2 for num in numbers)
 
for squared in squared_gen:
    print(squared)

Expected output:

1
4
9
16
25
36
49
64
81
100

The generator computes each squared value as the loop requests it. Once a value is consumed, it's discarded, the generator doesn't store the entire result set in memory. This is the fundamental difference: a list comprehension computes and stores everything upfront, while a generator expression computes each value just-in-time and immediately releases it.

Converting Generators to Lists

You can convert a generator to a list if you need to use it multiple times:

numbers = range(1, 11)
squared_gen = (num ** 2 for num in numbers)
 
squared_list = list(squared_gen)
print(squared_list)

Expected output:

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

But here's the catch: once you convert a generator to a list, you've consumed all the lazy evaluation benefits. You're back to holding everything in memory. Use this conversion pattern when you need random access (indexing), need to iterate the results multiple times, or need to know the length of the result before processing it. If you just need to process values once in sequence, keep it as a generator.

Memory Comparison: Lists vs Generators

This is where the real power of generators shows. Let's compare memory usage:

import sys
 
# List comprehension
list_comp = [x ** 2 for x in range(100000)]
print(f"List size: {sys.getsizeof(list_comp)} bytes")
 
# Generator expression
gen_exp = (x ** 2 for x in range(100000))
print(f"Generator size: {sys.getsizeof(gen_exp)} bytes")

Expected output:

List size: 900040 bytes
Generator size: 112 bytes

The generator is roughly 8000 times smaller! It's not storing the data, just the recipe to compute it. For datasets where you're only processing a subset of items, generators are a game-changer. This is why they're essential in data science workflows where you might be processing terabytes of data.

Generator Memory Savings

The memory gap illustrated above isn't a curiosity, it's a fundamental architectural advantage that becomes critical at scale. When you create a list comprehension over a million items, Python allocates a contiguous block of memory for all million results before you've processed a single one. If you only end up using the first thousand items, you've wasted the memory and time for 999,000 computations you never needed.

A generator sidesteps this entirely. The 112-byte object you saw in the benchmark is essentially a state machine: it holds a reference to the source iterable, the expression to evaluate, and a pointer to where it last left off. That's it. When the calling code asks for the next value via next(), the generator resumes, computes one result, yields it, and suspends again. Memory usage stays flat regardless of how large the logical sequence is.

This pattern is central to how Python handles large-scale data in production systems. Reading a multi-gigabyte log file line by line, streaming API responses, processing database cursor results, all of these typically use generator-based approaches under the hood precisely because keeping the full dataset in memory would be impractical. When you eventually work with pandas DataFrames on large CSVs or process ML training batches, the same lazy-evaluation philosophy applies: compute what you need, when you need it, and discard it immediately.

Generator Functions: The yield Statement

For more complex generation logic, you can write generator functions using the yield keyword. Instead of building a list and returning it all at once, you yield values one at a time:

def countdown(n):
    while n > 0:
        yield n
        n -= 1
 
for value in countdown(5):
    print(value)

Expected output:

5
4
3
2
1

Each time the loop requests a value, the function runs until it hits yield, then pauses. When the loop asks for the next value, the function resumes right where it left off. This is powerful for stateful generation, situations where computing the next value depends on previous state. The function's local variables, including n, are preserved across yields, unlike a regular function where local state is destroyed when the function returns.

Here's a more practical example: generating Fibonacci numbers:

def fibonacci(limit):
    a, b = 0, 1
    while a < limit:
        yield a
        a, b = b, a + b
 
for fib in fibonacci(50):
    print(fib, end=" ")

Expected output:

0 1 1 2 3 5 8 13 21 34

The function maintains state (the a and b variables) between yields. Each iteration computes the next Fibonacci number without storing the entire sequence. For generating thousands or millions of values, this approach is far more efficient than building the complete list upfront.

Common Comprehension Mistakes

Even experienced Python developers make mistakes with comprehensions. Knowing the common pitfalls saves you debugging time and prevents subtle bugs from sneaking into production code.

Mistake 1: Confusing filtering if with ternary if. The if at the end of a comprehension filters items out entirely, while the ternary if...else in the expression position transforms every item. Mixing them up produces wrong results or syntax errors. [x if x > 0 else 0 for x in nums] gives you every item, with negatives clamped to zero. [x for x in nums if x > 0] gives you only positive items. These look similar but do completely different things.

Mistake 2: Side effects inside comprehensions. Comprehensions are expressions meant to produce values, not to perform actions. Writing [print(x) for x in items] technically works, but it creates a list of None values (the return value of print) as a side effect of printing. If you want side effects, use a loop. The intent is completely different and using a comprehension for side-effect-only operations confuses readers.

Mistake 3: Over-nesting until the comprehension becomes unreadable. We covered this in the readability trap section, but it bears repeating because it's the most common mistake. The moment you need to mentally execute the comprehension step-by-step to understand it, it has failed as a communication tool. Break it into named intermediate steps.

Mistake 4: Forgetting generator exhaustion. A generator can only be consumed once. If you pass a generator to two different functions, the second function gets an empty sequence. Always be aware of whether you're passing a generator or a list, and convert to a list when multiple consumers need the data.

Mistake 5: Mutating the source list inside a comprehension. Modifying the iterable you're iterating over leads to unpredictable behavior. Create a new collection from the comprehension result and then replace the original if needed.

Common Patterns: Transform, Filter, Flatten

Here are the three most common comprehension patterns you'll encounter:

Pattern 1: Transform

Apply a function or operation to every item:

items = ["apple", "banana", "cherry"]
uppercase = [item.upper() for item in items]
 
print(uppercase)

Expected output:

['APPLE', 'BANANA', 'CHERRY']

Pattern 2: Filter

Keep only items matching a condition:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
multiples_of_3 = [num for num in numbers if num % 3 == 0]
 
print(multiples_of_3)

Expected output:

[3, 6, 9]

Pattern 3: Flatten

Take nested data and flatten it into a single level:

nested = [[1, 2], [3, 4], [5, 6]]
flat = [item for sublist in nested for item in sublist]
 
print(flat)

Expected output:

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

Most real-world comprehensions combine one or more of these patterns. Recognize them and you'll instantly understand what a comprehension is trying to do.

When to Use Comprehensions vs Explicit Loops

Comprehensions are fantastic, but they're not always the right choice:

Use comprehensions when:

• You're doing a simple transform, filter, or flatten
• The logic fits in one readable line
• You need a list as the final output
• You want better performance than manual loops

Use explicit loops when:

• Your logic is complex (multiple nested conditions, state tracking)
• You need to print debug statements to understand what's happening
• You're doing multiple things per iteration (not just transform or filter)
• Other developers reading your code might struggle with the comprehension syntax
• You need a generator for memory efficiency

Here's an example where a loop is clearer:

# Hard to read as a comprehension
results = [
    process_item(item)
    for item in items
    if item in allowed_set
    if validate(item)
    and not is_banned(item)
]
 
# Clearer as a loop
results = []
for item in items:
    if item not in allowed_set:
        continue
    if not validate(item):
        continue
    if is_banned(item):
        continue
    results.append(process_item(item))

The loop version is longer, but it's dramatically clearer about what's being validated and in what order. Notice also that the loop version makes it trivial to add a print statement for debugging, something that's awkward to do inside a comprehension.

Performance Profiling with timeit

How much faster are comprehensions than explicit loops? Let's measure it:

import timeit
 
# Setup code
setup = "numbers = list(range(1000))"
 
# Method 1: Explicit loop
loop_code = """
result = []
for num in numbers:
    result.append(num ** 2)
"""
 
# Method 2: List comprehension
comp_code = "result = [num ** 2 for num in numbers]"
 
# Measure each
loop_time = timeit.timeit(loop_code, setup, number=10000)
comp_time = timeit.timeit(comp_code, setup, number=10000)
 
print(f"Loop time: {loop_time:.4f}s")
print(f"Comprehension time: {comp_time:.4f}s")
print(f"Comprehension is {loop_time / comp_time:.2f}x faster")

Expected output (typical results vary by system):

Loop time: 1.2345s
Comprehension time: 0.8234s
Comprehension is 1.50x faster

Comprehensions typically run 20-50% faster than equivalent loops on modern Python. The optimization comes from avoiding repeated attribute lookups (like the .append() method) and tighter bytecode generation. Use timeit whenever you're making performance decisions, gut feelings about Python speed are often wrong, and measuring takes only seconds.

Edge Cases and Gotchas

Gotcha 1: Variable Scope in Comprehensions

In Python 2, the loop variable in a list comprehension leaked into the surrounding scope. Python 3 fixed this -- comprehension variables are now scoped to the comprehension:

result = [x ** 2 for x in range(5)]
try:
    print(x)  # NameError in Python 3
except NameError:
    print("x is not defined -- comprehension variables don't leak in Python 3")

Expected output:

x is not defined -- comprehension variables don't leak in Python 3

This is a key improvement over Python 2. However, note that a regular for loop does leave its variable accessible after the loop ends. Don't confuse the two behaviors.

Gotcha 2: Generator Exhaustion

A generator can only be iterated once:

gen = (x for x in range(5))
 
list(gen)  # Consumes the generator
list(gen)  # Empty!

Expected output:

[0, 1, 2, 3, 4]
[]

Once you've iterated through a generator, it's exhausted. If you need to iterate multiple times, convert it to a list or create a new generator.

Gotcha 3: Mutable Default Arguments in Comprehensions

When working with mutable objects (lists, dicts) in comprehensions, remember they're shared across iterations:

matrix = [[0] * 3 for _ in range(3)]
print(matrix)

Expected output:

[[0, 0, 0], [0, 0, 0], [0, 0, 0]]

This is fine, each row gets its own list. But if you do this (wrong):

rows = [[0] * 3] * 3  # DON'T DO THIS
rows[0][0] = 1
print(rows)

Expected output:

[[1, 0, 0], [1, 0, 0], [1, 0, 0]]

You've created one list and referenced it three times. Modifying one modifies all. Always use comprehensions to create independent nested structures.

Advanced: Working with File I/O

Comprehensions are particularly useful when reading files. Here's reading lines from a file and filtering out empty ones:

# Read non-empty lines from a file
with open("data.txt", "r") as f:
    lines = [line.rstrip() for line in f if line.strip()]
 
print(lines)

Expected output (depends on file content):

['First line of data', 'Second line of data', 'Third line of data']

The rstrip() removes trailing whitespace (including the newline character), and the if line.strip() filters out lines that are empty or contain only whitespace. This pattern works because Python file objects are iterable, you can use them directly in a comprehension's for clause without loading the entire file into memory first.

Here's a more complex example: processing log files to extract specific information:

# Extract timestamps and error messages from a log file
with open("app.log", "r") as f:
    errors = [
        line.split(" | ")[0:2]  # Get timestamp and message
        for line in f
        if "ERROR" in line
    ]
 
print(errors)

Expected output (depends on file content):

[['2025-02-25 10:15:30', 'ERROR'], ['2025-02-25 10:20:45', 'ERROR']]

This reads the entire file, filters for lines containing "ERROR", splits each line, and extracts the first two fields (timestamp and message). A traditional loop would require more code and wouldn't feel as natural. If the log file is very large, consider using a generator expression here instead of a list comprehension, that way Python reads and processes one line at a time rather than holding all the error lines in memory simultaneously.

Conditional Expressions in Comprehensions

Sometimes you want to transform data differently based on a condition. That's where the conditional expression (ternary operator) comes in:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = ["even" if num % 2 == 0 else "odd" for num in numbers]
 
print(result)

Expected output:

['odd', 'even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd', 'even']

The syntax is expression_if_true if condition else expression_if_false. Notice this is different from filtering with if at the end. Here, we're using a ternary expression to transform each item. Every item is included, but with different values depending on the condition. The key distinction: a trailing if reduces the output size (some items are excluded), while a ternary if...else keeps the output size the same (every item is present, just potentially transformed differently).

You can make this even more complex:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = [
    "fizzbuzz" if num % 15 == 0
    else "fizz" if num % 3 == 0
    else "buzz" if num % 5 == 0
    else num
    for num in numbers
]
 
print(result)

Expected output:

[1, 2, 'fizz', 4, 'buzz', 'fizz', 7, 8, 'fizz', 'buzz']

This implements FizzBuzz using a chained ternary expression. It's readable, concise, and efficient. Remember: this is transformation (every item is included), not filtering (some items are excluded). Chained ternaries like this are acceptable when the conditions are short and the logic is well-known (like FizzBuzz), but for more than three branches, a loop with if/elif/else is typically clearer.

Working with Multiple Iterables

Sometimes you need to combine or iterate over multiple collections. The zip() function pairs up items from multiple iterables:

names = ["Alice", "Bob", "Charlie"]
ages = [28, 35, 42]
 
combined = [f"{name} is {age}" for name, age in zip(names, ages)]
 
print(combined)

Expected output:

['Alice is 28', 'Bob is 35', 'Charlie is 42']

The zip() function pairs up the first items from each iterable, then the second items, and so on. Your comprehension receives both values in each iteration. This is useful when you have parallel data sources. Note that zip() stops when the shortest iterable is exhausted, if your lists have different lengths, you'll only get pairs up to the length of the shorter one.

You can also use enumerate() to get index and value together:

colors = ["red", "green", "blue"]
indexed = [f"{i}: {color}" for i, color in enumerate(colors)]
 
print(indexed)

Expected output:

['0: red', '1: green', '2: blue']

This is handy when you need to know which position each item is at.

Real-World Example: Processing CSV Data

Here's a practical scenario: you have CSV data and need to extract specific columns, filter rows, and transform values:

import csv
 
# Simulated CSV data
csv_data = [
    {"name": "Alice", "age": "28", "salary": "75000"},
    {"name": "Bob", "age": "35", "salary": "85000"},
    {"name": "Charlie", "age": "42", "salary": "95000"},
    {"name": "Diana", "age": "31", "salary": "80000"},
]
 
# Extract names of employees making more than 80000
high_earners = [
    row["name"]
    for row in csv_data
    if int(row["salary"]) > 80000
]
 
print(high_earners)

Expected output:

['Bob', 'Charlie']

This single comprehension filters rows by salary and extracts the name column. In a traditional loop, you'd need more boilerplate. For data processing pipelines, comprehensions significantly reduce code volume. Notice that we're calling int() inside the condition, that's perfectly valid, and is exactly the kind of inline transformation that comprehensions handle gracefully.

Now let's do something more complex: transform the data structure entirely:

# Convert list of dicts to dict of tuples
salary_data = [
    {"name": "Alice", "age": "28", "salary": "75000"},
    {"name": "Bob", "age": "35", "salary": "85000"},
    {"name": "Charlie", "age": "42", "salary": "95000"},
]
 
# Create a dict where key is name and value is (age, salary)
people = {
    row["name"]: (int(row["age"]), int(row["salary"]))
    for row in salary_data
}
 
print(people)

Expected output:

{'Alice': (28, 75000), 'Bob': (35, 85000), 'Charlie': (42, 95000)}

This uses a dict comprehension (which we'll cover more deeply in the next article) to reshape your data from one structure to another. Comprehensions shine at these transformation tasks, and combining them with Python's built-in data types gives you a powerful, expressive toolkit for the kind of data wrangling that shows up constantly in real-world ML preprocessing work.

Summary

List comprehensions and generator expressions are quintessentially Pythonic. Comprehensions give you concise, readable one-liners for simple data transformations; generators provide lazy evaluation for memory efficiency and infinite sequences. Know when to use each:

• Use list comprehensions for straightforward transforms and filters where you need the entire result immediately
• Use generator expressions when memory is a concern or you're processing large or infinite sequences
• Use generator functions when your generation logic is stateful or complex
• Fall back to explicit loops when readability matters more than conciseness

The real power isn't just in writing them, it's in recognizing the patterns (transform, filter, flatten) and knowing when a comprehension would make your code cleaner versus when it would make it harder to understand. Master these tools and you'll write more efficient, more elegant Python code.

There's a deeper lesson here beyond syntax: list comprehensions and generators represent two different philosophies about when to do work. Comprehensions say "compute everything now, store it, and have it ready." Generators say "don't compute anything until it's asked for, and forget it the moment it's been consumed." Understanding which philosophy fits your problem, bounded vs. unbounded data, single-pass vs. multi-pass processing, memory-constrained vs. latency-constrained environments, is a judgment call you'll make thousands of times as a Python developer. The more you use these tools, the more natural that judgment becomes. Start simple: replace your next verbose transform-loop with a comprehension, swap your next large-data list comprehension with a generator, and pay attention to how the code feels. That intuition is what we're building toward.

As you move into the next article on dictionary and set comprehensions, you'll see these same ideas applied to other collection types. The syntax is nearly identical, but the use cases shift in interesting ways, especially for building lookup tables and deduplication pipelines, which are bread-and-butter operations in data preprocessing. Keep the patterns from this article in mind, and the next one will click immediately.