How does itertools.product with repeat= replace nested for loops in Python?

### What the Cartesian product is The Cartesian product of several iterables is every way of picking one element from each, in order. `itertools.product` yields those picks as tuples. With two arguments it is a pair of nested loops; with k arguments it is k nested loops; and the ordering matches the loops exactly, with the last position cycling fastest and the first position changing most slowly. ```python from itertools import product # these two loops produce identical sequences for a in 'xy': for b in [0, 1]: print((a, b)) for pair in product('xy', [0, 1]): print(pair) ``` ### What repeat= buys you `repeat=n` repeats the whole argument list n times before taking the product. `product([0, 1], repeat=3)` is literally `product([0, 1], [0, 1], [0, 1])`, and it enumerates all eight three-bit patterns. `product(a, b, repeat=2)` is `product(a, b, a, b)`. The reason this matters is not brevity but **parameterization**. Nested `for` loops encode their depth in the source text: three levels of indentation can only ever enumerate triples. With `repeat=k`, the depth is an ordinary variable, so the same line of code enumerates pairs, triples or ten-tuples depending on a value computed at runtime. Any time you catch yourself writing a recursive helper whose only job is to build fixed-width tuples from one alphabet, `product(..., repeat=k)` is the flat replacement. It also flattens the code: the loop body sits at one indentation level instead of k, and `break`/`continue` behave straightforwardly against a single loop rather than needing flags or a labelled-loop workaround Python does not have. ### Laziness of the output, eagerness of the input `product` returns an iterator and produces one tuple at a time, so the memory it holds is the input tuples plus the current output tuple. But the **input side is eager**: at construction, each input iterable is converted to a tuple immediately, because the algorithm has to revisit every input element many times over. Two consequences follow. First, a generator passed to `product` is exhausted before a single result is yielded: ```python gen = (x for x in range(3)) p = product(gen, repeat=2) list(gen) # [] — product already drained it len(list(p)) # 9 — the results are all still there ``` Second, an endless iterator cannot be an input: `product` would try to materialize it and never return. Bound such an iterator before passing it in. ### Counts and edge cases The number of tuples is the product of the input lengths — `math.prod([len(a), len(b), len(c)])` — and with `repeat=k` over one iterable of length n it is exactly n**k. That is exponential in the repeat count, which is the thing to compute before iterating: a ten-value list with `repeat=8` is 100 million tuples, no bigger in memory than one tuple but hours of work. Two edge cases interviewers like: * If **any** input is empty, the product is empty — there is no way to pick one element from an empty set, so zero tuples come out. * `product(anything, repeat=0)` yields exactly one item, the empty tuple `()`. That is the mathematically correct empty product, not a bug, and it mirrors `math.prod([]) == 1`. ### product versus its combinatorial neighbours `product` is the one that lets a value repeat *within* a tuple and treats position as meaningful: `product('ab', repeat=2)` gives all four of `('a','a')`, `('a','b')`, `('b','a')`, `('b','b')`. `itertools.permutations` drops the repeats (`('a','a')` cannot occur), `itertools.combinations` drops repeats and orderings, and `itertools.combinations_with_replacement` keeps repeats but drops orderings. Choosing between them is choosing two independent yes/no answers: may an element repeat, and does order matter? ### Where it shows up in real code Grid enumeration is the archetype: every combination of settings in a configuration sweep, every cell of a two-dimensional board, every truth assignment over a set of boolean flags, every pairing of a currency with a region. The mechanical tell in review is a stack of loops all iterating structurally-similar sequences whose only purpose is to assemble a tuple — that stack is a `product` call. The counter-indication is real too. If most of the space is going to be rejected by a condition checked at the first or second level, a hand-written nested loop can skip whole subtrees, while `product` faithfully generates each doomed tuple before your filter sees it. When the pruning matters, split the enumeration or filter the input lists before taking the product.