Python - Convert List to Single Valued Lists in Tuple

Converting a list to a tuple of single-valued lists is a common data transformation in Python. Each element from the original list becomes a separate list containing just that element, and all these lists are wrapped in a tuple. For example, [1, 2, 3] becomes ([1], [2], [3]).

Using List Comprehension and tuple()

List comprehension provides the most readable and Pythonic approach for this transformation ?

demo_list = [1, 2, 3, 4, 5]
print("Initial List:", demo_list)

# Using list comprehension with tuple() function
final_tuple = tuple([x] for x in demo_list)

print("Final Tuple:", final_tuple)

Initial List: [1, 2, 3, 4, 5]
Final Tuple: ([1], [2], [3], [4], [5])

The expression [x] for x in demo_list creates a generator that yields single-element lists. The tuple() function converts this generator into a tuple.

Using map() and lambda

The map() function applies a lambda function to each element, creating single-element lists ?

numbers = [1, 2, 3, 4, 5]
print("Initial List:", numbers)

# Using map with lambda function
output_tuple = tuple(map(lambda x: [x], numbers))

print("Final Tuple:", output_tuple)

Initial List: [1, 2, 3, 4, 5]
Final Tuple: ([1], [2], [3], [4], [5])

The lambda function lambda x: [x] wraps each element in a list, and map() applies this to every element in the input list.

Using a for Loop

A traditional approach using iteration and the append() method ?

input_list = [1, 2, 3, 4, 5]
print("Initial List:", input_list)

result_list = []
for item in input_list:
    result_list.append([item])

output_tuple = tuple(result_list)
print("Final Tuple:", output_tuple)

Initial List: [1, 2, 3, 4, 5]
Final Tuple: ([1], [2], [3], [4], [5])

This method creates an empty list, iterates through each element, appends it as a single-element list, and finally converts the result to a tuple.

Using Recursion

A recursive approach that builds the tuple by processing one element at a time ?

def convert_to_single_lists(input_list):
    if not input_list:
        return ()
    else:
        return ([input_list[0]],) + convert_to_single_lists(input_list[1:])

demo_list = [1, 2, 3, 4, 5]
output_tuple = convert_to_single_lists(demo_list)

print("Input list:", demo_list)
print("Output tuple:", output_tuple)

Input list: [1, 2, 3, 4, 5]
Output tuple: ([1], [2], [3], [4], [5])

The recursive function processes the first element by wrapping it in a list and tuple, then recursively processes the remaining elements.

Performance Comparison

Conclusion

List comprehension offers the best combination of readability and performance for converting a list to single-valued lists in a tuple. The map() approach is equally efficient but less readable, while recursion should be avoided due to its poor performance characteristics.