Why do I need combinations and combinations_with_replacement?

In Python, generating all possible combinations of items from a list is a common task—think of picking teams, selecting lottery numbers, or even solving combinatorial puzzles. Without itertools, you’d likely end up writing nested loops or recursive functions, which can get messy fast.

With itertools.combinations and itertools.combinations_with_replacement, you get clean, efficient, and built-in ways to handle these scenarios. The key difference? combinations picks unique subsets without repeating elements, while combinations_with_replacement allows elements to be reused. Let’s break it down with examples.

Example without itertools

Suppose you’re organizing a dinner party and need to pick 2 dishes from a menu of 3: salad, pasta, and steak. Without itertools, you might write something like this:

menu = ['salad', 'pasta', 'steak']
pairs = []

for i in range(len(menu)):
    for j in range(i + 1, len(menu)):  # i + 1 to avoid duplicates and self-pairs
        pairs.append((menu[i], menu[j]))

print(pairs)

Output:

[('salad', 'pasta'), ('salad', 'steak'), ('pasta', 'steak')]

This works, but it’s clunky. What if you need 3 dishes instead of 2? The code gets uglier with more loops. Now imagine you’re okay with repeats—like serving two salads. You’d need even more logic to handle that case.

Example with itertools.combinations

Here’s how itertools.combinations simplifies the same task:

from itertools import combinations

menu = ['salad', 'pasta', 'steak']
pairs = list(combinations(menu, 2))  # 2 is the size of each combination

print(pairs)

Output:

[('salad', 'pasta'), ('salad', 'steak'), ('pasta', 'steak')]

Boom—done in one line. The combinations function takes an iterable (like a list) and an integer r (the size of each subset) and returns an iterator of all possible combinations, where order doesn’t matter and elements aren’t repeated within a combination. No loops, no fuss.

Example with itertools.combinations_with_replacement

Now, what if you’re fine with repeating dishes—like two salads? Enter combinations_with_replacement:

from itertools import combinations_with_replacement

menu = ['salad', 'pasta', 'steak']
pairs = list(combinations_with_replacement(menu, 2))

print(pairs)

Output:

[('salad', 'salad'), ('salad', 'pasta'), ('salad', 'steak'), ('pasta', 'pasta'), ('pasta', 'steak'),
 ('steak', 'steak')]

Notice how it includes pairs like ('salad', 'salad'). This function works like combinations, but it allows elements to be reused within each subset. It’s perfect for scenarios where repetition is valid, like picking multiple scoops of ice cream (two vanillas? Why not!).

Digging deeper

Both functions are memory-efficient because they return iterators—you can process results one at a time instead of building a full list upfront (just drop the list() call if you don’t need everything at once). The Python docs explain their behavior clearly:

• combinations(iterable, r): Returns r-length tuples in sorted order, no repeated elements.
• combinations_with_replacement(iterable, r): Same, but allows individual elements to be repeated.

For example, with combinations('ABC', 2), you get ('A', 'B'), ('A', 'C'), ('B', 'C').

With combinations_with_replacement('ABC', 2), you get

('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'B'), ('B', 'C'), ('C', 'C').

Conclusion

While you could write your own combination logic, why reinvent the wheel? itertools.combinations and combinations_with_replacement offer concise, readable, and efficient solutions for generating subsets. They’re especially handy in mathematical computations, data analysis, or any situation where you need to explore possibilities without drowning in loops.

As the itertools docs put it, these functions are “roughly equivalent to” nested loops or recursive algorithms—but optimized and battle-tested. By using them, you keep your code clean and let Python’s standard library do the heavy lifting. So next time you’re picking pairs, teams, or flavors, give itertools a spin!