Python program to Flatten Nested List to Tuple List
Last Updated :
07 Apr, 2023
Given a list of tuples with each tuple wrapped around multiple lists, our task is to write a Python program to flatten the container to a list of tuples.
Input : test_list = [[[(4, 6)]], [[[(7, 4)]]], [[[[(10, 3)]]]]]
Output : [(4, 6), (7, 4), (10, 3)]
Explanation : The surrounded lists are omitted around each tuple.
Input : test_list = [[[(4, 6)]], [[[(7, 4)]]]]
Output : [(4, 6), (7, 4)]
Explanation : The surrounded lists are omitted around each tuple.
Method #1 : Using recursion + isinstance()
In this, the container wrapping is tested to be list using isinstance(). The recursion strategy is used to check for repeated flattening of the list till tuple.
step-by-step approach of the given program:
- Define an empty list res outside the function remove_lists(). This list will be used to store the flattened elements of the input list.
- Define the function remove_lists(test_list) that takes a list as input. This function will recursively flatten the list.
- Iterate over the elements of test_list using a for loop.
- Check if the current element is a list or not using the isinstance() function. If it is a list, call the remove_lists() function recursively with the current element as input. This will flatten the nested list.
- If the current element is not a list, append it to the res list.
- Return the res list.
- Initialize the input list test_list with some nested tuples.
- Print the original list test_list.
- Call the function remove_lists() with test_list as input. This will flatten the nested list recursively and store the flattened elements in the res list.
- Print the flattened list.
- End of the program.
Python3
res = []
def remove_lists(test_list):
for ele in test_list:
if isinstance (ele, list ):
remove_lists(ele)
else :
res.append(ele)
return res
test_list = [[[( 4 , 6 )]], [[[( 7 , 4 )]]], [[[[( 10 , 3 )]]]]]
print ( "The original list is : " + str (test_list))
res = remove_lists(test_list)
print ( "The Flattened container : " + str (res))
|
Output
The original list is : [[[(4, 6)]], [[[(7, 4)]]], [[[[(10, 3)]]]]]
The Flattened container : [(4, 6), (7, 4), (10, 3)]
Time Complexity: O(n), where n is the total number of elements in the nested tuple list.
Auxiliary Space: O(n), where n is the total number of elements in the nested tuple list.
Method #2 : Using yield + recursion
This method performs a similar task using recursion. The generator is used to process intermediate results using yield keyword.
Python3
def remove_lists(test_list):
if isinstance (test_list, list ):
for ele in test_list:
yield from remove_lists(ele)
else :
yield test_list
test_list = [[[( 4 , 6 )]], [[[( 7 , 4 )]]], [[[[( 10 , 3 )]]]]]
print ( "The original list is : " + str (test_list))
res = list (remove_lists(test_list))
print ( "The Flattened container : " + str (res))
|
Output
The original list is : [[[(4, 6)]], [[[(7, 4)]]], [[[[(10, 3)]]]]]
The Flattened container : [(4, 6), (7, 4), (10, 3)]
Time complexity: O(n), where n is the total number of elements in the input list.
Auxiliary space: O(m), where m is the maximum depth of nested lists in the input list.
Method #3 : Using replace(),split(),list(),map(),tuple() methods
Python3
test_list = [[[( 4 , 6 )]], [[[( 7 , 4 )]]], [[[[( 10 , 3 )]]]]]
res = []
for i in test_list:
i = str (i)
i = i.replace( "[" ,"")
i = i.replace( "]" ,"")
i = i.replace( "(" ,"")
i = i.replace( ")" ,"")
x = i.split( "," )
x = tuple ( map ( int ,x))
res.append(x)
print ( "The original list is : " + str (test_list))
print ( "The Flattened container : " + str (res))
|
Output
The original list is : [[[(4, 6)]], [[[(7, 4)]]], [[[[(10, 3)]]]]]
The Flattened container : [(4, 6), (7, 4), (10, 3)]
Time Complexity : O(N)
Auxiliary Space : O(N)
Method #4 : Using type() and recursion
Python3
res = []
def remove_lists(test_list):
for ele in test_list:
if type (ele) is list :
remove_lists(ele)
else :
res.append(ele)
return res
test_list = [[[( 4 , 6 )]], [[[( 7 , 4 )]]], [[[[( 10 , 3 )]]]]]
print ( "The original list is : " + str (test_list))
res = remove_lists(test_list)
print ( "The Flattened container : " + str (res))
|
Output
The original list is : [[[(4, 6)]], [[[(7, 4)]]], [[[[(10, 3)]]]]]
The Flattened container : [(4, 6), (7, 4), (10, 3)]
Time Complexity : O(N)
Auxiliary Space : O(N)
Method #5: Using itertools.chain() and recursion
Use the itertools.chain() function to flatten a nested list by recursively iterating over its elements using a generator function (flatten_list()) with the yield from statement. The remove_lists() function then applies itertools.chain.from_iterable() to the output of flatten_list() and returns a list containing all the flattened elements.
STEPS:
- First, we import the itertools module.
- Next, we define a function called flatten_list(lst) which takes a list as input and flattens it. This function uses a recursive approach to flatten nested lists. It checks whether the current item is a list or not. If it is a list, it calls the flatten_list() function again with that list as input, otherwise it yields the item.
- We define another function called remove_lists(test_list) which takes a nested list as input and returns a flattened list. This function uses the chain.from_iterable() method from itertools to concatenate all the nested lists into a single flattened list. It also calls the flatten_list() function to flatten the nested lists.
- We initialize a nested list called test_list which contains tuples.
- We print the original nested list.
- We call the remove_lists() function with test_list as input and store the flattened list in a variable called res.
- We print the flattened list.
Python3
import itertools
def flatten_list(lst):
for item in lst:
if isinstance (item, list ):
yield from flatten_list(item)
else :
yield item
def remove_lists(test_list):
return list (itertools.chain.from_iterable(flatten_list(test_list)))
test_list = [[[( 4 , 6 )]], [[[( 7 , 4 )]]], [[[[( 10 , 3 )]]]]]
print ( "The original list is : " + str (test_list))
res = remove_lists(test_list)
print ( "The Flattened container : " + str (res))
|
Output
The original list is : [[[(4, 6)]], [[[(7, 4)]]], [[[[(10, 3)]]]]]
The Flattened container : [4, 6, 7, 4, 10, 3]
Time complexity: O(n), where n is the total number of elements in the input list.
Auxiliary space: O(n), as the flatten_list() function uses recursion to iterate over the elements of the list, and each recursive call creates a new stack frame with local variables.
Method #6: Using stack and iteration
Step-by-step approach:
- Create an empty stack and append the input list test_list to it.
- Create an empty list res.
- While the stack is not empty:
a. Pop the top element ele from the stack.
b. If ele is a list, append its elements to the stack.
c. If ele is not a list, append it to res.
- Return res.
Below is the implementation of the above approach:
Python3
def remove_lists(test_list):
stack = [test_list]
res = []
while stack:
ele = stack.pop()
if isinstance (ele, list ):
stack + = ele
else :
res.append(ele)
return res
test_list = [[[( 4 , 6 )]], [[[( 7 , 4 )]]], [[[[( 10 , 3 )]]]]]
print ( "The original list is : " + str (test_list))
res = remove_lists(test_list)
print ( "The Flattened container : " + str (res))
|
Output
The original list is : [[[(4, 6)]], [[[(7, 4)]]], [[[[(10, 3)]]]]]
The Flattened container : [(10, 3), (7, 4), (4, 6)]
Time complexity: O(n), where n is the total number of elements in the input list.
Auxiliary space: O(n), where n is the total number of elements in the input list.
Share your thoughts in the comments
Please Login to comment...