# Flatten a Nested List in Python Using in-build Sum() Function

(Last Updated On: 26/09/2023)

Flattening a nested list is a common task in Python when dealing with structured data. A nested list contains sublists, and sometimes we need to convert it into a single, one-dimensional list for further processing or analysis.

One approach to achieve this is by using a Python program to flatten a nested list using the in-build sum() function. We will walk you through the step-by-step process and explain the logic behind it. By the end of this blog, you will have a clear understanding of how to use the sum() function effectively to flatten nested lists and make your data manipulation tasks more efficient.

So, let’s dive into the world of nested lists and learn how to flatten a nested list in Python using in-build sum() function.

## Python Program to Flatten a Nested List Using in-build Sum() Function

```#Flatten a Nested List in python Using In-build sum() function

list = [[11, 22, 33, 44], [55, 66, 77], [88, 99]]

#we are using a python In-build sum() function
flatList = sum(list, [])

# Output
print('New list', flatList)
```

#### Program Explanation

• Defining the nested list

We start by defining a nested list called list, containing several sublists with different elements.

• Using the sum() function to flatten the list

We use the sum() function, which is primarily used for adding elements of an iterable. The sum() function takes two arguments: the iterable (in our case, the nested list) and the start value (an empty list []). By passing the nested list and an empty list as arguments to the sum() function, it concatenates all the sublists into a single list.

• Printing the result

Finally, we print the flattened list using the print() function.

#### Output:

The output of the code is the flattened list.

``New list [11, 22, 33, 44, 55, 66, 77, 88, 99]``

The given program uses the in-built sum() function in Python to flatten a nested list. The original nested list is [[11, 22, 33, 44], [55, 66, 77], [88, 99]]. After applying the sum() function with an empty list as the start value, the program concatenates all the sublists into a single list. The resulting flattened list is [11, 22, 33, 44, 55, 66, 77, 88, 99]. This flattened list is then printed as the output using the print() function.

#### Other ways to flatten a nested list in Python are:

• Using List Comprehension: We can use nested list comprehension to iterate over the sublists and flatten them into a single list. This method is often preferred for its readability and simplicity.
• Using Nested Loops: We iterate through each sublist and then iterate through each element in the sublist, appending them to a new list. This method provides more control and can be useful for more complex scenarios.
• Using the itertools Module: We can use the chain() function from itertools to chain together the sublists and flatten the list. This method is particularly useful when dealing with large datasets.

In this blog, we used the sum() function which provides a concise and straightforward solution with minimal code. It clearly conveys the intention of flattening the nested list. It is optimized for performance and can efficiently handle large lists. It leverages built-in functionality, reducing the need for explicit loops or list comprehensions.

In this tutorial, we explored the process of flattening a nested list in Python using the in-built sum() function. By providing the nested list and an empty list as arguments to the sum() function, we successfully obtained a flattened list. This approach offers a straightforward and concise solution for handling nested lists and simplifies data manipulation tasks.

The sum() function proves to be a versatile tool in Python, showcasing its ability to perform operations beyond simple addition. With this knowledge, you can confidently flatten nested lists and efficiently work with structured data in your Python programs.

#### Some FAQs when we use Sum() Function to Flatten a Nested List in Python

What happens if the nested list contains non-integer elements?

The sum() function can handle different types of elements in the nested list, including integers, strings, or even other lists. It will concatenate all the elements into a single list regardless of their data type.

Can I use the sum() function to flatten nested lists with multiple levels of nesting?

Yes, the sum() function can handle nested lists with multiple levels of nesting. It will recursively flatten all the sublists and concatenate them into a single list.

Can I modify the original nested list using the sum() function?

No, the sum() function does not modify the original nested list. It returns a new flattened list while leaving the original nested list intact.

Are there any limitations to using the sum() function for flattening large or deeply nested lists?

While the sum() function is convenient for flattening nested lists, it may not be the most efficient approach for large or deeply nested lists. In such cases, other techniques like recursion or specialized libraries may offer better performance.

How can I handle irregularly shaped nested lists with varying sublist lengths?

The sum() function assumes all sublists have the same length. If your nested list contains sublists with different lengths, you may need to preprocess the data or consider alternative approaches like list comprehensions or recursion to flatten the list properly.