5 Best Ways to Flatten a Nested List Using Recursion in Python

Rate this post

πŸ’‘ Problem Formulation: You may encounter scenarios in programming where you have to process nested lists, which can vary in depth and complexity. The goal is to convert a nested list, such as [[1, 2], [3, [4, 5]], 6], into a flat list like [1, 2, 3, 4, 5, 6] using recursion in Python. This can simplify data manipulation and analysis tasks that require linear sequences of elements.

Method 1: Recursive Flattening with isinstance Check

This method involves defining a recursive function that iterates over each element in the list. If an element is itself a list (checked using isinstance()), the function is called recursively. Otherwise, the element is yielded. This method is explicit and easy to understand due to its clear use of an isinstance check.

Here’s an example:

def flatten_list(nested_list):
    for element in nested_list:
        if isinstance(element, list):
            yield from flatten_list(element)
        else:
            yield element

# Example usage:
nested_list = [[1, 2], [3, [4, 5]], 6]
print(list(flatten_list(nested_list)))

Output:

[1, 2, 3, 4, 5, 6]

The provided code snippet defines a function flatten_list() that takes a nested list and yields each element in its most basic form. The yield from statement is used to yield all elements from the recursive call if the element is a list.

Method 2: Recursive Flattening with Type Checking

This approach is similar to the first but involves checking for list types using the type() function instead of isinstance(). This is less flexible than isinstance because it does not consider subclassing, but it is suitable when working with lists and not subclasses of list.

Here’s an example:

def flatten_list(nested_list):
    for element in nested_list:
        if type(element) is list:
            yield from flatten_list(element)
        else:
            yield element

# Example usage:
nested_list = [[1, 'a'], ['b', [True, False]], None]
print(list(flatten_list(nested_list)))

Output:

[1, 'a', 'b', True, False, None]

In this code snippet, the function flatten_list() checks each element’s type using type() to decide whether to yield it directly or to recurse. This is a straightforward method suitable when you’re certain that you will not be dealing with subclasses of lists.

Method 3: Concatenation with Recursion

In this method, recursion is combined with list concatenation to merge nested lists into a single flat list. The function concatenates and returns lists instead of yielding elements. This method is intuitive but less memory efficient due to the temporary lists created during concatenation.

Here’s an example:

def flatten_list(nested_list):
    flat_list = []
    for element in nested_list:
        if isinstance(element, list):
            flat_list += flatten_list(element)
        else:
            flat_list.append(element)
    return flat_list

# Example usage:
nested_list = [0, [1, 2], [3, [4, 5]], 6]
print(flatten_list(nested_list))

Output:

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

This snippet showcases list concatenation where the flatten_list() function extends the flat list with the results of the recursive call. This approach may be less efficient than the yield-based methods due to the creation of intermediate lists.

Method 4: Recursion with Extend Method

Recursion can also be used in combination with the list’s extend() method. This recursively decomposes the list and extends it using the results. While offering better memory efficiency than concatenation, this method is less elegant than yield.

Here’s an example:

def flatten_list(nested_list):
    flat_list = []
    for element in nested_list:
        if isinstance(element, list):
            flat_list.extend(flatten_list(element))
        else:
            flat_list.append(element)
    return flat_list

# Example usage:
nested_list = [['x'], ['y', [['z']]], 'w']
print(flatten_list(nested_list))

Output:

['x', 'y', 'z', 'w']

The function flatten_list() in this code uses the extend() method to add elements from the recursive call to the flat_list without creating additional temporary lists, thus making it more memory-efficient than concatenation.

Bonus One-Liner Method 5: Using List Comprehension and Recursion

A one-liner version of the flatten function can be created by combining list comprehension with recursion. This method is elegant and concise, though may be slightly harder to read for beginners.

Here’s an example:

flatten_list = lambda x: [a for b in x for a in (flatten_list(b) if isinstance(b, list) else [b])]

# Example usage:
nested_list = [['X', 'Y'], [True, [1, 2]], 3]
print(flatten_list(nested_list))

Output:

['X', 'Y', True, 1, 2, 3]

This code snippet features a lambda function that defines flatten_list in one line. The function uses list comprehension to iterate over each element and calls itself recursively when an element is a list.

Summary/Discussion

  • Method 1: Recursive Flattening with isinstance Check. Easy to understand. Can handle subclasses of lists. Slightly slower due to the isinstance check.
  • Method 2: Recursive Flattening with Type Checking. Faster than isinstance but less flexible. Suitable for lists only, not their subclasses.
  • Method 3: Concatenation with Recursion. Intuitive but less memory efficient due to extra list creations. Good for small or medium-sized lists.
  • Method 4: Recursion with Extend Method. More memory efficient than method 3, but recursion might confuse beginners. Optimal for larger lists.
  • Method 5: Bonus One-Liner. Elegant but less readable. It efficiently combines recursion with list comprehensions for those comfortable with one-liners.