Nested Loops in Python — 400M Comparisons ETL Nightmare

Nested loops in Python multiply iterations, turning a 20,000-record ETL job into 400 million comparisons that run for 11 hours. The fix is replacing the inner loop with a set lookup, dropping complexity from O(n³) to O(n) and cutting runtime to minutes. This pattern—combinatorial explosion from naive nesting—is the most common performance killer in data processing pipelines. Understanding when nested loops are appropriate and when they signal a need for hash-based lookups or algorithmic changes is essential for writing production-grade Python.

When One Loop Inside Another Becomes an O(n²) Trap

A nested loop is a loop placed inside the body of another loop. For each iteration of the outer loop, the inner loop runs completely from start to end. This creates a multiplicative effect on total iterations: if the outer loop runs n times and the inner loop runs m times, the total operations are n × m. When both loops iterate over the same dataset of size n, complexity becomes O(n²).

In practice, this means a list of 20,000 items processed with a naive nested loop performs 400 million comparisons. That's not a theoretical limit — it's a real wall. Python's loop overhead (attribute lookups, bytecode dispatch) makes O(n²) algorithms degrade sharply beyond a few thousand elements. The inner loop's body executes n times more often than the outer loop's, so any expensive operation inside the inner loop is magnified.

Use nested loops when the problem genuinely requires comparing every pair of elements — for example, checking all pairs for duplicates, computing a distance matrix, or brute-force search in a small fixed-size grid. For any production system processing more than a few thousand records, nested loops are a red flag. They signal that you likely need a hash-based lookup, sorting, or an index to reduce complexity to O(n) or O(n log n).

Basic Nested Loop — How Iterations Multiply

The outer loop controls rows, the inner loop controls columns. Every time the outer loop ticks once, the inner loop runs to completion. This multiplication of iterations is the fundamental concept.

For i in range(3) runs 3 times. For j in range(4) runs 4 times. Nested: 3 × 4 = 12 total iterations. This scales fast: range(100) × range(100) = 10,000 iterations. range(10000) × range(10000) = 100,000,000 iterations. That last one will take minutes or hours depending on what's inside the loop.

Always think in terms of total iterations: outer_count × inner_count. If that product is more than about 10 million, you probably need a different approach.

# io.thecodeforge: Basic Nested Loop — Multiplication Table
total_iterations = 0

for i in range(1, 4):
    for j in range(1, 4):
        print(f'{i} x {j} = {i * j}', end='   ')
        total_iterations += 1
    print()

print(f'\nTotal iterations: {total_iterations}')
print(f'Formula: 3 outer x 3 inner = {3*3}')

print()

# Scaling warning — show how fast it grows
print('=== Iteration Scaling ===')
for n in [10, 100, 1000, 10000]:
    total = n * n
    print(f'range({n:>5}) x range({n:>5}) = {total:>12,} iterations')

Iterating Over a 2D List — The Most Natural Use Case

The most natural use of nested loops is walking through a matrix or a list of lists. The outer loop picks the row, the inner loop picks the column. This pattern shows up everywhere: image processing (pixel grids), spreadsheet data (rows and columns), game boards (chess, tic-tac-toe), and database result sets.

Use enumerate() when you need both the index and the value. Using a manual counter variable instead of enumerate() works but is less Pythonic and more error-prone.

# io.thecodeforge: 2D List Iteration Patterns
# Real-world patterns for processing matrices and grids

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

# Pattern 1: Sum all elements
total = 0
for row in matrix:
    for value in row:
        total += value
print(f'Sum of all elements: {total}')  # 45

print()

# Pattern 2: Find position of a value (using enumerate for indices)
target = 5
for row_idx, row in enumerate(matrix):
    for col_idx, value in enumerate(row):
        if value == target:
            print(f'Found {target} at row={row_idx}, col={col_idx}')

print()

# Pattern 3: Transpose a matrix (swap rows and columns)
rows = len(matrix)
cols = len(matrix[0])
transposed = []
for col in range(cols):
    new_row = []
    for row in range(rows):
        new_row.append(matrix[row][col])
    transposed.append(new_row)

print('Original:')
for row in matrix:
    print(f'  {row}')
print('Transposed:')
for row in transposed:
    print(f'  {row}')

print()

# Pattern 4: Process CSV-like data (rows = records, columns = fields)
students = [
    ['Alice', 92, 88, 95],
    ['Bob',   78, 85, 80],
    ['Carol', 95, 91, 97],
]

print('Student Averages:')
for student in students:
    name = student[0]
    scores = student[1:]
    avg = sum(scores) / len(scores)
    print(f'  {name}: {avg:.1f}')

Mixed Loop Nesting — for, while, and Combinations

Most tutorials only show for-inside-for. But production code uses all combinations: for-inside-while, while-inside-for, and while-inside-while. Each combination has a specific use case.

for inside while: Use when the outer condition is dynamic (like reading from a stream) but the inner iteration is fixed (like processing each field in a record).

while inside for: Use when iterating over a collection but each item requires a variable number of steps (like retrying an API call until it succeeds).

while inside while: Rare but useful for multi-stage processing where both stages have dynamic termination conditions.

The key with mixed nesting: make sure every loop has a guaranteed exit condition. A while loop inside a for loop where the while condition never becomes false is an infinite loop that will freeze your program.

# io.thecodeforge: Mixed Loop Nesting Patterns
# Real-world combinations of for and while loops

# Pattern 1: for inside while — processing a stream of records
# Outer: keep reading until stream is empty (dynamic)
# Inner: process fixed fields in each record (fixed)
print('=== Pattern 1: for inside while ===')
records = [
    {'name': 'Alice', 'scores': [90, 85, 92]},
    {'name': 'Bob',   'scores': [78, 82, 80]},
]

record_index = 0
while record_index < len(records):
    record = records[record_index]
    print(f"Processing {record['name']}:")
    for score in record['scores']:
        print(f'  Score: {score}')
    record_index += 1

print()

# Pattern 2: while inside for — retry logic per item
# Outer: iterate over API endpoints (fixed collection)
# Inner: retry until success or max attempts (dynamic)
print('=== Pattern 2: while inside for (retry pattern) ===')
endpoints = ['users', 'orders', 'products']

for endpoint in endpoints:
    attempt = 0
    max_attempts = 3
    success = False
    while attempt < max_attempts and not success:
        attempt += 1
        # Simulate: succeed on attempt 2 for 'orders', first attempt for others
        if endpoint == 'orders' and attempt < 2:
            print(f'  {endpoint}: attempt {attempt} failed, retrying...')
        else:
            success = True
            print(f'  {endpoint}: success on attempt {attempt}')

print()

# Pattern 3: Nested for with zip — parallel iteration
print('=== Pattern 3: Parallel iteration with zip ===')
products = ['Widget A', 'Widget B', 'Widget C']
prices = [29.99, 49.99, 19.99]
quantities = [3, 1, 5]

for product, price, qty in zip(products, prices, quantities):
    total = price * qty
    print(f'{product}: {qty} x ${price:.2f} = ${total:.2f}')

break and continue in Nested Loops — The Scope Trap

Here is where most beginners hit a wall: break only exits the innermost loop it is in, not all loops. continue only skips to the next iteration of the innermost loop. Neither affects outer loops.

This is the #1 source of 'my code doesn't stop when I expect it to' bugs with nested loops. If you break inside the inner loop, the outer loop keeps running.

To exit ALL nested loops, you have three options: 1. Flag variable — set a flag in the inner loop, check it in the outer loop 2. Function + return — wrap the loops in a function and use return to exit everything 3. Exception — raise and catch an exception (hacky, not recommended)

The function approach is the cleanest and most Pythonic. The flag approach works but adds clutter.

# io.thecodeforge: break and continue in Nested Loops
# Shows scope limitations and workarounds

# DEMO 1: break only exits the inner loop
print('=== break exits inner loop only ===')
for i in range(3):
    for j in range(3):
        if j == 1:
            break  # exits inner loop only — outer loop keeps going
        print(f'i={i}, j={j}')
print('Outer loop continued after break\n')
# Output: i=0,j=0 / i=1,j=0 / i=2,j=0
# j never reaches 1 or 2, but all 3 outer iterations complete

# DEMO 2: continue skips current inner iteration only
print('=== continue skips inner iteration only ===')
for i in range(3):
    for j in range(3):
        if j == 1:
            continue  # skips j=1, continues with j=2
        print(f'i={i}, j={j}')
print()
# Output: j=0 and j=2 for every i — j=1 is skipped each time

# DEMO 3: Flag variable — exit both loops
print('=== Flag variable to exit both loops ===')
found = False
for i in range(5):
    for j in range(5):
        if i * j > 6:
            found = True
            break  # exits inner loop
    if found:
        break  # exits outer loop too
print(f'Stopped at i={i}, j={j} (product={i*j})\n')

# DEMO 4: Function + return — cleanest approach
print('=== Function + return (recommended) ===')
def find_first_value_above(matrix, threshold):
    """Search a 2D matrix and return the first value above threshold."""
    for i, row in enumerate(matrix):
        for j, val in enumerate(row):
            if val > threshold:
                return i, j, val  # exits ALL loops instantly
    return None  # nothing found

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
result = find_first_value_above(matrix, 5)
print(f'First value > 5: {result}')

Pattern Printing — The Classic Nested Loop Exercise

If you've ever taken a programming course, you've printed triangles of stars with nested loops. It looks like a toy exercise, but it teaches something genuinely important: the outer loop controls the number of rows, and the inner loop controls what happens in each row.

The key insight: the inner loop's range often depends on the outer loop's current value. In a right triangle of stars, row 1 prints 1 star, row 2 prints 2 stars, row 5 prints 5 stars. The inner loop's range is range(1, i+1) — it changes every iteration of the outer loop.

This pattern of 'inner loop range depends on outer loop variable' shows up in real code too: comparing every pair of items, building triangular matrices, generating combinations.

# io.thecodeforge: Pattern Printing with Nested Loops
# Classic exercises that teach inner-loop-range-dependency

rows = 5

# Pattern 1: Right triangle
print('=== Right Triangle ===')
for i in range(1, rows + 1):
    for j in range(i):
        print('*', end='')
    print()

print()

# Pattern 2: Inverted right triangle
print('=== Inverted Right Triangle ===')
for i in range(rows, 0, -1):
    for j in range(i):
        print('*', end='')
    print()

print()

# Pattern 3: Pyramid (centered)
print('=== Pyramid ===')
for i in range(1, rows + 1):
    # Print leading spaces
    for space in range(rows - i):
        print(' ', end='')
    # Print stars
    for star in range(2 * i - 1):
        print('*', end='')
    print()

print()

# Pattern 4: Number triangle
print('=== Number Triangle ===')
for i in range(1, rows + 1):
    for j in range(1, i + 1):
        print(j, end=' ')
    print()

Flattening and Comprehensions — Pythonic Nested Loops

A common task — turning a list of lists into a flat list. You can do it with explicit nested loops, but Python offers cleaner alternatives.

List comprehensions can express nested loops in one line. The syntax reads left-to-right like the loop version: [item for sublist in nested for item in sublist] means 'for each sublist, for each item in that sublist, keep the item.' The order matches the nested for loop — outer first, inner second.

itertools.chain.from_iterable is the fastest option for flattening because it's implemented in C and uses lazy evaluation — no intermediate lists are built.

Use the explicit loop when the logic is complex. Use the comprehension when it's a simple transform. Use itertools when performance matters on large datasets.

# io.thecodeforge: Flattening and Comprehension Patterns

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

# Method 1: Explicit nested loop
flat_loop = []
for sublist in nested:
    for item in sublist:
        flat_loop.append(item)
print(f'Explicit loop:   {flat_loop}')

# Method 2: List comprehension — same result, one line
flat_comp = [item for sublist in nested for item in sublist]
print(f'Comprehension:   {flat_comp}')

# Method 3: itertools.chain — fastest for large lists
import itertools
flat_chain = list(itertools.chain.from_iterable(nested))
print(f'itertools.chain: {flat_chain}')

print()

# Nested comprehension with filtering
# Get all even numbers from a 2D list
evens = [val for row in nested for val in row if val % 2 == 0]
print(f'Even numbers: {evens}')

print()

# Cartesian product — every combination of two lists
# This is what nested loops really do under the hood
letters = ['a', 'b', 'c']
numbers = [1, 2, 3]
pairs = [(l, n) for l in letters for n in numbers]
print(f'Cartesian product: {pairs}')

Performance — When Nested Loops Become a Production Problem

Two nested loops over n items = O(n²). That's manageable for n=100 but slow at n=10,000 and unusable at n=1,000,000. Three nested loops = O(n³). Each additional nesting level multiplies the cost.

The most common production performance fix: replace an inner loop with a set or dictionary lookup. If you're looping through list A and for each item looping through list B to check if it exists, you can convert list B to a set and do if item in set_B — turning O(n×m) into O(n+m).

I once debugged a duplicate detection system that compared every record against every other record using nested loops. With 50,000 records, that's 2.5 billion comparisons. The system ran for 4 hours on every batch. The fix: sort the records first, then compare only adjacent items. Same result, O(n log n) instead of O(n²). Runtime dropped from 4 hours to 12 seconds.

The takeaway: before you write a nested loop, calculate total iterations. If it's over 10 million, you need a better algorithm.

# io.thecodeforge: Nested Loop Performance Patterns
# Real-world optimization examples

import time
import random

# BAD: O(n²) duplicate check
print('=== BAD: O(n²) Duplicate Detection ===')
items = list(range(10000))
# Add a few duplicates
items.append(5000)
items.append(8000)

def find_duplicates_slow(items):
    duplicates = []
    n = len(items)
    for i in range(n):
        for j in range(i + 1, n):
            if items[i] == items[j]:
                duplicates.append(items[i])
    return duplicates

# GOOD: O(n) using a set
print('=== GOOD: O(n) Set-Based Duplicate Detection ===')
def find_duplicates_fast(items):
    seen = set()
    duplicates = set()
    for item in items:
        if item in seen:
            duplicates.add(item)
        else:
            seen.add(item)
    return list(duplicates)

# BAD: Nested loop lookup
def find_matches_slow(list_a, list_b):
    matches = []
    for a in list_a:
        for b in list_b:
            if a == b:
                matches.append(a)
    return matches

# GOOD: Set-based lookup
def find_matches_fast(list_a, list_b):
    set_b = set(list_b)
    return [a for a in list_a if a in set_b]

# PAIR COMPARISON: j = i+1 pattern
print('=== Pair Comparison: Avoid Double-Counting ===')
items = ['A', 'B', 'C', 'D']

# BAD: compares each pair twice (A-B and B-A)
print('BAD: O(n²) with double counting:')
for i in range(len(items)):
    for j in range(len(items)):
        if i != j:
            print(f'  Compare {items[i]} vs {items[j]}')

# GOOD: each pair once
print('\nGOOD: O(n²/2) with single counting:')
for i in range(len(items)):
    for j in range(i + 1, len(items)):
        print(f'  Compare {items[i]} vs {items[j]}')

Real-World Patterns — Where Nested Loops Actually Live

Theory is fine, but here are the patterns where nested loops appear in real code every day:

1. CSV/Excel Processing: For each row, for each column, validate/transform data. This is exactly the 200k row × 40 column pipeline that took 11 hours before optimization.

2. Duplicate Detection: For each record, check against every other record to find duplicates. This is the classic O(n²) trap. The fix is hashing or sorting.

3. Cartesian Product: Generate all combinations of options. Product catalog: sizes × colors × styles = all SKUs. This is intentional O(n×m×p) and is fine when the product dimensions are small.

4. Adjacent Comparisons: For i in range(n-1): compare item[i] with item[i+1]. This is O(n) not O(n²). Often used in time-series analysis to detect spikes.

5. Matrix Operations: Adding two matrices, finding the maximum, transposing. These are naturally O(rows × cols) and unavoidable.

# io.thecodeforge: Real-World Nested Loop Patterns

print('=== Pattern 1: CSV Validation ===')
csv_data = [
    ['Alice', '25', 'alice@example.com'],
    ['Bob', 'invalid', 'bob@example.com'],
    ['Carol', '30', 'not-an-email'],
]

for row_idx, row in enumerate(csv_data):
    name, age_str, email = row
    errors = []
    try:
        age = int(age_str)
        if age < 0 or age > 120:
            errors.append('age out of range')
    except ValueError:
        errors.append('age not a number')
    if '@' not in email or '.' not in email:
        errors.append('invalid email format')
    if errors:
        print(f'Row {row_idx + 1}: {", ".join(errors)}')

print('\n=== Pattern 2: Duplicate Detection with Hashing ===')
# Instead of O(n²) nested loops, use a set
users = [
    {'id': 1, 'email': 'alice@example.com'},
    {'id': 2, 'email': 'bob@example.com'},
    {'id': 3, 'email': 'alice@example.com'},  # duplicate email
    {'id': 4, 'email': 'carol@example.com'},
]

seen_emails = {}
for user in users:
    email = user['email']
    if email in seen_emails:
        print(f'Duplicate email "{email}": user {seen_emails[email]} and user {user["id"]}')
    else:
        seen_emails[email] = user['id']

print('\n=== Pattern 3: Cartesian Product (SKU Generation) ===')
sizes = ['S', 'M', 'L']
colors = ['Red', 'Blue']
styles = ['Crew', 'V-Neck']

skus = []
for size in sizes:
    for color in colors:
        for style in styles:
            sku = f'{size}-{color}-{style}'
            skus.append(sku)
print(f'{len(skus)} SKUs generated:')
for sku in skus[:5]:  # show first 5 only
    print(f'  {sku}')
print('  ...')

print('\n=== Pattern 4: Adjacent Comparison (Time Series Spikes) ===')
metrics = [100, 102, 105, 200, 101, 98, 95]
for i in range(1, len(metrics)):
    prev = metrics[i - 1]
    curr = metrics[i]
    if curr > prev * 1.5:  # 50% spike
        print(f'Spike at position {i}: {prev} → {curr}')

Variable Scoping in Nested Loops — Where Python Bites You

Most devs assume loop variables are local to the loop block. Python doesn't work that way. A variable created inside an inner loop leaks to the enclosing scope. This isn't a bug—it's how Python's scoping rules work. But it will torch your code if you reuse variable names carelessly. The inner loop's iterator variable persists after the outer loop finishes. That means if you name a variable i in both loops, the outer i gets overwritten. You lose the outer loop's last value. This causes subtle off-by-one errors in production systems, especially when you're processing nested data streams. The fix: use unique variable names per nesting level. Python 3.12's PEP 709 introduced except* scoping improvements, but loop scoping remains unchanged. Don't fight the language—use distinct names like row_idx and col_idx to keep your state predictable.

// io.thecodeforge — python tutorial

# Demonstrates variable scoping leakage in nested loops

def find_value(matrix, target):
    for i, row in enumerate(matrix):
        for j, val in enumerate(row):
            if val == target:
                print(f"Found at ({i}, {j})")
    # After the loops, 'j' is still alive
    # If loop never ran, 'j' would be undefined
    print(f"Outer loop last index: {i}, \
Inner loop last index: {j}")  # Works, but dangerous

if __name__ == "__main__":
    data = [[1, 2], [3, 4]]
    find_value(data, 3)

Generating Pairwise Combinations — The Pythonic Way Without Nested Bruteforce

You need all unique pairs from a list. The instinct? Two nested for loops. That works, but it's O(n²) and includes self-pairs and duplicates if you're not careful. Production code uses itertools.combinations. It handles index management, eliminates mirror pairs, and produces a generator—so no memory explosion for large lists. The combinatoric explosion is real: 10,000 items means 50 million pairs. A nested loop will kill your memory and runtime. combinations gives you the same result in a fraction of the code, with C-level speed. This isn't just cleaner; it's safer. You avoid off-by-one errors and the temptation to prematurely optimize with manual index arithmetic. When you need cartesian products or permutations, itertools has those too. Stop writing custom nested loops for combinatorial logic—it's a solved problem.

// io.thecodeforge — python tutorial

# Bad: manual nested loop for pairs

team_members = ["alice", "bob", "charlie", "diana"]
pairs = []
for i in range(len(team_members)):
    for j in range(i + 1, len(team_members)):
        pairs.append((team_members[i], team_members[j]))
print(pairs)

# Pythonic: itertools.combinations

from itertools import combinations

pairs = list(combinations(team_members, 2))
print(pairs)

Nested Loops That Read Like a Crime Scene — Fix the Noise

Nested loops go from bad to unreadable faster than a bad merge request. When you shove three levels of indentation with variable names like i, j, k, you are writing code that will be blamed on you in a postmortem. The WHY is simple: humans read top-to-bottom, not zig-zag. Deeply nested loops break that flow.

The fix is not to avoid nesting — sometimes it's the right tool. The fix is extraction. Pull that inner block into a function with a name that says what it does. validate_cell(grid, row, col) beats three lines of index arithmetic every time. Also, consider breaking early with continue or break once your condition is met. Every extra iteration past a solved problem is noise.

If your loop body exceeds a screen height, you've already lost. Senior engineers treat nested loops like a sharp knife — useful, but you keep your fingers clear.

// io.thecodeforge — python tutorial

def cell_has_conflict(grid, row, col, value):
    for c in range(len(grid[0])):
        if grid[row][c] == value:
            return True
    for r in range(len(grid)):
        if grid[r][col] == value:
            return True
    return False

grid = [
    [5, 3, 0],
    [6, 0, 0],
    [0, 9, 8]
]

row, col, value = 0, 2, 7
if cell_has_conflict(grid, row, col, value):
    print(f"Conflict: {value} at row {row}, col {col}")
else:
    print(f"Safe to place {value}")

O(n²) Is a Cost Center — How to Spot and Snuff Bottlenecks

Nested loops burn CPU cycles like a bad crypto miner. Every production outage I've seen that wasn't a DB spike traced back to a nested loop over a list that should have been a hash lookup. The WHY is mathematics: if you have 1000 items and you nest two loops, that's a million iterations. For 10k items, it's 100 million. Your users feel that.

The first step is profiling. Do not guess. Use Python's built-in timeit or a profiler. The second step is data structure replacement. Need to check if an item exists while nested? Use a set or a dict. That drops O(n) membership checks to O(1). Third, consider itertools.product for pairwise work — it's not faster, but it's often clearer and easier to refactor into lazy evaluation.

If you still need the nested loop, cache results. Precompute the inner data outside the outer loop. Never recompute the same thing in a hot path. Your CPU will thank you, and your on-call pager will stay silent.

// io.thecodeforge — python tutorial

import time

# Slow: O(n²) due to 'in' over list
users = [f"user_{i}" for i in range(10000)]
blocked = [f"user_{j}" for j in range(100)]

start = time.perf_counter()
def is_blocked_slow(name, blocked_list):
    return name in blocked_list  # O(n) each time

count = 0
for u in users:
    if is_blocked_slow(u, blocked):
        count += 1
print(f"Slow: {count} blocked, took {time.perf_counter()-start:.3f}s")

# Fast: O(n) total using set
blocked_set = set(blocked)
start = time.perf_counter()
count = sum(1 for u in users if u in blocked_set)
print(f"Fast: {count} blocked, took {time.perf_counter()-start:.3f}s")

itertools.product: Flattening Nested Loops

When you have multiple independent iterables and need to iterate over all combinations, nested loops can become deeply nested and hard to read. Python's itertools.product provides a clean, efficient way to flatten these loops into a single iterator. Instead of writing:

``python for i in range(10): for j in range(10): for k in range(10): print(i, j, k) ``

You can write:

```python from itertools import product

for i, j, k in product(range(10), repeat=3): print(i, j, k) ```

This not only reduces nesting but also improves readability and maintainability. product generates tuples lazily, so memory usage is minimal even for large iterables. Performance is comparable to nested loops, but the clarity gain is significant. Use product whenever you need to iterate over the Cartesian product of multiple iterables, especially when the number of iterables is dynamic or large. It's a Pythonic way to avoid deeply nested loops and makes the code more declarative.

from itertools import product

# Instead of nested loops:
# for i in range(3):
#     for j in range(4):
#         print(i, j)

for i, j in product(range(3), range(4)):
    print(i, j)

Nested List Comprehensions: Readability vs Performance

Nested list comprehensions allow you to write compact code for generating lists from nested loops. For example, creating a 2D grid:

``python matrix = [[i * j for j in range(5)] for i in range(5)] ``

This is concise and Pythonic, but it can become unreadable when the nesting is deep or the logic is complex. Performance-wise, list comprehensions are generally faster than equivalent nested loops because they avoid the overhead of repeated append calls. However, they create the entire list in memory, which can be a problem for large datasets. For large-scale data, consider using generator expressions or itertools.product to avoid memory bloat. The trade-off is readability: a deeply nested comprehension like:

``python result = [[func(a, b) for b in list_b if condition(b)] for a in list_a if condition(a)] ``

can be hard to debug. In production, prioritize clarity over brevity. Use nested comprehensions for simple, small-scale transformations, but refactor complex logic into helper functions or explicit loops.

# Nested list comprehension
matrix = [[i * j for j in range(5)] for i in range(5)]
print(matrix)

# Equivalent nested loop
matrix = []
for i in range(5):
    row = []
    for j in range(5):
        row.append(i * j)
    matrix.append(row)

Breaking Out of Nested Loops: Patterns and Alternatives

Breaking out of nested loops in Python is tricky because break only exits the innermost loop. Common patterns to break out of multiple levels include using flags, exceptions, or refactoring into functions. For example, using a flag:

``python found = False for i in range(10): for j in range(10): if condition(i, j): found = True break if found: break ``

A more Pythonic approach is to use for...else with a break flag, or wrap the loops in a function and use return. Another alternative is to use itertools.product and break from a single loop:

```python from itertools import product

for i, j in product(range(10), range(10)): if condition(i, j): break ```

This avoids the need for flags entirely. For complex scenarios, consider using exceptions as a control flow mechanism, but use sparingly as it can be considered non-Pythonic. The best practice is to refactor nested loops into a generator or function that yields results, allowing early termination via return or break in the outer loop.

# Using a flag
found = False
for i in range(10):
    for j in range(10):
        if i * j > 50:
            found = True
            break
    if found:
        break

# Using itertools.product
from itertools import product
for i, j in product(range(10), range(10)):
    if i * j > 50:
        break