Is there a shortcut to make a simple list out of a list of lists in Python?

I can do it in a `for`

loop, but is there some cool “one-liner”?

I tried it with `functools.reduce()`

:

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

But I get this error:

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

5

## 26 Answers

Given a list of lists `t`

,

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

which means:

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

is faster than the shortcuts posted so far. (`t`

is the list to flatten.)

Here is the corresponding function:

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

As evidence, you can use the `timeit`

module in the standard library:

```
$ python -mtimeit -s't=[[1,2,3],[4,5,6], [7], [8,9]]*99' '[item for sublist in t for item in sublist]'
10000 loops, best of 3: 143 usec per loop
$ python -mtimeit -s't=[[1,2,3],[4,5,6], [7], [8,9]]*99' 'sum(t, [])'
1000 loops, best of 3: 969 usec per loop
$ python -mtimeit -s't=[[1,2,3],[4,5,6], [7], [8,9]]*99' 'reduce(lambda x,y: x+y,t)'
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(T**2)`

when there are T 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 T sublists of k items each: the first k items are copied back and forth T-1 times, the second k items T-2 times, and so on; total number of copies is k times the sum of x for x from 1 to T excluded, i.e., `k * (T**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.

6

I tried a test with the same data, using

`itertools.chain.from_iterable`

:`$ python -mtimeit -s'from itertools import chain; l=[[1,2,3],[4,5,6], [7], [8,9]]*99' 'list(chain.from_iterable(l))'`

. It runs a bit more than twice as fast as the nested list comprehension that’s the fastest of the alternatives shown here.– intuitedI found the syntax hard to understand until I realized you can think of it exactly like nested for loops. for sublist in l: for item in sublist: yield item

@RobCrowell Same here. To me the list comprehension one doesn’t

*read right*, something feels off about it – I always seem to get it wrong and end up googling. To me this reads right`[leaf for leaf in tree for tree in forest]`

. I wish this is how it was. I am sure I am missing something about the grammar here, and I would appreciate if anyone could point that out.I kept looking here every time I wanted to flatten a list, but this gif is what drove it home: i.stack.imgur.com/0GoV5.gif

– Gilthans

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:

```
merged = list(itertools.chain.from_iterable(list2d))
```

4

The

`*`

is the tricky thing that makes`chain`

less straightforward than the list comprehension. You have to know that chain only joins together the iterables passed as parameters, and the * causes the top-level list to be expanded into parameters, so`chain`

joins together all those iterables, but doesn’t descend further. I think this makes the comprehension more readable than the use of chain in this case.@TimDierks: I’m not sure “this requires you to understand Python syntax” is an argument against using a given technique in Python. Sure, complex usage could confuse, but the “splat” operator is generally useful in many circumstances, and this isn’t using it in a particularly obscure way; rejecting all language features that aren’t necessarily obvious to beginning users means you’re tying one hand behind your back. May as well throw out list comprehensions too while you’re at it; users from other backgrounds would find a

`for`

loop that repeatedly`append`

s more obvious.* creates an intermediary tuple.!

`from_iterable`

fetch the nested lists directly from the top list.– nadapezTo make this more readable, you can make a simple function:

`def flatten_list(deep_list: list[list[object]]):`

`return list(chain.from_iterable(deep_list))`

. The type hinting improves the clarity of what’s going on (modern IDEs would interpret this as returning a`list[object]`

type).

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

```
>>> l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
>>> 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.

7

that’s pretty neat and clever but I wouldn’t use it because it’s confusing to read.

– andrewrkThis is a Shlemiel the painter’s algorithm joelonsoftware.com/articles/fog0000000319.html — unnecessarily inefficient as well as unnecessarily ugly.

The append operation on lists forms a

, which is one of the most convenient abstractions for thinking of a`Monoid`

`+`

operation in a general sense (not limited to numbers only). So this answer deserves a +1 from me for (correct) treatment of lists as a monoid.*The performance is concerning though…*– ulidtkothis is a very inefficient way because of the quadratic aspect of the sum.

This article explains the maths of the inefficiency mathieularose.com/how-not-to-flatten-a-list-of-lists-in-python

– ds4940

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

), and found

```
import functools
import operator
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.)

A simpler and also acceptable variant is

```
out = []
for sublist in a:
out.extend(sublist)
```

If the number of sublists is large, this performs a little worse than the above suggestion.

Code to reproduce the plot:

```
import functools
import itertools
import operator
import numpy as np
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(np.array(a).flat)
def numpy_concatenate(a):
return list(np.concatenate(a))
def extend(a):
out = []
for sublist in a:
out.extend(sublist)
return out
b = perfplot.bench(
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,
extend,
],
n_range=[2 ** k for k in range(16)],
xlabel="num lists (of length 10)",
# xlabel="len lists (10 lists total)"
)
b.save("out.png")
b.show()
```

6

For huge nested lists,’ list(numpy.array(a).flat)’ is the fastest among all functions above.

– SaraIs there a way to do a 3-d perfplot? number of arrays by average size of array?

– Leo@Sara can you define “huge” please?

– BorisTried

`numpy_flat`

on the test example from Rossetta Code (link) and got`VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray`

– mirekphdOne option missed above which shows up faster for my particular case i just

`items = []; for sublist in a: items.extend(sublist); return sublist`

```
>>> from functools import reduce
>>> 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 `functools.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]
```

0

Here is a general approach that applies to **numbers**, **strings**, **nested** lists and **mixed** containers. This can flatten both simple and complicated containers (see also *Demo*).

**Code**

```
from typing import Iterable
#from collections import Iterable # < py38
def flatten(items):
"""Yield items from any nested iterable; see Reference."""
for x in items:
if isinstance(x, Iterable) and not isinstance(x, (str, bytes)):
for sub_x in flatten(x):
yield sub_x
else:
yield x
```

*Notes*:

- In Python 3,
`yield from flatten(x)`

can replace`for sub_x in flatten(x): yield sub_x`

- In Python 3.8, abstract base classes are moved from
`collection.abc`

to the`typing`

module.

**Demo**

```
simple = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
list(flatten(simple))
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
complicated = [[1, [2]], (3, 4, {5, 6}, 7), 8, "9"] # numbers, strs, nested & mixed
list(flatten(complicated))
# [1, 2, 3, 4, 5, 6, 7, 8, '9']
```

**Reference**

- This solution is modified from a recipe in
*Beazley, D. and B. Jones. Recipe 4.14, Python Cookbook 3rd Ed., O’Reilly Media Inc. Sebastopol, CA: 2013.* - Found an earlier SO post, possibly the original demonstration.

8

I just wrote pretty much the same, because I didn’t see your solution … here is what I looked for “recursively flatten complete multiple lists” … (+1)

@MartinThoma Much appreciated. FYI, if flattening nested iterables is a common practice for you, there are some third-party packages that handle this well. This may save from reinventing the wheel. I’ve mentioned

`more_itertools`

among others discussed in this post. Cheers.– pylangMaybe

`traverse`

could also be a good name for this way of a tree, whereas I’d keep it less*universal*for this answer by sticking to nested lists.– WolfYou can check

`if hasattr(x, '__iter__')`

instead of importing/checking against`Iterable`

and that will exclude strings as well.the above code doesnt seem to work for if one of the nested lists is having a list of strings. [1, 2, [3, 4], [4], [], 9, 9.5, ‘ssssss’, [‘str’, ‘sss’, ‘ss’], [3, 4, 5]] output:- [1, 2, 3, 4, 4, 9, 9.5, ‘ssssss’, 3, 4, 5]

– sunnyX

If you want to flatten a data-structure where you don’t know how deep it’s nested you could use `iteration_utilities.deepflatten`

^{1}

```
>>> from iteration_utilities import deepflatten
>>> l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
>>> list(deepflatten(l, depth=1))
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> l = [[1, 2, 3], [4, [5, 6]], 7, [8, 9]]
>>> list(deepflatten(l))
[1, 2, 3, 4, 5, 6, 7, 8, 9]
```

It’s a generator so you need to cast the result to a `list`

or explicitly iterate over it.

To flatten only one level and if each of the items is itself iterable you can also use `iteration_utilities.flatten`

which itself is just a thin wrapper around `itertools.chain.from_iterable`

:

```
>>> from iteration_utilities import flatten
>>> l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
>>> list(flatten(l))
[1, 2, 3, 4, 5, 6, 7, 8, 9]
```

Just to add some timings (based on Nico Schlömer’s answer that didn’t include the function presented in this answer):

It’s a log-log plot to accommodate for the huge range of values spanned. For qualitative reasoning: Lower is better.

The results show that if the iterable contains only a few inner iterables then `sum`

will be fastest, however for long iterables only the `itertools.chain.from_iterable`

, `iteration_utilities.deepflatten`

or the nested comprehension have reasonable performance with `itertools.chain.from_iterable`

being the fastest (as already noticed by Nico Schlömer).

```
from itertools import chain
from functools import reduce
from collections import Iterable # or from collections.abc import Iterable
import operator
from iteration_utilities import deepflatten
def nested_list_comprehension(lsts):
return [item for sublist in lsts for item in sublist]
def itertools_chain_from_iterable(lsts):
return list(chain.from_iterable(lsts))
def pythons_sum(lsts):
return sum(lsts, [])
def reduce_add(lsts):
return reduce(lambda x, y: x + y, lsts)
def pylangs_flatten(lsts):
return list(flatten(lsts))
def flatten(items):
"""Yield items from any nested iterable; see REF."""
for x in items:
if isinstance(x, Iterable) and not isinstance(x, (str, bytes)):
yield from flatten(x)
else:
yield x
def reduce_concat(lsts):
return reduce(operator.concat, lsts)
def iteration_utilities_deepflatten(lsts):
return list(deepflatten(lsts, depth=1))
from simple_benchmark import benchmark
b = benchmark(
[nested_list_comprehension, itertools_chain_from_iterable, pythons_sum, reduce_add,
pylangs_flatten, reduce_concat, iteration_utilities_deepflatten],
arguments={2**i: [[0]*5]*(2**i) for i in range(1, 13)},
argument_name="number of inner lists"
)
b.plot()
```

^{1 Disclaimer: I’m the author of that library}

0

Consider installing the `more_itertools`

package.

```
> pip install more_itertools
```

It ships with an implementation for `flatten`

(source, from the itertools recipes):

```
import more_itertools
lst = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
list(more_itertools.flatten(lst))
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
```

*Note: as mentioned in the docs, flatten requires a list of lists. See below on flattening more irregular inputs.*

As of version 2.4, you can flatten more complicated, nested iterables with `more_itertools.collapse`

(source, contributed by abarnet).

```
lst = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
list(more_itertools.collapse(lst))
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
lst = [[1, 2, 3], [[4, 5, 6]], [[[7]]], 8, 9] # complex nesting
list(more_itertools.collapse(lst))
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
```

3

The reason your function didn’t work is because the *extend* extends an array in-place and doesn’t return it. You can still return x from lambda, using something like this:

```
reduce(lambda x,y: x.extend(y) or x, l)
```

Note: extend is more efficient than + on lists.

2

`extend`

is better used as`newlist = []`

,`extend = newlist.extend`

,`for sublist in l: extend(l)`

as it avoids the (rather large) overhead of the`lambda`

, the attribute lookup on`x`

, and the`or`

.– agffor python 3 add

`from functools import reduce`

The following seems simplest to me:

```
>>> import numpy as np
>>> l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
>>> print(np.concatenate(l))
[1 2 3 4 5 6 7 8 9]
```

1

OP doesn’t mention they want to use numpy. Python has good ways of doing this without relying on a library

`matplotlib.cbook.flatten()`

will work for nested lists even if they nest more deeply than the example.

```
import matplotlib
l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
print(list(matplotlib.cbook.flatten(l)))
l2 = [[1, 2, 3], [4, 5, 6], [7], [8, [9, 10, [11, 12, [13]]]]]
print(list(matplotlib.cbook.flatten(l2)))
```

Result:

```
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
```

This is 18x faster than underscore._.flatten:

```
Average time over 1000 trials of matplotlib.cbook.flatten: 2.55e-05 sec
Average time over 1000 trials of underscore._.flatten: 4.63e-04 sec
(time for underscore._)/(time for matplotlib.cbook) = 18.1233394636
```

1

I think this is the fast of above all functions

– abdul

One can also use NumPy’s flat:

```
import numpy as np
list(np.array(l).flat)
```

It only works when sublists have identical dimensions.

0

According your list `[[1, 2, 3], [4, 5, 6], [7], [8, 9]]`

which is 1 list level, we can simply use `sum(list,[])`

without using any libraries

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

2

Neat! Though the other answer here, stackoverflow.com/a/952946/14273548, explains the reasons this solution

**should generally be avoided**(it’s inefficient and confusing.)– Arel

you can use `list`

`extend`

method, it shows to be the fastest:

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

performance:

```
import functools
import itertools
import numpy
import operator
import perfplot
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 extend(a):
n = []
list(map(n.extend, a))
return n
perfplot.show(
setup=lambda n: [list(range(10))] * n,
kernels=[
functools_reduce_iconcat, extend,itertools_chain, numpy_flat
],
n_range=[2**k for k in range(16)],
xlabel="num lists",
)
```

0

If you are willing to give up a tiny amount of speed for a cleaner look, then you could use `numpy.concatenate().tolist()`

or `numpy.concatenate().ravel().tolist()`

:

```
import numpy
l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]] * 99
%timeit numpy.concatenate(l).ravel().tolist()
1000 loops, best of 3: 313 µs per loop
%timeit numpy.concatenate(l).tolist()
1000 loops, best of 3: 312 µs per loop
%timeit [item for sublist in l for item in sublist]
1000 loops, best of 3: 31.5 µs per loop
```

You can find out more here in the documentation, numpy.concatenate and numpy.ravel.

3

Doesn’t work for unevenly nested lists like

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

– EL_DON@EL_DON of course, that isn’t what this question is asking, there is another question that deals with that case

@juanpa.arrivillaga it’s a simple and natural extension of the question, though. Answers that can handle greater depth of nesting are more likely to be useful to someone who finds this question.

– EL_DON

There are several answers with the same recursive appending scheme as below, but none makes use of `try`

, which makes the solution more robust and *Pythonic*.

```
def flatten(itr):
for x in itr:
try:
yield from flatten(x)
except TypeError:
yield x
```

**Usage**: this is a generator, you typically want to enclose it in an iterable builder like `list()`

or `tuple()`

or use it in a `for`

loop.

Advantages of this solution are:

- works with any kind of iterable (even future ones!)
- works with any combination and deepness of nesting
- works also if top level contains bare items
- no dependencies
- efficient (you can flatten the nested iterable partially, without wasting time on the remaining part you don’t need)
- versatile (you can use it to build an iterable of your choice or in a loop)

N.B. since ALL iterables are flattened, strings are decomposed into sequences of single characters. If you don’t like/want such behavior, you can use the following version which filters out from flattening iterables like strings and bytes:

```
def flatten(itr):
if type(itr) in (str,bytes):
yield itr
else:
for x in itr:
try:
yield from flatten(x)
except TypeError:
yield x
```

3

why would you use a tuple? now your solution is inefficient.

And with any sequence,

`sum((flatten(e) for e in itr), tuple())`

is highly inefficient,@juanpa.arrivillaga Your comment made me think about improving my answer and I think I found a better one, what do you think?

– mmj

```
def flatten(alist):
if alist == []:
return []
elif type(alist) is not list:
return [alist]
else:
return flatten(alist[0]) + flatten(alist[1:])
```

1

Fails for python2.7 for the example nested list in the question:

`[[1, 2, 3], [4, 5, 6], [7], [8, 9]]`

– EL_DON

**Note**: Below applies to Python 3.3+ because it uses `yield_from`

. `six`

is also a third-party package, though it is stable. Alternately, you could use `sys.version`

.

In the case of `obj = [[1, 2,], [3, 4], [5, 6]]`

, all of the solutions here are good, including list comprehension and `itertools.chain.from_iterable`

.

However, consider this slightly more complex case:

```
>>> obj = [[1, 2, 3], [4, 5], 6, 'abc', [7], [8, [9, 10]]]
```

There are several problems here:

- One element,
`6`

, is just a scalar; it’s not iterable, so the above routes will fail here. - One element,
`'abc'`

,*is*technically iterable (all`str`

s are). However, reading between the lines a bit, you don’t want to treat it as such–you want to treat it as a single element. - The final element,
`[8, [9, 10]]`

is itself a nested iterable. Basic list comprehension and`chain.from_iterable`

only extract “1 level down.”

You can remedy this as follows:

```
>>> from collections import Iterable
>>> from six import string_types
>>> def flatten(obj):
... for i in obj:
... if isinstance(i, Iterable) and not isinstance(i, string_types):
... yield from flatten(i)
... else:
... yield i
>>> list(flatten(obj))
[1, 2, 3, 4, 5, 6, 'abc', 7, 8, 9, 10]
```

Here, you check that the sub-element (1) is iterable with `Iterable`

, an ABC from `itertools`

, but also want to ensure that (2) the element is *not* “string-like.”

1

If you are still interested in Python 2 compatibility, change

`yield from`

to a`for`

loop, e.g.`for x in flatten(i): yield x`

– pylang

This may not be the most efficient way but I thought to put a one-liner (actually a two-liner). Both versions will work on arbitrary hierarchy nested lists, and exploits language features (Python3.5) and recursion.

```
def make_list_flat (l):
flist = []
flist.extend ([l]) if (type (l) is not list) else [flist.extend (make_list_flat (e)) for e in l]
return flist
a = [[1, 2], [[[[3, 4, 5], 6]]], 7, [8, [9, [10, 11], 12, [13, 14, [15, [[16, 17], 18]]]]]]
flist = make_list_flat(a)
print (flist)
```

The output is

```
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]
```

This works in a depth first manner. The recursion goes down until it finds a non-list element, then extends the local variable `flist`

and then rolls back it to the parent. Whenever `flist`

is returned, it is extended to the parent’s `flist`

in the list comprehension. Therefore, at the root, a flat list is returned.

The above one creates several local lists and returns them which are used to extend the parent’s list. I think the way around for this may be creating a gloabl `flist`

, like below.

```
a = [[1, 2], [[[[3, 4, 5], 6]]], 7, [8, [9, [10, 11], 12, [13, 14, [15, [[16, 17], 18]]]]]]
flist = []
def make_list_flat (l):
flist.extend ([l]) if (type (l) is not list) else [make_list_flat (e) for e in l]
make_list_flat(a)
print (flist)
```

The output is again

```
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]
```

Although I am not sure at this time about the efficiency.

1

Why extend([l]) instead of append(l)?

– Maciek

Another unusual approach that works for hetero- and homogeneous lists of integers:

```
from typing import List
def flatten(l: list) -> List[int]:
"""Flatten an arbitrary deep nested list of lists of integers.
Examples:
>>> flatten([1, 2, [1, [10]]])
[1, 2, 1, 10]
Args:
l: Union[l, Union[int, List[int]]
Returns:
Flatted list of integer
"""
return [int(i.strip('[ ]')) for i in str(l).split(',')]
```

7

That’s just a more complicated and a bit slower way of what ᴡʜᴀᴄᴋᴀᴍᴀᴅᴏᴏᴅʟᴇ3000 already posted before. I reinvented his proposal yesterday, so this approach seems quite popular these days 😉

Not quite:

`wierd_list = [[1, 2, 3], [4, 5, 6], [7], [8, 9], 10]`

>>`nice_list=[1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 0]`

– tharndtmy code as one liner would be :

`flat_list = [int(e.replace('[','').replace(']','')) for e in str(deep_list).split(',')]`

– tharndtYou are indeed right +1, ᴡʜᴀᴄᴋᴀᴍᴀᴅᴏᴏᴅʟᴇ3000’s proposal won’t work with multiple digit numbers, I also didn’t test this before although it should be obvious. You could simplify your code and write

`[int(e.strip('[ ]')) for e in str(deep_list).split(',')]`

. But I’d suggest to stick with Deleet’s proposal for real use cases. It doesn’t contain hacky type transformations, it’s faster and more versatile because it naturally also handles lists with mixed types.Unfortunately no. But I saw this code recently here: Python Practice Book 6.1.2

– tharndt

I wanted a solution which can deal with multiple nesting (`[[1], [[[2]], [3]]], [1, 2, 3]`

for example), but would also not be recursive (I had a big level of recursion and I got a recursion error.

This is what I came up with:

```
def _flatten(l) -> Iterator[Any]:
stack = l.copy()
while stack:
item = stack.pop()
if isinstance(item, list):
stack.extend(item)
else:
yield item
def flatten(l) -> Iterator[Any]:
return reversed(list(_flatten(l)))
```

and tests:

```
@pytest.mark.parametrize('input_list, expected_output', [
([1, 2, 3], [1, 2, 3]),
([[1], 2, 3], [1, 2, 3]),
([[1], [2], 3], [1, 2, 3]),
([[1], [2], [3]], [1, 2, 3]),
([[1], [[2]], [3]], [1, 2, 3]),
([[1], [[[2]], [3]]], [1, 2, 3]),
])
def test_flatten(input_list, expected_output):
assert list(flatten(input_list)) == expected_output
```

You can use the following:

```
def flatlst(lista):
listaplana = []
for k in lista: listaplana = listaplana + k
return listaplana
```

1

`+`

operator creates a new list each time. You’ll be better off using`+=`

or`.extend()`

– Vimanyu

A non-recursive function to flatten lists of lists of any depth:

```
def flatten_list(list1):
out = []
inside = list1
while inside:
x = inside.pop(0)
if isinstance(x, list):
inside[0:0] = x
else:
out.append(x)
return out
l = [[[1,2],3,[4,[[5,6],7],[8]]],[9,10,11]]
flatten_list(l)
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
```

Use two `for`

in list comprehension:

```
l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
flat_l = [e for v in l for e in v]
print(flat_l)
```

If I want to add something to the great previous answers, here is my recursive `flatten`

function which can flatten not only nested lists, but also any given container or any generally any object which can throw out items. This is also work for any depth of nesting and it is a lazy iterator which yields the items as requested:

```
def flatten(iterable):
# These types won't considered a sequence or generally a container
exclude = str, bytes
for i in iterable:
try:
if isinstance(i, exclude):
raise TypeError
iter(i)
except TypeError:
yield i
else:
yield from flatten(i)
```

This way you can exclude types you don’t want them to be flatted like `str`

or what else.

The idea is if an object can pass the `iter()`

it’s ready to yield items. So the iterable can have even generator expressions as an item.

Someone could argue that why did you write this that generic when the OP didn’t ask for ? ok you’re right. I just felt like this might help someone(like it did for myself).

Test cases:

```
lst1 = [1, {3}, (1, 6), [[3, 8]], [[[5]]], 9, ((((2,),),),)]
lst2 = ['3', B'A', [[[(i ** 2 for i in range(3))]]], range(3)]
print(list(flatten(lst1)))
print(list(flatten(lst2)))
```

output:

```
[1, 3, 1, 6, 3, 8, 5, 9, 2]
['3', b'A', 0, 1, 4, 0, 1, 2]
```

```
np.hstack(listoflist).tolist()
```

1

While this code may answer the question, providing additional context regarding why and/or how this code answers the question improves its long-term value. Consider reading How to Answer and edit your answer to improve it.

There’s an in-depth discussion of this here: rightfootin.blogspot.com/2006/09/more-on-python-flatten.html, discussing several methods of flattening arbitrarily nested lists of lists. An interesting read!

Some other answers are better but the reason yours fails is that the ‘extend’ method always returns None. For a list with length 2, it will work but return None. For a longer list, it will consume the first 2 args, which returns None. It then continues with None.extend(<third arg>), which causes this erro

stackoverflow.com/questions/50259290/… (this article explain the difference between an np.flatten() and a tf.flatten() use (static vs dynamic) ndarray.

This is a very common duplicate target. However, for cases where OP already has a process that generates a list of lists (especially if it’s a list comprehension), consider whether stackoverflow.com/questions/1077015/… is a more applicable duplicate.

your lambda should be

`reduce(lambda a, b: a + b, l)`