jwaixs wrote:
> Hello,
>
> How can I disgrate (probably not a good word for it) a list? For
> example:
>
> a = [1,2]
> b = 3
> c = [a] + [b] # which makes [[1,2],3]
>
> Then how can I change c ([[1,2],3]) into [1,2,3]? I have a simple
> function for this:
> ========================
> def flatten(l):
> r = []
> s = [l]
> while len(s) > 0:
> i = s.pop()
> if i.__class__ == list:
> for c in i:
> s.append(c)
> else:
> r.append(i)
> return r
> ========================
> But this function isn't really doing it in the "python-way". Doesn't
> have python an obscure function or buildin to do this?
I'm not sure what makes it against "the python-way"...I would
likely just use a "for" loop structure rather than a while loop.
I would also skip copying the parameter and popping its
elements off. Lastly, I would use a slightly broader test than
asking if the item is a list (to handle sub-classes, sets,
dictionaries, etc):
>>> def flatten(x):
... q = []
... for v in x:
... if hasattr(v, '__iter__'):
... q.extend(flatten(v))
... else:
... q.append(v)
... return q
...
>>> flatten([1,2,3])
[1, 2, 3]
>>> flatten([1,2,3, [5,6]])
[1, 2, 3, 5, 6]
>>> flatten([1,2,3, [5,6, [7,8]]])
[1, 2, 3, 5, 6, 7, 8]
>>> flatten([1,2,3, [5, {1:3,5:1},6, set([7,8])]])
[1, 2, 3, 5, 1, 5, 6, 8, 7]
I'm not sure if '__iter__' is the right thing to be looking for,
but it seems to work at least for lists, sets, dictionarys (via
their keys), etc. I would use it because at least then you know
you can iterate over it
I don't know of any builtin that will go to arbitrary depths, and
haven't figured out a clean way to do this with any sort of
list-comprehension, reduce/map call, or anything of the like.
The ability to flatten requires recursing down nested data
structures...recursion is something that list comprehensions,
map()/reduce() commands, etc. aren't so good as (at least as far
as I've learned).
-tkc
--
http://mail.python.org/mailman/listinfo/python-list
