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
# Python3 code to demonstrate working of
# Multiflatten Tuple List
# Using recursion + isinstance()
res = []
def remove_lists(test_list):
for ele in test_list:
# checking for wrapped list
if isinstance(ele, list):
remove_lists(ele)
else:
res.append(ele)
return res
# initializing list
test_list = [[[(4, 6)]], [[[(7, 4)]]], [[[[(10, 3)]]]]]
# printing original list
print("The original list is : " + str(test_list))
# calling recursive function
res = remove_lists(test_list)
# printing result
print("The Flattened container : " + str(res))
OutputThe 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
# Python3 code to demonstrate working of
# Multiflatten Tuple List
# Using yield + recursion
def remove_lists(test_list):
if isinstance(test_list, list):
# return intermediate to recursive function
for ele in test_list:
yield from remove_lists(ele)
else:
yield test_list
# initializing list
test_list = [[[(4, 6)]], [[[(7, 4)]]], [[[[(10, 3)]]]]]
# printing original list
print("The original list is : " + str(test_list))
# calling recursive function
res = list(remove_lists(test_list))
# printing result
print("The Flattened container : " + str(res))
OutputThe 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
# Python3 code to demonstrate working of
# Multiflatten Tuple List
# initializing list
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)
# printing original list
print("The original list is : " + str(test_list))
# printing result
print("The Flattened container : " + str(res))
OutputThe 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
# Python3 code to demonstrate working of
# Multiflatten Tuple List
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
# initializing list
test_list = [[[(4, 6)]], [[[(7, 4)]]], [[[[(10, 3)]]]]]
# printing original list
print("The original list is : " + str(test_list))
# calling recursive function
res = remove_lists(test_list)
# printing result
print("The Flattened container : " + str(res))
OutputThe 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)))
# initializing list
test_list = [[[(4, 6)]], [[[(7, 4)]]], [[[[(10, 3)]]]]]
# printing original list
print("The original list is : " + str(test_list))
# calling recursive function
res = remove_lists(test_list)
# printing result
print("The Flattened container : " + str(res))
OutputThe 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):
# create an empty stack and append the input list to it
stack = [test_list]
# create an empty list to store the flattened elements
res = []
# while the stack is not empty
while stack:
# pop the top element from the stack
ele = stack.pop()
# if the element is a list, append its elements to the stack
if isinstance(ele, list):
stack += ele
# if the element is not a list, append it to the result list
else:
res.append(ele)
# return the flattened list
return res
# initializing list
test_list = [[[(4, 6)]], [[[(7, 4)]]], [[[[(10, 3)]]]]]
# printing original list
print("The original list is : " + str(test_list))
# calling function
res = remove_lists(test_list)
# printing result
print("The Flattened container : " + str(res))
OutputThe 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.
Similar Reads
Python Tutorial | Learn Python Programming Language Python Tutorial â Python is one of the most popular programming languages. Itâs simple to use, packed with features and supported by a wide range of libraries and frameworks. Its clean syntax makes it beginner-friendly.Python is:A high-level language, used in web development, data science, automatio
10 min read
Python Interview Questions and Answers Python is the most used language in top companies such as Intel, IBM, NASA, Pixar, Netflix, Facebook, JP Morgan Chase, Spotify and many more because of its simplicity and powerful libraries. To crack their Online Assessment and Interview Rounds as a Python developer, we need to master important Pyth
15+ min read
Python OOPs Concepts Object Oriented Programming is a fundamental concept in Python, empowering developers to build modular, maintainable, and scalable applications. By understanding the core OOP principles (classes, objects, inheritance, encapsulation, polymorphism, and abstraction), programmers can leverage the full p
11 min read
Python Projects - Beginner to Advanced Python is one of the most popular programming languages due to its simplicity, versatility, and supportive community. Whether youâre a beginner eager to learn the basics or an experienced programmer looking to challenge your skills, there are countless Python projects to help you grow.Hereâs a list
10 min read
Python Exercise with Practice Questions and Solutions Python Exercise for Beginner: Practice makes perfect in everything, and this is especially true when learning Python. If you're a beginner, regularly practicing Python exercises will build your confidence and sharpen your skills. To help you improve, try these Python exercises with solutions to test
9 min read
Python Programs Practice with Python program examples is always a good choice to scale up your logical understanding and programming skills and this article will provide you with the best sets of Python code examples.The below Python section contains a wide collection of Python programming examples. These Python co
11 min read
Enumerate() in Python enumerate() function adds a counter to each item in a list or other iterable. It turns the iterable into something we can loop through, where each item comes with its number (starting from 0 by default). We can also turn it into a list of (number, item) pairs using list().Let's look at a simple exam
3 min read
Python Data Types Python Data types are the classification or categorization of data items. It represents the kind of value that tells what operations can be performed on a particular data. Since everything is an object in Python programming, Python data types are classes and variables are instances (objects) of thes
9 min read
Python Introduction Python was created by Guido van Rossum in 1991 and further developed by the Python Software Foundation. It was designed with focus on code readability and its syntax allows us to express concepts in fewer lines of code.Key Features of PythonPythonâs simple and readable syntax makes it beginner-frien
3 min read
Input and Output in Python Understanding input and output operations is fundamental to Python programming. With the print() function, we can display output in various formats, while the input() function enables interaction with users by gathering input during program execution. Taking input in PythonPython input() function is
8 min read