3 Ways to Flatten Lists in Python (Nested Loops, List Comprehension, itertools)

What is a flat list and a list of lists?

• A flat list is a one-dimensional list that contains only individual elements, not nested structures.
• A list of lists (or sometimes called a multidimensional list) is a nested data structure where a list contains other lists as elements.

How to flatten a list of lists in Python

There are several ways to achieve this in Python, each with its own advantages and considerations:

Using Nested Loops:

This is a straightforward approach that iterates through the outer list and then iterates through each sublist, appending elements to a new flat list.

def flatten_list(nested_list):
  flat_list = []
  for sublist in nested_list:
    for element in sublist:
      flat_list.append(element)
  return flat_list

nested_list = [[1, 2], [3, 4], [5]]
flat_list = flatten_list(nested_list)
print(flat_list)  # Output: [1, 2, 3, 4, 5]

Using List Comprehension:

This method offers a more concise way to achieve the same result as nested loops. It combines iteration and element addition into a single line.

flat_list = [element for sublist in nested_list for element in sublist]
print(flat_list)  # Output: [1, 2, 3, 4, 5]

Using itertools.chain.from_iterable:

The itertools module provides a chain.from_iterable function that efficiently connects iterables (like lists) into a single iterator. This can be converted to a list for flattening.

from itertools import chain

nested_list = [[1, 2], [3, 4], [5]]
flat_list = list(chain.from_iterable(nested_list))
print(flat_list)  # Output: [1, 2, 3, 4, 5]

Choosing the Right Method:

• For simple cases and better readability, nested loops or list comprehension might be preferable.
• If performance is critical for very large lists, itertools.chain.from_iterable can be slightly more efficient.

Key Points:

• These methods work for lists containing any data type (numbers, strings, etc.).
• They create a new flattened list, leaving the original nested list unchanged.
• Consider using a descriptive function name like flatten_list to improve code clarity.
• For more complex flattening scenarios (e.g., handling arbitrary levels of nesting or filtering elements), explore libraries like functools.reduce.

I hope this explanation is helpful!

def flatten_list(nested_list):
  flat_list = []
  for sublist in nested_list:
    for element in sublist:
      flat_list.append(element)
  return flat_list

nested_list = [[1, 2], [3, 4], [5]]
flat_list = flatten_list(nested_list)
print(flat_list)  # Output: [1, 2, 3, 4, 5]

flat_list = [element for sublist in nested_list for element in sublist]
print(flat_list)  # Output: [1, 2, 3, 4, 5]

from itertools import chain

nested_list = [[1, 2], [3, 4], [5]]
flat_list = list(chain.from_iterable(nested_list))
print(flat_list)  # Output: [1, 2, 3, 4, 5]

These examples demonstrate how to flatten a list of lists in Python using different approaches. Choose the method that best suits your specific needs and coding style.

Using functools.reduce (Functional Programming Approach):

The functools module offers a reduce function that allows for a more functional programming style. It takes a function and an iterable, applying the function cumulatively to create a single result. Here's how to use it for flattening:

from functools import reduce

def flatten(list_of_lists):
  return reduce(lambda x, y: x + y, list_of_lists, [])

nested_list = [[1, 2], [3, 4], [5]]
flat_list = flatten(nested_list)
print(flat_list)  # Output: [1, 2, 3, 4, 5]

Explanation:

• reduce takes three arguments:
  • The function to apply (here, lambda x, y: x + y which concatenates lists).
  • The iterable (the nested list).
  • An optional initial value for the accumulator (empty list []).
• It iteratively applies the lambda function, starting with the empty list and the first sublist, then the result with the second sublist, and so on, until all sublists are processed.

Using Recursion (For Complex Nesting):

Recursion is a technique where a function calls itself. It can be useful for handling lists with arbitrary levels of nesting:

def flatten_recursive(nested_list):
  flat_list = []
  for item in nested_list:
    if isinstance(item, list):
      flat_list.extend(flatten_recursive(item))  # Recursive call for sublists
    else:
      flat_list.append(item)
  return flat_list

nested_list = [[1, [2, 3]], 4, [5, [6]]]
flat_list = flatten_recursive(nested_list)
print(flat_list)  # Output: [1, 2, 3, 4, 5, 6]

• The function checks each element in the nested list:
  • If it's a list, it recursively calls flatten_recursive to handle the sublist.
  • Otherwise, it appends the element to the flat list.
• This approach works well for unknown levels of nesting, but be cautious with very deep nesting due to potential recursion depth limits.

• Nested loops, list comprehension, and itertools.chain.from_iterable are generally preferred for simple or moderate list flattening.
• functools.reduce offers a concise functional approach.
• Recursion can handle complex nesting but use it cautiously due to recursion depth limitations.

Remember to consider the complexity of your nested list and choose the method that best suits your needs.