How to Efficiently Flatten Irregularly Nested Lists in Python?

How to Flatten an Irregular Nested List of Lists

Although there are discussions around flattening list structures, solutions tend to fall short when lists are deeply nested. One effective approach is presented below:

Recursive Function Approach

def flatten(x):
    result = []
    for el in x:
        if hasattr(el, "__iter__") and not isinstance(el, basestring):
            result.extend(flatten(el))
        else:
            result.append(el)
    return result

This function checks if each element is iterable (except for strings) and recursively flattens it if true. Non-iterable elements are appended to the result.

Generator Function Approach

Enhancing the readability and performance of the flattening process is possible using generator functions:

Python 2 (using Iterable ABC):

from collections import Iterable

def flatten(xs):
    for x in xs:
        if isinstance(x, Iterable) and not isinstance(x, basestring):
            for item in flatten(x):
                yield item
        else:
            yield x

Python 3 (using tuple for str and bytes):

from collections.abc import Iterable

def flatten(xs):
    for x in xs:
        if isinstance(x, Iterable) and not isinstance(x, (str, bytes)):
            yield from flatten(x)
        else:
            yield x

This generator function lazily returns the flattened elements, optimizing memory usage. It can be iterated over or converted to a list as needed.

The above is the detailed content of How to Efficiently Flatten Irregularly Nested Lists in Python?. For more information, please follow other related articles on the PHP Chinese website!