name: iterate-with-itertools description: "For combinatorial iteration: permutations, combinations, cartesian products, without storing all results in memory."

iterate-with-itertools

When to Use

• Need all permutations of a sequence
• Need all combinations of k items
• Need cartesian product of multiple sequences
• Chaining multiple iterables
• Grouping consecutive elements

When NOT to Use

• Simple loop is clearer
• Only need a few specific elements
• Need random access to results

The Pattern

Use itertools for memory-efficient iteration over combinatorial structures.

from itertools import permutations, combinations, product, chain

# Permutations: all orderings
list(permutations('ABC'))
# [('A','B','C'), ('A','C','B'), ('B','A','C'), ...]

# Combinations: all subsets of size k
list(combinations('ABCD', 2))
# [('A','B'), ('A','C'), ('A','D'), ('B','C'), ('B','D'), ('C','D')]

# Product: cartesian product
list(product('AB', '12'))
# [('A','1'), ('A','2'), ('B','1'), ('B','2')]

# Chain: concatenate iterables
list(chain([1,2], [3,4], [5]))
# [1, 2, 3, 4, 5]

# All are lazy - generate on demand
for perm in permutations(range(10)):  # 3.6M permutations
    if is_valid(perm):
        break  # Stop early, don't generate rest

Example (from pytudes)

from itertools import permutations, combinations, product

# TSP: try all tours (TSP.ipynb)
def brute_force_tsp(cities):
    start, *rest = cities
    return min(
        ([start] + list(perm) for perm in permutations(rest)),
        key=tour_length
    )

# Card hands (Probability.ipynb)
deck = [r + s for r in 'A23456789TJQK' for s in 'SHDC']
hands = combinations(deck, 5)  # 2.6M hands, lazy

# Dice rolls (Probability.ipynb)
def roll(n, sides=6):
    """Distribution of sums from rolling n dice."""
    from collections import Counter
    die = range(1, sides + 1)
    return Counter(sum(roll) for roll in product(die, repeat=n))

# Expression building (Countdown.ipynb)
for L, R in product(left_expressions, right_expressions):
    for op in ['+', '-', '*', '/']:
        combine(L, op, R)

# Splits of a sequence
def splits(sequence):
    """All ways to split sequence into two non-empty parts."""
    return ((sequence[:i], sequence[i:])
            for i in range(1, len(sequence)))

Key Principles

1. Lazy by default: itertools returns iterators, not lists
2. product with repeat: product(range(6), repeat=3) for 3 dice
3. combinations_with_replacement: Allow same item multiple times
4. chain.from_iterable: Flatten nested iterables
5. islice for limits: islice(permutations(...), 100) for first 100