Open In App

# Python | Convert list of tuples to list of list

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)

## 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.