So, we must do this with iteration. One way is to iterate over the list until no lists remain:

def flatten(lst):
has_lists = True
while has_lists:
tmp_lst = []
has_lists = False
for elt in lst:
if isinstance(elt, list):
tmp_lst += elt
has_lists = True
else:
tmp_lst.append(elt)
lst = tmp_lst
return lst

Of course, you’re doing more iteration that you need to if the list contains elements of variable list depth. But since function calls are expensive in Python, it may actually be faster than recursion.

E.g.

def flatten(l):
return reduce(operator.add, l)

Obviously this requires the operator-module import.

def flatten(l):
if isinstance(l,list):
return sum(map(flatten,l),[])
else:
return [l]

def flatten(x):
ans = []
for i in range(len(x)):
if isinstance(x[i],list):
ans.extend(flatten(x[i]))
else:
ans.append(x[i])
return ans

def flatten(x):
ans = []
for i in range(len(x)):
if isinstance(x[i],list):
ans = x[:i]+flatten(x[i])+x[i+1:]
else:
ans.append(x[i])
return ans

def flatten(seq):
res = []
for item in seq:
if (isinstance(item, (tuple, list))):
res.extend(flatten(item))
else:
res.append(item)
return res

Another version is listed a in recipe 363051:

import sys
def flatten(inlist, ltype=(list,tuple), maxint=sys.maxint):
try:
for ind in xrange(maxint):
while isinstance(inlist[ind], ltype):
inlist[ind:ind+1] = list(inlist[ind])
except IndexError:
pass
return inlist

[[[1,2,3], (42,None)], [4,5], [6], 7, MyVector(8,9,10)]

One could imagine the following outputs:

# flattened one level:
[[1, 2, 3], (42, None), 4, 5, 6, 7, MyVector(8,9,10)]

# flattened all lists:
[1, 2, 3, (42, None), 4, 5, 6, 7, MyVector(8,9,10)]

# flattened all lists and tuples:
[1, 2, 3, 42, None, 4, 5, 6, 7, MyVector(8,9,10)]

# flattened all iterables:
[1, 2, 3, 42, None, 4, 5, 6, 7, 8, 9, 10]

@Will: Daniels version looks more optimized to me. The question whether isinstance is better than checking the class is another possible implementation decision, e.g. given the following definition of MyVector:

class MyVector(list):
def __init__(self, *args):
list.__init__(self, args)

Your version would handle it the same as a list, while daniels would not flatten it.

For the record, the above corresponds to the following checks in Daniel’s flatten function:
if i.__class__ is list:
if i.__class__ in (list, tuple):
if isinstance(i, list):
if isinstance(i, (list, tuple)):
if hasattr(i, “__iter__”):
AFAICS the simplest way to flatten only one layer is to change the recursive call to “list” instead of “flatten”.

How about:

def flatten(x):
if not isinstance(x,list):
return x
elif len(x) is 0:
return []
elif isinstance(x[0],list):
return flatten(x[0]) + flatten(x[1:])
else:
return [x[0]] + flatten(x[1:])