How can I match up permutations of a long list with a shorter list (according to the length of the shorter list)?

Harnessing itertools.product // When combinations are key!

Need all possible pairings between lists of different length? Your best friend here is itertools.product:

import itertools

long_list = ['a', 'b', 'c', 'd']
short_list = [1, 2]

pairs = itertools.product(long_list, repeat=len(short_list))
unique_combinations = set(pairs)  # Collect 'em all! No duplicates allowed.

for combo in unique_combinations:
    print(combo)  # Enjoy these lovely pairings. No two alike!


This ensures unique combinations and allows items from the short_list to pair with any from the long_list.

Dealing with changing list length // Squaring the circle!

Custom-sized permutations

Imagine you only want permutations of a long_list up to the length of your short_list. Here's how to do it:

from itertools import permutations

# Spot on perms!
perms = permutations(long_list, len(short_list))


By determining the length, we trim our permutations to the short list's measure.

Unique combinations

Here's how to compile unique combinations of elements without repetition:

from itertools import combinations

# No repeats, radio!
combos = combinations(long_list, len(short_list))


The itertools.combinations function tackles this pristine.

Repeat-friendly combinations

To allow repeated elements in the short_list:

from itertools import combinations_with_replacement

# Double trouble allowed!
repeat_combos = combinations_with_replacement(short_list, len(long_list))


combinations_with_replacement lets redundancies slide.

Example of matching permutations:

🧀🥕🍅 ➡️ 🥔🧅🥕 ➡️ 🍗🍅🧀➡️ (No, we're not making a salad)

✅ Matching Set: 🥕Carrot, 🧀Cheese, 🍗Chicken (There's our yummy recipe!)

Each trial presents a permutation checked against the recipe.

Forget MasterChef, we're programming our perfect culinary escapade!

Banishing duplicates // One is enough

Quick unique results

Send duplicates packing by converting itertools.product results directly to a set:

unique_combinations = set(itertools.product(long_list, repeat=len(short_list)))  # No room for clones!


Post-generation cleanup

Or, if you must cast out duplicates post-generation:

unique_combinations = set()
for combo in itertools.product(long_list, repeat=len(short_list)):
    unique_combinations.add(combo)  # Leave no stone (or duplicate) unturned.


Displaying your results // The showstopper

Neat and tidy with pprint

For displaying combinations in all their glory:

from pprint import pprint

pprint(list(itertools.product(long_list, repeat=len(short_list))))  # Ah, such organizational bliss!


pprint aids in formatting the output for easier legibility.

Recursion or Iteration // To dive or to step?

When it comes to efficiency, choosing between recursion and iteration can be critical. It's the difference between gracefully diving into a solution or carefully stepping towards it. With itertools, we mostly step.