Skip to content

Easily Flatten a List in Python

How to Flatten a List of Lists in Python

Sometimes, when you’re working with data, you may have the data as a list of nested lists. A common operation is to flatten this data into a one-dimensional list in Python. Flattening a list involves converting a multidimensional list, such as a matrix, into a one-dimensional list.

To better illustrate what it means to flatten a list, let’s consider an example. Imagine you have the following matrix:

matrix = [
[9, 3, 8, 3],
[4, 5, 2, 8],
[6, 4, 3, 1],
[1, 0, 4, 5],

The matrix variable holds a Python list that contains four nested lists. Each nested list represents a row in the matrix. The rows store four items or numbers each. Now, let’s say you want to turn this matrix into a one-dimensional list:

[9, 3, 8, 3, 4, 5, 2, 8, 6, 4, 3, 1, 1, 0, 4, 5]

In this tutorial, we will explore different approaches to flattening a list of lists in Python.

How to Flatten a List of Lists With a for Loop

One way to flatten a list of lists is to use a for loop. Here are the steps you can follow:

  1. Create a new empty list to store the flattened data.
  2. Iterate over each nested list in the original list.
  3. Add every item from the current sublist to the list of flattened data.
  4. Return the resulting list with the flattened data.

To implement this using a for loop, you can use the .extend() method from the list class to add items to the new flattened list. Here’s an example:

def flatten_extend(matrix):
flat_list = []
for row in matrix:
return flat_list

In the flatten_extend() function, we first create an empty list called flat_list to store the flattened data. We then iterate over the nested lists using a for loop. In each iteration, we use the .extend() method to add the elements from the current sublist to flat_list.

Using a Comprehension to Flatten a List of Lists

Python comprehensions provide a concise way to create new lists. They can also be used to flatten a list of lists. Here’s an example using a list comprehension:

def flatten_comprehension(matrix):
return [item for row in matrix for item in row]

In the flatten_comprehension() function, we create a new list by iterating over each nested list (row) in the matrix. For each row, we iterate over each item (item) and add it to the new list.

Flattening a List Using Standard-Library and Built-in Tools

Python provides several built-in tools and standard-library modules that can help with flattening a list of lists. Let’s explore some of them.

Chaining Iterables With itertools.chain()

The itertools.chain() function allows you to chain or combine multiple iterables into a single iterable. Here’s an example using itertools.chain():

import itertools
def flatten_chain(matrix):
return list(itertools.chain(*matrix))

In the flatten_chain() function, we use the * operator to unpack the nested lists from matrix and pass them as arguments to itertools.chain(). We then convert the resulting chain object into a list.

Concatenating Lists With functools.reduce()

The functools.reduce() function enables you to apply a function to a sequence of arguments. You can use it to concatenate the nested lists into a single list. Here’s an example:

import functools
def flatten_reduce(matrix):
return functools.reduce(lambda x, y: x + y, matrix)

In the flatten_reduce() function, we use functools.reduce() along with a lambda function to concatenate the nested lists. The lambda function takes two arguments (x and y) and returns their sum. The resulting list of concatenated items is returned.

Using sum() to Concatenate Lists

The sum() function in Python can be used to concatenate lists by providing an empty list as the starting value. Here’s an example:

def flatten_sum(matrix):
return sum(matrix, [])

In the flatten_sum() function, we pass the matrix as the first argument to sum(), followed by an empty list as the second argument. This effectively concatenates the nested lists and returns the flattened list.

Considering Performance While Flattening Your Lists

When flattening large or deeply nested lists, performance can become a concern. Some techniques may be faster than others, depending on the specific use case. It’s important to consider the trade-offs between simplicity and performance when choosing an approach.

Flattening Python Lists for Data Science With NumPy

If you’re working with data science applications in Python, you may often encounter nested lists that need to be flattened. The NumPy library provides efficient ways to handle multidimensional data, including flattening lists. Here’s an example using NumPy:

import numpy as np
def flatten_numpy(matrix):
return np.array(matrix).flatten().tolist()

In the flatten_numpy() function, we first convert the matrix to a NumPy array using np.array(). We then use the flatten() method to flatten the array, and finally, convert it back to a regular Python list using .tolist().


Flattening a list of lists is a common operation when working with multidimensional data in Python. In this tutorial, we explored different approaches to achieve this task, including using a for loop, list comprehensions, built-in tools and modules, and the NumPy library. Each approach has its own benefits and trade-offs, so choose the one that best suits your specific use case.

Remember to consider the performance implications of flattening large or deeply nested lists, and choose an approach accordingly.

Have fun flattening your lists!