disgrating a list

[jwaixs]

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?

Greetz,

Noud Aldenhoven

[Diez B. Roggisch]

jwaixs schrieb:

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]

Why do you wrap a in a list? Just

c = a + [b]

will do it.

Diez

[jwaixs]

Diez B. Roggisch wrote:

Why do you wrap a in a list? Just

c = a + [b]

will do it.

Yes I know, but the problem is I don't know if 'a' is a list or not. I
could make a type check, but I don't want to program in that way.

Noud

[George Sakkis]

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?

No, it doesn't, but it's easy to roll one on your own, e.g. using a
recursive generator; in fact, if you had searched for "flatten" in the
google group of c.l.py, you'd find this: http://tinyurl.com/ndobk
George

[Tim Chase]

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(flatte n(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...re cursion is something that list comprehensions,
map()/reduce() commands, etc. aren't so good as (at least as far
as I've learned).

-tkc

[Peter Otten]

jwaixs wrote:

>
Diez B. Roggisch wrote:

>Why do you wrap a in a list? Just

c = a + [b]

will do it.

Yes I know, but the problem is I don't know if 'a' is a list or not. I
could make a type check, but I don't want to program in that way.

Somewhere in the call chain you have made the decision "I want this function
to accept both lists and scalars", but always passing in lists is probably
the better approach. If you want to go with your original idea -- googling
in c.l.py will turn up many more or less optimized variants of flatten()
that basically follow the same approach as yours. There is also
Tkinter._flatte n() which you can use though it gives you a tuple, not a
list -- the place at least should meet the "obscurity" criterion :-)

Peter

[Hardcoded Software]

Tim Chase wrote:

>>def flatten(x):

... q = []
... for v in x:
... if hasattr(v, '__iter__'):
... q.extend(flatte n(v))
... else:
... q.append(v)
... return q
...

Let's do some nitpicking on "pythonic" style. A more pythonic way to do
it would be:

try:
q.extend(v)
except TypeError:
q.append(v)

[Tal Einat]

Tim Chase wrote:

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

AFAIK and as seen throughout posts on c.l.py, the best way to check if
something is iterable is:

try:
iter(obj)
except TypeError:
<obj is not iterable>
else:
<obj is iterable>

- Tal

[Neil Cerutti]

On 2006-09-01, jwaixs <jw****@gmail.c omwrote:

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:

You might try:

c = a + [b]

instead, to avoid the issue.

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 don't know if the following is the Python way, but I think it's
cute:

def flatten(x):
"""Flatten list x, in place."""
i = 0
while i < len(x):
if isinstance(x[i], list):
x[i:i+1] = x[i]
i = i+1

--
Neil Cerutti
In my prime I could have handled Michael Jordan. Of course, he
would be only 12 years old. --Jerry Sloan

[Neil Cerutti]

On 2006-09-01, Tal Einat <ta************ @gmail.comwrote :

Tim Chase wrote:

>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

AFAIK and as seen throughout posts on c.l.py, the best way to
check if something is iterable is:

try:
iter(obj)
except TypeError:
<obj is not iterable>
else:
<obj is iterable>

That confounds me. Of course, I'm coming from a C++, where you
never want to throw an exception in a common case, hence the name
'exception'. The Python FAQ does say that raising and catching an
exception is an expensive operation. I see that type-checking is
good to avoid, but type-checking must be better than "abusing"
exceptions in this way. Is the above really a popular idiom?

If so, I guess I'll get used to it.

--
Neil Cerutti