How to Flatten a List of Lists in Python

When working with data in Python, you often encounter nested lists, also known as a list of lists. The need to combine these inner lists into a single, flat list is a common task.

This article explores different techniques to flatten a list of lists in Python, providing clear explanations, practical examples, and performance considerations for each method. We’ll cover using list comprehensions, the itertools.chain.from_iterable method, the sum() function, and the NumPy library.

Let’s consider a basic example to start:

 Input:
 list_of_lists = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
 

 Expected Output:
 [1, 2, 3, 4, 5, 6, 7, 8, 9]
 

Method 1: Using List Comprehension

List comprehension offers a concise and readable way to flatten a list of lists. It involves iterating through each sublist and then through each element within those sublists to create a new, flattened list.

 list_of_lists = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]

 flattened_list = [element for sublist in list_of_lists for element in sublist]

 print(flattened_list)
 

 Output:
 [1, 2, 3, 4, 5, 6, 7, 8, 9]
 

Explanation: The code iterates through each sublist in list_of_lists. For each sublist, it then iterates through each element and adds it to the new flattened_list. This approach is generally efficient for smaller lists and provides a clean and Pythonic way to achieve flattening.

Method 2: Using itertools.chain.from_iterable

The itertools module provides powerful tools for working with iterators. The chain.from_iterable function is specifically designed for flattening iterable structures like lists of lists. It’s often more efficient than list comprehensions for larger lists.

 import itertools

 list_of_lists = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]

 flattened_list = list(itertools.chain.from_iterable(list_of_lists))

 print(flattened_list)
 

 Output:
 [1, 2, 3, 4, 5, 6, 7, 8, 9]
 

Explanation: itertools.chain.from_iterable takes an iterable (in this case, our list of lists) and returns a chain object that iterates through the elements of each sublist sequentially. We then convert this chain object to a list using list() to obtain the flattened list. This method avoids creating intermediate lists, making it memory-efficient for large datasets.

Method 3: Using sum() Function

The sum() function, when used with an initial value of an empty list ([]), can be used to concatenate the sublists into a single flattened list. While concise, this method’s performance can degrade significantly for very large lists due to repeated list concatenation, which creates new lists in each step.

 list_of_lists = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]

 flattened_list = sum(list_of_lists, [])

 print(flattened_list)
 

 Output:
 [1, 2, 3, 4, 5, 6, 7, 8, 9]
 

Explanation: The sum() function adds each sublist to the initial empty list []. This effectively concatenates all sublists. However, because lists are immutable in Python, each concatenation operation creates a new list, which can become inefficient for long lists. It’s more suitable for small to medium-sized lists where performance is not critical.

Method 4: Using NumPy (for Numerical Data)

If your list of lists contains numerical data, NumPy provides an efficient way to flatten the list using the flatten() or ravel() methods after converting it into a NumPy array. NumPy is optimized for numerical operations and offers significant performance improvements over standard Python lists for large datasets.

 import numpy as np

 list_of_lists = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]

 arr = np.array(list_of_lists)
 flattened_list = arr.flatten()  # Or use arr.ravel()

 print(flattened_list)
 

 Output:
 [1 2 3 4 5 6 7 8 9]
 

 import numpy as np

 list_of_lists = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]

 arr = np.array(list_of_lists, dtype=object)
 flattened_list = np.concatenate(arr)

 print(flattened_list)
 

 Output:
 [1 2 3 4 5 6 7 8 9]
 

Explanation: First, we convert the list of lists into a NumPy array using np.array(). Then, we use the flatten() method to create a one-dimensional flattened array. Alternatively, ravel() also achieves the same result. If the inner lists have varying lengths, ensure you set the dtype to object when creating the NumPy array, or use np.concatenate as shown in the second example to handle the array of lists properly. NumPy’s vectorized operations make this method highly efficient for large numerical datasets.