Python Flatten List: 8 Methods to Flatten Nested Lists

Name

Soren Atelier

Updated on 2/10/2026

You have a list of lists in Python and you need a single flat list. Maybe it came from a database query that returned grouped rows, a CSV parser that split lines into chunks, or a matrix operation that produced nested output. Whatever the source, you need [[1, 2], [3, 4], [5]] to become [1, 2, 3, 4, 5]. Python has no built-in flatten() function, but there are at least eight solid ways to do it -- each with different trade-offs in readability, performance, and depth handling.

Picking the wrong method can cost you. Using sum(nested, []) on a 10,000-element list runs 100x slower than itertools.chain. Using numpy on jagged lists throws an error. Using a shallow method on deeply nested data silently drops inner elements. This guide covers every major approach, benchmarks them head-to-head, and gives you a clear decision framework for choosing the right one.

Quick Answer: The Simplest Way to Flatten a List

For a basic list of lists (one level of nesting), use a list comprehension:

nested = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
flat = [item for sublist in nested for item in sublist]
print(flat)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

If you need to flatten deeply nested or irregular structures, skip ahead to the recursive methods.

Methods Summary Table

Method 1: List Comprehension (Shallow Flatten)

The most Pythonic one-liner for a single level of nesting. It reads naturally: "for each sublist in nested, for each item in sublist, give me item."

nested = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
flat = [item for sublist in nested for item in sublist]
print(flat)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

This builds the entire result list in memory at once. For most use cases that is fine. The CPython interpreter optimizes list comprehensions with a dedicated bytecode path, making them faster than equivalent for loops.

Limitations: Only handles one level of nesting. If your input is [[1, [2, 3]], [4]], the inner [2, 3] stays as a list in the output.

Method 2: itertools.chain.from_iterable (Shallow, Memory Efficient)

The itertools.chain.from_iterable() function treats a sequence of iterables as a single continuous stream. It returns a lazy iterator, so it does not build the full result in memory until you consume it.

import itertools
 
nested = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
flat = list(itertools.chain.from_iterable(nested))
print(flat)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

The key advantage over chain(*nested) is that from_iterable does not unpack the outer list as individual arguments. This matters when the outer list has thousands of sublists -- argument unpacking has overhead and can hit Python's argument limit.

# Lazy evaluation -- useful for processing large data without loading everything
import itertools
 
nested = [[i, i+1] for i in range(0, 1_000_000, 2)]
flat_iter = itertools.chain.from_iterable(nested)
 
# Process one element at a time without storing the full flat list
first_ten = [next(flat_iter) for _ in range(10)]
print(first_ten)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

When to use: This is the best default choice for shallow flattening. It is the fastest standard-library method and the most memory efficient.

Method 3: sum() with Empty List (Simple but Slow)

Python's sum() can concatenate lists when you provide [] as the start value:

nested = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
flat = sum(nested, [])
print(flat)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

This works because sum() applies + between each element and the accumulator. For lists, + means concatenation.

Why it is slow: Each + creates a brand-new list, copying all elements from both operands. For n sublists of average length m, the time complexity is O(n * m * n) = O(n^2 * m). On 1,000 sublists, this is already noticeably slower. On 10,000 sublists, it can be 100x slower than itertools.chain.

Use only for quick one-off scripts with small data where readability matters more than speed.

Method 4: functools.reduce + operator.concat

A functional programming approach that applies list concatenation across the sequence:

import functools
import operator
 
nested = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
flat = functools.reduce(operator.concat, nested)
print(flat)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

operator.concat is equivalent to + for sequences but avoids a lambda. Under the hood, this has the same quadratic performance problem as sum() -- each reduction step creates a new list.

# Equivalent using operator.iadd (in-place add) for better performance
import functools
import operator
 
nested = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
flat = functools.reduce(operator.iadd, nested, [])
print(flat)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

Using operator.iadd (which maps to +=) mutates the accumulator in place, avoiding the quadratic copy cost. This makes reduce + iadd competitive with list comprehension in benchmarks. Note the empty list [] as the initial value -- without it, iadd would mutate the first sublist in the original data.

Method 5: Recursive Function (Any Depth)

When your data has unpredictable nesting depth, recursion is the straightforward solution:

def flatten(nested):
    result = []
    for item in nested:
        if isinstance(item, list):
            result.extend(flatten(item))
        else:
            result.append(item)
    return result
 
data = [[1, 2, [3, 4]], [5, [6, [7, 8]]], 9]
print(flatten(data))
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

This handles lists nested to any depth. The isinstance(item, list) check determines whether to recurse deeper or collect the element.

Limitations:

• Only detects list types. Tuples, sets, and other iterables inside the structure will be treated as leaf values.
• Python has a default recursion limit of 1,000. Extremely deep nesting (rare in practice) can hit this. You can raise it with sys.setrecursionlimit(), but a stack-based iterative approach is safer for such cases.

A generator-based version avoids building intermediate lists:

def flatten_gen(nested):
    for item in nested:
        if isinstance(item, list):
            yield from flatten_gen(item)
        else:
            yield item
 
data = [[1, 2, [3, 4]], [5, [6, [7, 8]]], 9]
print(list(flatten_gen(data)))
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

Method 6: collections.abc + Recursive (Robust Deep Flatten)

The previous method only checks for list. A more robust approach uses collections.abc.Iterable to handle tuples, sets, generators, and custom iterables -- while correctly skipping strings and bytes (which are iterable but should not be flattened character-by-character):

from collections.abc import Iterable
 
def deep_flatten(nested):
    for item in nested:
        if isinstance(item, Iterable) and not isinstance(item, (str, bytes)):
            yield from deep_flatten(item)
        else:
            yield item
 
data = [[1, 2], (3, 4), {5, 6}, "hello", [[7, [8]]]]
print(list(deep_flatten(data)))
# [1, 2, 3, 4, 5, 6, 'hello', 7, 8]

Note that "hello" remains as a single string rather than being split into ['h', 'e', 'l', 'l', 'o']. The str and bytes exclusion is critical -- without it, you get infinite recursion because iterating a single character string yields itself.

When to use: This is the best approach when your data contains mixed types or comes from an untrusted/variable source.

Method 7: numpy.ndarray.flatten (Numeric Arrays Only)

NumPy's flatten() method works on ndarray objects. It is fast for numeric data because it operates on contiguous C-level memory.

import numpy as np
 
# Works with uniform (rectangular) arrays
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
flat = matrix.flatten().tolist()
print(flat)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

Critical limitation: NumPy arrays must be rectangular. If your sublists have different lengths (jagged arrays), np.array() does not create a 2D array -- it creates a 1D array of Python list objects, and calling .flatten() on that returns the lists unchanged:

import numpy as np
 
# Jagged list -- sublists have different lengths
jagged = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
 
# This does NOT flatten correctly
arr = np.array(jagged, dtype=object)
result = arr.flatten().tolist()
print(result)
# [[1, 2, 3], [4, 5], [6, 7, 8, 9]]  -- still nested!

To handle jagged numeric data with NumPy, use np.concatenate or np.hstack:

import numpy as np
 
jagged = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
flat = np.concatenate(jagged).tolist()
print(flat)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

When to use: Only when your data is already in NumPy arrays or when you are doing numerical computation. Do not import NumPy just to flatten a list of Python objects -- it adds overhead and dependency for no benefit.

Method 8: more_itertools.collapse (Third-Party)

The more-itertools library provides collapse(), which deep-flattens any iterable and handles edge cases like strings and bytes automatically:

# pip install more-itertools
from more_itertools import collapse
 
data = [[1, 2, [3]], (4, 5), "hello", [[6, [7]]]]
flat = list(collapse(data))
print(flat)
# [1, 2, 3, 4, 5, 'hello', 6, 7]

You can also control the flattening depth with the levels parameter:

from more_itertools import collapse
 
data = [[1, [2, [3, [4]]]], [5]]
 
# Flatten only 1 level
print(list(collapse(data, levels=1)))
# [1, [2, [3, [4]]], 5]
 
# Flatten 2 levels
print(list(collapse(data, levels=2)))
# [1, 2, [3, [4]], 5]
 
# Flatten all levels (default)
print(list(collapse(data)))
# [1, 2, 3, 4, 5]

When to use: If you already depend on more-itertools, this is the cleanest option for deep flattening. It is well-tested and handles edge cases you might miss in a hand-written recursive function.

Performance Benchmarks

The following benchmarks measure flattening a list of 1,000 sublists, each containing 10 integers, using Python 3.12 on a standard machine. Times are averages over 1,000 runs.

Key takeaways:

• For shallow flattening, itertools.chain.from_iterable and list comprehension are within 2x of each other and both excellent.
• The sum() and basic reduce approaches are an order of magnitude slower due to quadratic list copying.
• The reduce + iadd trick brings reduce back to competitive performance.
• For deep flattening, the recursive methods are necessary regardless of speed -- none of the fast shallow methods handle nesting beyond one level.

You can reproduce these benchmarks with:

import timeit
import itertools
import functools
import operator
 
nested = [[j for j in range(i, i + 10)] for i in range(0, 10000, 10)]
 
# itertools.chain.from_iterable
t1 = timeit.timeit(
    lambda: list(itertools.chain.from_iterable(nested)),
    number=1000
)
print(f"chain.from_iterable: {t1:.4f}s")
 
# List comprehension
t2 = timeit.timeit(
    lambda: [x for sub in nested for x in sub],
    number=1000
)
print(f"List comprehension:  {t2:.4f}s")
 
# sum()
t3 = timeit.timeit(
    lambda: sum(nested, []),
    number=1000
)
print(f"sum(nested, []):     {t3:.4f}s")

If you run experiments like these in Jupyter notebooks, RunCell (opens in a new tab) can help you iterate faster. It is an AI agent that works inside Jupyter -- it understands your notebook context, suggests optimized alternatives, and can run benchmarks across variations of your code automatically.

When to Use Which Method: A Decision Guide

Follow this decision tree:

1. Is the nesting exactly one level deep?

   • Yes, and performance matters: use itertools.chain.from_iterable.
   • Yes, and readability matters: use a list comprehension.
   • Yes, and the list is tiny (under 100 elements): sum(nested, []) is fine.

2. Is the nesting depth unknown or variable?

   • Data contains only lists: use the simple recursive function (Method 5).
   • Data contains mixed types (tuples, sets, generators): use collections.abc + recursive (Method 6).
   • You already use more-itertools: use collapse (Method 8).

3. Is the data purely numeric and already in NumPy?

   • Rectangular array: use ndarray.flatten().
   • Jagged sublists: use np.concatenate().

4. Do you need lazy evaluation (process elements one at a time)?

   • Shallow: itertools.chain.from_iterable returns an iterator.
   • Deep: use the generator-based recursive function with yield from.

Common Mistakes

Mistake 1: Flattening Strings by Accident

Strings are iterable in Python. A naive recursive flatten that checks hasattr(item, '__iter__') will split "hello" into ['h', 'e', 'l', 'l', 'o'] -- and then recurse into each character, causing infinite recursion (a single character string yields itself when iterated).

# WRONG -- causes infinite recursion on strings
def bad_flatten(nested):
    for item in nested:
        if hasattr(item, '__iter__'):
            yield from bad_flatten(item)
        else:
            yield item
 
# This will crash: list(bad_flatten(["hello", [1, 2]]))

Fix: Always exclude str and bytes from the recursion check, as shown in Method 6.

Mistake 2: Mutating the Original List with iadd

Using functools.reduce with operator.iadd without an initial value mutates the first sublist in the original data:

import functools, operator
 
nested = [[1, 2], [3, 4], [5, 6]]
flat = functools.reduce(operator.iadd, nested)
 
print(flat)         # [1, 2, 3, 4, 5, 6]
print(nested[0])    # [1, 2, 3, 4, 5, 6]  -- mutated!

Fix: Always provide an empty list as the initial value: functools.reduce(operator.iadd, nested, []).

Mistake 3: Using NumPy on Jagged Lists

As shown in Method 7, np.array() on sublists of different lengths creates an object array, not a 2D numeric array. Calling .flatten() on it returns the original lists, not the elements.

Fix: Use np.concatenate(jagged) for jagged numeric lists, or stick with pure Python methods.

Mistake 4: Forgetting That Generators Are One-Shot

If you flatten with a generator function and try to iterate the result twice, the second pass produces nothing:

def flatten_gen(nested):
    for item in nested:
        if isinstance(item, list):
            yield from flatten_gen(item)
        else:
            yield item
 
data = [[1, 2], [3, 4]]
gen = flatten_gen(data)
 
print(list(gen))    # [1, 2, 3, 4]
print(list(gen))    # []  -- generator exhausted

Fix: Convert to a list if you need to iterate multiple times, or recreate the generator.

FAQ

What is the fastest way to flatten a list in Python?

For a single level of nesting (list of lists), itertools.chain.from_iterable() is the fastest standard library method. It operates at the C level and returns a lazy iterator, avoiding memory allocation for intermediate lists. List comprehension is a close second and requires no import. Both are significantly faster than sum(nested, []) or functools.reduce with operator.concat, which have quadratic time complexity.

How do I flatten a deeply nested list in Python?

Write a recursive function that checks each element: if it is a list (or any iterable), recurse into it; otherwise, yield or append it. For maximum robustness, use collections.abc.Iterable as the type check and exclude str and bytes to prevent infinite recursion on strings. Alternatively, install more-itertools and use collapse(), which handles all these edge cases out of the box.

Can I flatten a list of lists with different lengths?

Yes. All pure Python methods (list comprehension, itertools.chain, recursion, sum, reduce) handle sublists of different lengths without any issues. The only method that requires uniform lengths is numpy.ndarray.flatten(), which needs a rectangular array. For jagged numeric data in NumPy, use np.concatenate() instead.

What is the difference between flatten() and ravel() in NumPy?

Both flatten() and ravel() return a 1D array from a multi-dimensional array, but they differ in memory behavior. flatten() always returns a copy -- modifying the result does not affect the original. ravel() returns a view when possible, meaning changes to the returned array may modify the original data. Use flatten() when you need a safe, independent copy. Use ravel() when performance matters and you will not modify the result.

How do I flatten only one level of a nested list?

Use any of the shallow methods: list comprehension ([x for sub in nested for x in sub]), itertools.chain.from_iterable(nested), or sum(nested, []). These peel off exactly one layer of nesting. If you want to flatten exactly N levels of an arbitrarily nested structure, use more_itertools.collapse(data, levels=N) which gives you precise depth control.

Conclusion

Flattening lists is a fundamental operation in Python, and the right method depends on three factors: nesting depth, data size, and data types.

For everyday shallow flattening, itertools.chain.from_iterable is the best default -- it is fast, memory efficient, and part of the standard library. List comprehension is the most readable alternative when you do not need lazy evaluation. Avoid sum(nested, []) on anything beyond small lists due to its quadratic performance.

For deep or irregular nesting, the recursive approach using collections.abc.Iterable handles the widest range of inputs safely. The more-itertools library offers a polished, tested version of this with depth control.

For numeric computation, stay within NumPy: use ndarray.flatten() for rectangular arrays and np.concatenate() for jagged ones.

Whatever method you choose, test it against your actual data shape. The method that is perfect for [[1, 2], [3, 4]] may silently produce wrong results on [[1, [2, 3]], "hello", (4, 5)].