# How do I make a flat list out of a list of lists?

I have a list of lists like `[[1, 2, 3], [4, 5, 6], [7], [8, 9]]`. How can I flatten it to get `[1, 2, 3, 4, 5, 6, 7, 8, 9]`?

If your list of lists comes from a nested list comprehension, the problem can be solved more simply/directly by fixing the comprehension; please see python list comprehensions; compressing a list of lists?.

The most popular solutions here generally only flatten one "level" of the nested list. See Flatten an irregular (arbitrarily nested) list of lists for solutions that completely flatten a deeply nested structure (recursively, in general).

## Solution

Given a list of lists `l`,

``````flat_list = [item for sublist in l for item in sublist]
``````

which means:

``````flat_list = []
for sublist in l:
for item in sublist:
flat_list.append(item)
``````

is faster than the shortcuts posted so far. (`l` is the list to flatten.)

Here is the corresponding function:

``````def flatten(l):
return [item for sublist in l for item in sublist]
``````

As evidence, you can use the `timeit` module in the standard library:

``````\$ python -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99' '[item for sublist in l for item in sublist]'
10000 loops, best of 3: 143 usec per loop
\$ python -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99' 'sum(l, [])'
1000 loops, best of 3: 969 usec per loop
\$ python -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99' 'reduce(lambda x,y: x+y,l)'
1000 loops, best of 3: 1.1 msec per loop
``````

Explanation: the shortcuts based on `+` (including the implied use in `sum`) are, of necessity, `O(L**2)` when there are L sublists — as the intermediate result list keeps getting longer, at each step a new intermediate result list object gets allocated, and all the items in the previous intermediate result must be copied over (as well as a few new ones added at the end). So, for simplicity and without actual loss of generality, say you have L sublists of I items each: the first I items are copied back and forth L-1 times, the second I items L-2 times, and so on; total number of copies is I times the sum of x for x from 1 to L excluded, i.e., `I * (L**2)/2`.

The list comprehension just generates one list, once, and copies each item over (from its original place of residence to the result list) also exactly once.

Source: StackOverflow.com