flattening a list with some elements being lists

[Skaperen]

a list might be like [[1,2,3],4,[5,6,7,8],[9]] and i want to flatten it to [1,2,3,4,5,6,7,8,9]. how easy is this to do if it is only 2 levels like that? what if it goes even deeper like [[1,2,3],4,[5,[[6,7],8]],[9]]. is it any easier as a list than any type of iterator? would this be any easier if the iterators were ranges?

[wavic]

There is a generator function here. Look at it.

[Skaperen]

looking for something simpler. i think i am getting close.

[perfringo]

This could be simpler and should work:

>>> m = [[1,2,3],4,[5,[[6,7],8]],[9]]
>>> def flatten(lst):
...     for item in lst:
...         try:
...             yield from flatten(item)
...         except TypeError:
...             yield item
...
>>> list(flatten(m))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

I should mention that if list contains string(s) function fails miserably (maximum recursion depth exceeded)

[Skaperen]

you could test for list type somewhere to avoid trying to iterate a string.

* Skaperen thinks that code would be a great example for the language reference

---

that code gave me hints, but i wanted something that would also work in Python2, so no yield from. i came up with this code, which works without being a generator at all. i created it as a code file with test code, instead of an interactive session, since i wanted to keep it.

flatten.py:

def flatten(*a):
    if len(a)==1:
        l=[]
        flatten(a[0],l)
        return l
    if isinstance(a[0],list):
        for e in a[0]:
            flatten(e,a[1])
        return
    a[1].append(a[0])
    return

x=[[1,2,3],4,[5,[[6,7],8]],[9]]
print(repr(x))
y=flatten(x)
print(repr(y))

[wavic]

I should mention that if list contains string(s) function fails miserably (maximum recursion depth exceeded)

I had this issue with strings. You can see the link in my prev. post.
I like the way you use try/except. I didn't even think to catch an exception.

[perfringo]

Let's bend our minds little further

This should be compatible with Python 2 and handle strings as well:

def flatten(lst):
    def _flatten(lst, result):    
        if type(lst) is not list:
            result.append(lst)
        else:
            for item in lst:
                result = result + flatten(item)
        return result
    return _flatten(lst, [])

This will produce:

>>> n = [[1, 2, 3], [[4]], [5], [['spam','ham','bacon'] , [['foo','bar','baz']], ['x','y','z']], 6]
>>> flatten(n)
[1, 2, 3, 4, 5, 'spam', 'ham', 'bacon', 'foo', 'bar', 'baz', 'x', 'y', 'z', 6]

[buran]

def flatten(lst):
    result = []
    for item in lst:
        if isinstance(item, (list, tuple)): # You may add more container types if needed
            result.extend(flatten(item))
        else:
            result.append(item)
    return result
    
n = [[1, 2, 3], [[4]], [5], [['spam','ham','bacon'] , [['foo','bar','baz']], ('x','y','z')], 6]
print flatten(n)

Output:
[1, 2, 3, 4, 5, 'spam', 'ham', 'bacon', 'foo', 'bar', 'baz', 'x', 'y', 'z', 6]

[perfringo]

def flatten(lst):
    result = []
    for item in lst:
        if isinstance(item, (list, tuple)): # You may add more container types if needed
            result.extend(flatten(item))
        else:
            result.append(item)
    return result
    

This is the reason I like Python - smart people (like buran) can achieve desired results with minimal and very readable piece of code. I have lot of work to do in smart part

[Gribouillis]

Using a generic function to dispatch according to the argument's type

>>> import functools
>>> @functools.singledispatch
... def flatten(x):
...     return [x]
... 
>>> @flatten.register(list)
... @flatten.register(tuple)
... def _(x):
...     return [z for y in x for z in flatten(y)]
... 
>>> a = [[1, 2, 3], [[4]], [5], [['spam','ham','bacon'] , [['foo','bar','baz']], ('x','y','z')], 6]
>>> flatten(a)
[1, 2, 3, 4, 5, 'spam', 'ham', 'bacon', 'foo', 'bar', 'baz', 'x', 'y', 'z', 6]