# How to make a flat list out of list of lists?

## How to make a flat list out of list of lists?

### Question

I wonder whether there is a shortcut to make a simple list out of list of lists in Python.

I can do that in a `for`

loop, but maybe there is some cool "one-liner"? I tried it with `reduce()`

, but I get an error.

**Code**

```
l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
reduce(lambda x, y: x.extend(y), l)
```

**Error message**

```
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 1, in <lambda>
AttributeError: 'NoneType' object has no attribute 'extend'
```

### Accepted Answer

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:

```
flatten = lambda l: [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.

Read more... Read less...

You can use `itertools.chain()`

:

```
import itertools
list2d = [[1,2,3], [4,5,6], [7], [8,9]]
merged = list(itertools.chain(*list2d))
```

Or you can use `itertools.chain.from_iterable()`

which doesn't require unpacking the list with the `*`

operator:

```
import itertools
list2d = [[1,2,3], [4,5,6], [7], [8,9]]
merged = list(itertools.chain.from_iterable(list2d))
```

**Note from the author**: This is inefficient. But fun, because monoids are awesome. It's not appropriate for production Python code.

```
>>> sum(l, [])
[1, 2, 3, 4, 5, 6, 7, 8, 9]
```

This just sums the elements of iterable passed in the first argument, treating second argument as the initial value of the sum (if not given, `0`

is used instead and this case will give you an error).

Because you are summing nested lists, you actually get `[1,3]+[2,4]`

as a result of `sum([[1,3],[2,4]],[])`

, which is equal to `[1,3,2,4]`

.

Note that only works on lists of lists. For lists of lists of lists, you'll need another solution.

I tested most suggested solutions with perfplot (a pet project of mine, essentially a wrapper around `timeit`

), and found

```
functools.reduce(operator.iconcat, a, [])
```

to be the fastest solution, both when many small lists and few long lists are concatenated. (`operator.iadd`

is equally fast.)

Code to reproduce the plot:

```
import functools
import itertools
import numpy
import operator
import perfplot
def forfor(a):
return [item for sublist in a for item in sublist]
def sum_brackets(a):
return sum(a, [])
def functools_reduce(a):
return functools.reduce(operator.concat, a)
def functools_reduce_iconcat(a):
return functools.reduce(operator.iconcat, a, [])
def itertools_chain(a):
return list(itertools.chain.from_iterable(a))
def numpy_flat(a):
return list(numpy.array(a).flat)
def numpy_concatenate(a):
return list(numpy.concatenate(a))
perfplot.show(
setup=lambda n: [list(range(10))] * n,
# setup=lambda n: [list(range(n))] * 10,
kernels=[
forfor,
sum_brackets,
functools_reduce,
functools_reduce_iconcat,
itertools_chain,
numpy_flat,
numpy_concatenate,
],
n_range=[2 ** k for k in range(16)],
xlabel="num lists (of length 10)",
# xlabel="len lists (10 lists total)"
)
```

```
from functools import reduce #python 3
>>> l = [[1,2,3],[4,5,6], [7], [8,9]]
>>> reduce(lambda x,y: x+y,l)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
```

The `extend()`

method in your example modifies `x`

instead of returning a useful value (which `reduce()`

expects).

A faster way to do the `reduce`

version would be

```
>>> import operator
>>> l = [[1,2,3],[4,5,6], [7], [8,9]]
>>> reduce(operator.concat, l)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
```

## Don't reinvent the wheel if you use **Django**:

```
>>> from django.contrib.admin.utils import flatten
>>> l = [[1,2,3], [4,5], [6]]
>>> flatten(l)
>>> [1, 2, 3, 4, 5, 6]
```

...**Pandas**:

```
>>> from pandas.core.common import flatten
>>> list(flatten(l))
```

...**Itertools**:

```
>>> import itertools
>>> flatten = itertools.chain.from_iterable
>>> list(flatten(l))
```

...**Matplotlib**

```
>>> from matplotlib.cbook import flatten
>>> list(flatten(l))
```

...**Unipath**:

```
>>> from unipath.path import flatten
>>> list(flatten(l))
```

...**Setuptools**:

```
>>> from setuptools.namespaces import flatten
>>> list(flatten(l))
```