Open In App
Related Articles

Python | Convert list of tuples to list of list

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

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. 

  1. Initialize a list of tuples called test_list containing three tuples with two elements each.
  2. Print the original list of tuples using the print() function and the str() method to convert the list to a string for printing.
  3. 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.
  4. Print the converted list of lists using the print() function and the str() method to convert the list to a string for printing.

Python3

# Python3 code to demonstrate
# convert list of tuples to list of list
# using list comprehension
 
# initializing list
test_list = [(1, 2), (3, 4), (5, 6)]
 
# printing original list
print("The original list of tuples : " + str(test_list))
 
# using list comprehension
# convert list of tuples to list of list
res = [list(ele) for ele in test_list]
 
# print result
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

# Python3 code to demonstrate
# convert list of tuples to list of list
# using map() + list
 
# initializing list
test_list = [(1, 2), (3, 4), (5, 6)]
 
# printing original list
print("The original list of tuples : " + str(test_list))
 
# using map() + list
# convert list of tuples to list of list
res = list(map(list, test_list))
 
# print result
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:

  1. Initialize an empty list res.
  2. Convert the input list of tuples to a numpy array using np.array() function.
  3. Convert the numpy array to a list using the tolist() method.
  4. Store the result in the res list.
  5. Print the res list.
     

Python3

# Python3 code to demonstrate
# convert list of tuples to list of list
# using numpy library
 
import numpy as np
 
# initializing list
test_list = [(1, 2), (3, 4), (5, 6)]
 
# printing original list
print("The original list of tuples : " + str(test_list))
 
# using numpy library
# convert list of tuples to list of list
res = np.array(test_list).tolist()
 
# print result
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

  1. Initialize an empty list res to store the converted lists.
  2. Iterate over each tuple ele in the test_list using a for loop.
  3. Convert the current tuple ele to a list using the list() method.
  4. Append the converted list to the res list.
  5. Return the final list res.

Python3

# Python3 code to demonstrate
# convert list of tuples to list of list
# using for loop
 
# initializing list
test_list = [(1, 2), (3, 4), (5, 6)]
 
# printing original list
print("The original list of tuples : " + str(test_list))
 
# using for loop
# convert list of tuples to list of list
res = []
for ele in test_list:
    res.append(list(ele))
 
# print result
print("The converted list of list : " + str(res))
#This code is contributed by Vinay Pinjala.

                    

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), 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)]
 
# using list comprehension with list() function
res = [list(t) for t in test_list]
 
# print result
print("The converted list of list : " + str(res))

                    

Output
The 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():

  1. Initialize the test_list variable to [(1, 2), (3, 4), (5, 6)].
  2. Call the reduce() function with the lambda function lambda acc, x: acc + [list(x)], the test_list variable, and an initial accumulator value of [].
  3. 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] ].
  4. 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] ].
  5. 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] ].
  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.
  7. 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)]
# printing original list
print("The original list of tuples : " + str(test_list))
res = functools.reduce(lambda acc, x: acc + [list(x)], test_list, [])
# print result
print("The converted list of list : " + str(res))
# This code is contributed by jyothi Pinjala.

                    

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)

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.



Last Updated : 27 Apr, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads