Python - Convert a list into tuple of lists

When working with data structures in Python, there are times when we need to convert a list into a tuple of smaller lists.

For example, given a list [1, 2, 3, 4, 5, 6], we may want to split it into a tuple of two lists like ([1, 2, 3], [4, 5, 6]). We will explore different methods to achieve this conversion.

Using slicing

This method is simple and relies on Python's list slicing capabilities. It allows us to split the original list into sublists based on specified indices.

# Input list
a = [1, 2, 3, 4, 5, 6]
# Split the list into two parts using slicing
res = (a[:3], a[3:])
print(res)  

([1, 2, 3], [4, 5, 6])

Explanation:

• We use slicing to divide the list a into two parts: one containing the first three elements and the other containing the rest.
• The sliced sublists are then packed into a tuple.
• This method is efficient and works well for scenarios where we know the split indices.

Let's explore some more methods and see how we can convert a list into tuples of lists.

Using zip() with iterators

This method utilizes zip() and iterators to group elements from the list into smaller lists dynamically.

a = [1, 2, 3, 4, 5, 6]
# Split the list using zip and iterators
res = tuple(zip(a[:len(a)//2], a[len(a)//2:]))
print(res)  

((1, 4), (2, 5), (3, 6))

Explanation:

• zip() function pairs elements from the first half of the list with elements from the second half.
• This method is useful when we want a pair-wise grouping of elements.

Using list comprehension

This method provides a compact way to achieve the desired result using list comprehension.

a = [1, 2, 3, 4, 5, 6]
# Split the list into a tuple of sublists
res = tuple([a[i::2] for i in range(2)])
print(res)  

([1, 3, 5], [2, 4, 6])

Explanation:

• We use list comprehension to create two sublists: one containing elements at even indices and the other at odd indices.
• These sublists are then packed into a tuple.
• This method is flexible and compact but may be less intuitive than slicing.

Using a loop

We can use a for loop, especially when the size of the sublists needs to be calculated dynamically.

a = [1, 2, 3, 4, 5, 6]
# Initialize an empty tuple
res = ()
# Determine the split index
split_index = len(a) // 2
# Create the sublists and add them to the tuple
res += (a[:split_index], a[split_index:])
print(res) 

([1, 2, 3], [4, 5, 6])

Explanation:

• We calculate the split index dynamically as half the length of the list.
• We use slicing to create the sublists and then add them to the tuple.
• This method provides flexibility for handling lists where the split index is determined programmatically.