Python - Split list into all possible tuple pairs

When working with lists, you might need to generate all possible ways to split the list into tuple pairs. This involves creating partitions where elements can either remain as individual items or be grouped into tuples with other elements.

Example

Below is a demonstration of splitting a list into all possible tuple pair combinations ?

def determine_pairings(my_list):
    if len(my_list) <= 1:
        return [my_list]
    
    result = [[my_list[0]] + element for element in determine_pairings(my_list[1:])]
    
    for index in range(1, len(my_list)):
        result.extend([[(my_list[0], my_list[index])] + element for element in determine_pairings(my_list[1: index] + my_list[index + 1:])])
    
    return result

my_list = [56, 31, 78, 0]

print("The list is :")
print(my_list)

my_result = determine_pairings(my_list)

print("The resultant pairs are :")
print(my_result)

Output

The list is :
[56, 31, 78, 0]
The resultant pairs are :
[[56, 31, 78, 0], [56, 31, (78, 0)], [56, (31, 78), 0], [56, (31, 0), 78], [(56, 31), 78, 0], [(56, 31), (78, 0)], [(56, 78), 31, 0], [(56, 78), (31, 0)], [(56, 0), 31, 78], [(56, 0), (31, 78)]]

How It Works

The algorithm uses recursion to generate all possible partitions ?

• Base Case: If the list has 1 or fewer elements, return it as is

• Single Elements: Keep the first element alone and recursively process the rest

• Tuple Pairs: Pair the first element with each remaining element, then recursively process what's left

• Combine Results: Use list comprehension and extend() to merge all possibilities

Alternative Approach Using itertools

You can also use itertools.combinations for a more straightforward approach ?

from itertools import combinations

def simple_pairings(data):
    items = list(range(len(data)))
    results = []
    
    # Generate all possible pair combinations
    for r in range(len(data) + 1):
        for combo in combinations(items, r):
            partition = []
            used = set(combo)
            
            # Add pairs
            for i in range(0, len(combo), 2):
                if i + 1 < len(combo):
                    partition.append((data[combo[i]], data[combo[i + 1]]))
            
            # Add remaining singles
            for i, val in enumerate(data):
                if i not in used:
                    partition.append(val)
            
            if partition:
                results.append(partition)
    
    return results

numbers = [1, 2, 3]
result = simple_pairings(numbers)

for pair in result:
    print(pair)

[1, 2, 3]
[(1, 2), 3]
[(1, 3), 2]
[1, (2, 3)]

Conclusion

Splitting lists into tuple pairs involves recursive partitioning where elements can remain individual or be grouped. The recursive approach explores all combinations systematically, making it useful for combinatorial problems in data analysis.