This is a quite simple problem but can have a good amount of application due to certain constraints of Python language. Because tuples are immutable, they are not easy to process whereas lists are always a better option while processing. Let’s discuss certain ways in which we can convert a list of tuples to list of list.
Method #1: Using list comprehension
This can easily be achieved using list comprehension. We just iterate through each list converting the tuples to the list.
- Initialize a list of tuples called test_list containing three tuples with two elements each.
- Print the original list of tuples using the print() function and the str() method to convert the list to a string for printing.
- Use a list comprehension to create a new list called res. The list comprehension iterates over each tuple in the test_list, converts each tuple to a list using the list() method, and appends each list to the new res list.
- Print the converted list of lists using the print() function and the str() method to convert the list to a string for printing.
Python3
test_list = [(1, 2), (3, 4), (5, 6)]
print("The original list of tuples : " + str(test_list))
res = [list(ele) for ele in test_list]
print("The converted list of list : " + str(res))
|
Output : The original list of tuples : [(1, 2), (3, 4), (5, 6)]
The converted list of list : [[1, 2], [3, 4], [5, 6]]
Time complexity: The time complexity of this code is O(n), where n is the length of the input list.
Auxiliary space: The auxiliary space complexity of this code is also O(n), where n is the length of the input list.
Method #2: Using map() + list We can use the combination of map function and list operator to perform this particular task. The map function binds each tuple and converts it into list.
Python3
test_list = [(1, 2), (3, 4), (5, 6)]
print("The original list of tuples : " + str(test_list))
res = list(map(list, test_list))
print("The converted list of list : " + str(res))
|
Output : The original list of tuples : [(1, 2), (3, 4), (5, 6)]
The converted list of list : [[1, 2], [3, 4], [5, 6]]
Time complexity: O(n), where n is the length of the input list.
Auxiliary space: O(n), since we are creating a new list of the same length as the input list.
Method #3: Using enumerate function
Python3
test_list = [(1, 2), (3, 4), (5, 6)]
res = [list(ele) for i,ele in enumerate(test_list)]
print(res)
|
Output[[1, 2], [3, 4], [5, 6]]
Time complexity:O(n) and
Auxiliary space: O(n)
Method: Using map function
Python3
test_list = [(1, 2), (3, 4), (5, 6)]
x=list(map(list,test_list))
print(x)
|
Output[[1, 2], [3, 4], [5, 6]]
Method 5: Using numpy library
Algorithm:
- Initialize an empty list res.
- Convert the input list of tuples to a numpy array using np.array() function.
- Convert the numpy array to a list using the tolist() method.
- Store the result in the res list.
- Print the res list.
Python3
import numpy as np
test_list = [(1, 2), (3, 4), (5, 6)]
print("The original list of tuples : " + str(test_list))
res = np.array(test_list).tolist()
print("The converted list of list : " + str(res))
|
Output :
The original list of tuples : [(1, 2), (3, 4), (5, 6)]
The converted list of list : [[1, 2], [3, 4], [5, 6]]
The time complexity of this approach is O(n), where n is the length of the input list of tuples. This is because converting a list of tuples to a numpy array takes O(n) time and converting a numpy array to a list takes O(1) time.
The auxiliary space of this approach is also O(n), since we are creating a new list of the same size as the input list.
Method #6: Using for loop
Algorithm
- Initialize an empty list res to store the converted lists.
- Iterate over each tuple ele in the test_list using a for loop.
- Convert the current tuple ele to a list using the list() method.
- Append the converted list to the res list.
- Return the final list res.
Python3
test_list = [(1, 2), (3, 4), (5, 6)]
print("The original list of tuples : " + str(test_list))
res = []
for ele in test_list:
res.append(list(ele))
print("The converted list of list : " + str(res))
|
OutputThe original list of tuples : [(1, 2), (3, 4), (5, 6)]
The converted list of list : [[1, 2], [3, 4], [5, 6]]
Time complexity: O(n), where n is the length of the input list.
Auxiliary Space: O(n), where n is the length of the input list.
Additionally, we need to create a new list for each tuple in the test_list, so the space complexity is also O(n), where n is the length of the input list.
Method 7: using a list comprehension with the list() function
Python3
test_list = [(1, 2), (3, 4), (5, 6)]
res = [list(t) for t in test_list]
print("The converted list of list : " + str(res))
|
OutputThe converted list of list : [[1, 2], [3, 4], [5, 6]]
Time complexity: O(n), where n is the number of tuples in the input list.
Auxiliary space: O(n), as we create a new list of lists with the same size as the input list.
Method 8: Using functools.reduce():
- Initialize the test_list variable to [(1, 2), (3, 4), (5, 6)].
- Call the reduce() function with the lambda function lambda acc, x: acc + [list(x)], the test_list variable, and an initial accumulator value of [].
- The lambda function is applied to the first tuple (1, 2) and the initial accumulator value of []. The lambda function converts the tuple to a list [1, 2], and appends it to the accumulator [] to produce [ [1, 2] ].
- The lambda function is applied to the second tuple (3, 4) and the accumulator value [ [1, 2] ]. The lambda function converts the tuple to a list [3, 4], and appends it to the accumulator [ [1, 2] ] to produce [ [1, 2], [3, 4] ].
- The lambda function is applied to the third tuple (5, 6) and the accumulator value [ [1, 2], [3, 4] ]. The lambda function converts the tuple to a list [5, 6], and appends it to the accumulator [ [1, 2], [3, 4] ] to produce [ [1, 2], [3, 4], [5, 6] ].
- The final value of the accumulator [ [1, 2], [3, 4], [5, 6] ] is returned as the result of the reduce() function and assigned to the res variable.
- The resulting list of lists [ [1, 2], [3, 4], [5, 6] ] is printed to the console.
Python3
import functools
test_list = [(1, 2), (3, 4), (5, 6)]
print("The original list of tuples : " + str(test_list))
res = functools.reduce(lambda acc, x: acc + [list(x)], test_list, [])
print("The converted list of list : " + str(res))
|
OutputThe original list of tuples : [(1, 2), (3, 4), (5, 6)]
The converted list of list : [[1, 2], [3, 4], [5, 6]]
Time complexity: O(n)
The reduce() function takes O(n) time to iterate through the entire test_list, where n is the length of the list.
The lambda function inside reduce() takes O(1) time as it just converts a tuple to a list and appends it to the accumulator list.
Therefore, the overall time complexity of the code is O(n).
Auxiliary Space: O(n), as we create a new list for each tuple in test_list. The space required for the accumulator also grows linearly with the size of test_list.