Flatten a list/tuple and Call a function with tuples
beginner
I am wondering how do I 'flatten' a list or a tuple? For example, I'd
like to transform[1, 2, (3,4)] or [1,2,[3,4]] to [1,2,3,4].
Another question is how do I pass a tuple or list of all the
aurgements of a function to the function. For example, I have all the
arguments of a function in a tuple a=(1,2,3). Then I want to pass each
item in the tuple to a function f so that I make a function call
f(1,2,3). In perl it is a given, but in python, I haven't figured out
a way to do it. (Maybe apply? but it is deprecated?)
Thanks,
cg
kyos...@gmail.com
I'm not sure about the first question, but as for the second, you
could do a few different things. You could just pass the tuple itself
into the function and have the tuple unpacked inside the function.
<code>
f(a)
def f (tuple):
x,y,z = tuple
</code>
You could also pass the elements of the tuple in:
f(a[0], a[1], a[2])
That would do it the way you describe in your post.
Mike
Stargaming
> Hi,
>
> I am wondering how do I 'flatten' a list or a tuple? For example, I'd
> like to transform[1, 2, (3,4)] or [1,2,[3,4]] to [1,2,3,4].
A recursive function, always yielding the first element of the list,
could do the job. See the ASPN Python Cookbook for a few implementations.
http://aspn.activestate.com/ASPN/search?
query=flatten§ion=PYTHONCKBK&type=Subsection
> Another question is how do I pass a tuple or list of all the aurgements
> of a function to the function. For example, I have all the arguments of
> a function in a tuple a=(1,2,3). Then I want to pass each item in the
> tuple to a function f so that I make a function call f(1,2,3). In perl
> it is a given, but in python, I haven't figured out a way to do it.
> (Maybe apply? but it is deprecated?)
>>> def foo(a, b, c): print a, b, c
...
>>> t = (1, 2, 3)
>>> foo(*t)
1 2 3
Have a look at the official tutorial, 4.7.4 http://www.python.org/doc/
current/tut/node6.html#SECTION006740000000000000000
> Thanks,
> cg
HTH,
Stargaming
beginner
> On Wed, 25 Jul 2007 14:50:18 +0000, beginner wrote:
> > Hi,
>
> > I am wondering how do I 'flatten' a list or a tuple? For example, I'd
> > like to transform[1, 2, (3,4)] or [1,2,[3,4]] to [1,2,3,4].
>
> A recursive function, always yielding the first element of the list,
> query=flatten§ion=PYTHONCKBK&type=Subsection
>
> > Another question is how do I pass a tuple or list of all the aurgements
> > of a function to the function. For example, I have all the arguments of
> > a function in a tuple a=(1,2,3). Then I want to pass each item in the
> > tuple to a function f so that I make a function call f(1,2,3). In perl
> > it is a given, but in python, I haven't figured out a way to do it.
> > (Maybe apply? but it is deprecated?)
> >>> def foo(a, b, c): print a, b, c
> ...
> >>> t = (1, 2, 3)
> >>> foo(*t)
>
> 1 2 3
>
> current/tut/node6.html#SECTION006740000000000000000
>
> > Thanks,
> > cg
>
> HTH,
> Stargaming
Hi Stargaming,
I know the * operator. However, a 'partial unpack' does not seem to
work.
def g():
return (1,2)
def f(a,b,c):
return a+b+c
f(*g(),10) will return an error.
Do you know how to get that to work?
Thanks,
cg
kyos...@gmail.com
As I mentioned, you can access the elements individually using square
brackets. The following works:
f(g()[0], g()[1], 10)
But it's not clear. Unfortunately, I'm not seeing much else for tuple
unpacking except the obvious:
a,b=g()
f(a,b,10)
Mike
beginner
>
> - Show quoted text -
Unfortunately f(g()[0], g()[1], 10) is calling g() twice. Sometimes
this is not a good idea.
> a,b=g()
> f(a,b,10)
would work until you want it to be an expression.
Diez B. Roggisch
f(*(g() + (10,))
Not the most beautiful solution, but it works.
Diez
Stargaming
> On Jul 25, 10:19 am, Stargaming <stargam...@gmail.com> wrote:
>> On Wed, 25 Jul 2007 14:50:18 +0000, beginner wrote:
[snip]
http://docs.python.org/ref/calls.html
> Do you know how to get that to work?
Well, there are several ways to solve this. You could either invoke f(*g
() + (10,)). Might be a bit nasty and unreadable, though. Or you could
just change your function f to accept them in reversed order (f(10, *g)
should work) or convert g() to return a dictionary like {'b': 1, 'c': 2}
and use f(10, **g). But if your function f's hugest use case is being
called with g(), changing f to accept something and g's result (tuple) --
unpacking it inside f -- might be better.
Paul Rubin
> I know the * operator. However, a 'partial unpack' does not seem to work.
A few other posters have mentioned ways around this, but you might ask
yourself what coding situation makes you want to do this stuff in the
first place. I won't say there's never a reason for it, but a lot of
times, a list containing a mixture of scalars and lists/tuples is a
sign that your underlying data representation is contorted. Things
are logically single values or they are logically lists of values, and
that mixed representation is often a sign that the item logically
should be a list, and you're hairing up the program with special
treatment of the case where the list has exactly one element.
I.e. instead of [[1,2,], 3, [5,6,]] maybe you really want
[[1,2,], [3,], [5,6]] without the special treatment and flattening.
James Stroud
Were this not hypothetical, I would make use of the commutative property
of addition:
f(10, *g())
Proof:
1+2+10 = 10+1+2
Also, this has not been suggested:
py> def g():
... return (1,2)
...
py> def f(a,b,c):
... return a+b+c
...
py> f(c=10, *g())
13
James
Wildemar Wildenburger
> On Jul 25, 9:50 am, beginner <zyzhu2...@gmail.com> wrote:
>
>> Another question is how do I pass a tuple or list of all the
>> aurgements of a function to the function. For example, I have all the
>> arguments of a function in a tuple a=(1,2,3). Then I want to pass each
>> item in the tuple to a function f so that I make a function call
>> f(1,2,3). In perl it is a given, but in python, I haven't figured out
>> a way to do it. (Maybe apply? but it is deprecated?)
>>
> could do a few different things. You could just pass the tuple itself
> into the function and have the tuple unpacked inside the function.
>
>>> t = 1, 2, 3
>>> f(*t)
bam! :)
This works with dicts as well (for giving keyword arguments). There you
prepend ** (two asterisk to your dict).
Simple :)
/W
attn.st...@gmail.com
You can use the "partial" method from functools:
import functools
sum_of_three = functools.partial(f, *g())(10)
--
Hope this helps,
Steven
George Sakkis
Or if you'd rather write it in one line:
f(*(g() + (10,)))
George
Jeff
def flatten(obj):
if type(obj) not in (list, tuple, str):
raise TypeError("String, list, or tuple expected in
flatten().")
if len(obj) == 1:
if type(obj[0]) in (tuple, list):
return flatten(obj[0])
else:
return [obj[0]]
else:
return [obj[0]] + flatten(obj[1:])
x = [1, 2, (3, 4)]
y = (1, 2, [3, 4])
z = "It even works with strings!"
d = {"foo": "bar", "baz": "bat"}
print flatten(x)
print flatten(y)
print flatten(z)
print flatten(d)
Aneesh Goel
> def flatten(obj):
> if type(obj) not in (list, tuple, str):
> raise TypeError("String, list, or tuple expected in
> flatten().")
> if len(obj) == 1:
> if type(obj[0]) in (tuple, list):
> return flatten(obj[0])
> else:
> return [obj[0]]
> else:
> return [obj[0]] + flatten(obj[1:])
This seems to work fine only if the last object is the only one with
the tuple or list. For example:
>>> y = [(1,2),3,4]
>>> y
[(1, 2), 3, 4]
>>> print flatten(y)
[(1, 2), 3, 4]
if the last line is changed to
return flatten([obj[0]]) + flatten(obj[1:])
then it will unpack tuples/lists anywhere in the main collection being
flattened:
>>> y
[(1, 2), 3, 4]
>>> flatten(y)
[1, 2, 3, 4]
>>> z = [1,(2,3),4]
>>> flatten(z)
[1, 2, 3, 4]
>>> x
[1, 2, (3, 4)]
>>> flatten(x)
[1, 2, 3, 4]
>>> k = [(1,2),(3,4)]
>>> flatten(k)
[1, 2, 3, 4]
Neil Cerutti
> Here's a quick flatten() function:
>
> def flatten(obj):
> if type(obj) not in (list, tuple, str):
> raise TypeError("String, list, or tuple expected in
> flatten().")
> if len(obj) == 1:
> if type(obj[0]) in (tuple, list):
> return flatten(obj[0])
> else:
> return [obj[0]]
> else:
> return [obj[0]] + flatten(obj[1:])
>
> x = [1, 2, (3, 4)]
> y = (1, 2, [3, 4])
> z = "It even works with strings!"
> d = {"foo": "bar", "baz": "bat"}
e = [[1], 2, 3, , 4]
f = [1, 2, 3, 4, []]
--
Neil Cerutti
Neil Cerutti
Please excuse my bad typography. The above should've been
e = [[1], 2, 3, 4].
--
Neil Cerutti
It isn't pollution that is hurting the environment; it's the impurities in our
air and water that are doing it. --Dan Quayle
Eduardo "EdCrypt" O. Padoan
return list(chain(*listOfLists))
>From http://www.python.org/doc/2.4/lib/itertools-recipes.html
--
EduardoOPadoan (eopadoan->altavix::com)
Bookmarks: http://del.icio.us/edcrypt
Jeff
def flatten(obj):
if type(obj) not in (list, tuple, str):
raise TypeError("String, list, or tuple expected in
flatten().")
if len(obj) == 1:
if type(obj[0]) in (tuple, list):
return flatten(obj[0])
else:
return [obj[0]]
else:
if type(obj[0]) in (list, tuple):
return flatten(obj[0]) + flatten(obj[1:])
else:
return [obj[0]] + flatten(obj[1:])
x = (1, 2, [3, 4, (5, 6)])
y = ([1, 2, (3, 4)], 5, 6)
z = (1, [2, 3, (4, 5)], 6)
Jeff
<eopad...@altavix.com> wrote:
> def flatten(listOfLists):
> return list(chain(*listOfLists))
>
> >Fromhttp://www.python.org/doc/2.4/lib/itertools-recipes.html
That doesn't necessarily work:
import itertools
x = (1, 2, [3, 4, (5, 6)])
y = ([1, 2, (3, 4)], 5, 6)
z = (1, [2, 3, (4, 5)], 6)
def flatten(listOfLists):
return list(itertools.chain(*listOfLists))
print flatten(x)
print flatten(y)
print flatten(z)
==> TypeError: chain argument #1 must support iteration
beginner
Very good question. It is well possible that the problem is my
programming style. I am new to python and am still developing a style
that works for me. A lot of things that work in perl does not seem to
work. Unpacking and flattening are just two examples.
I need nested lists to represent nested records in a script. Since the
structure of the underlying data is nested, I think it is probably
reasonable to represent them as nested lists. For example, if I have
the below structure:
Big Record
Small Record Type A
Many Small Record Type B
Small Record Type C
It is pretty natural to use lists, although after a while it is
difficult to figure out the meaning of the fields in the lists. If
only there were a way to 'attach' names to members of the list.
For the unpacking question, I encountered it when working with list
comprehensions. For example:
[ f(*x,1,2) for x in list] is difficult to do if I don't want to
expand *x to x[0]..x[n]. There are usually 7-10 items in the list and
it is very tedious and error prone.
The second problem is from a nested list comprehension. I just needed
something to flatten the list at the moment.
I am still forming my way to do things in python via trial and error.
It is well possible that this is not the natural way to do things.
beginner
>
> py> def g():
> ... return (1,2)
> ...
> py> def f(a,b,c):
> ... return a+b+c
> ...
> py> f(c=10, *g())
> 13
>
>
> - Show quoted text -
Great idea.
beginner
> Well, there are several ways to solve this. You could either invoke f(*g
> () + (10,)). Might be a bit nasty and unreadable, though. Or you could
> just change your function f to accept them in reversed order (f(10, *g)
> should work) or convert g() to return a dictionary like {'b': 1, 'c': 2}
> and use f(10, **g). But if your function f's hugest use case is being
> called with g(), changing f to accept something and g's result (tuple) --
>
> - Show quoted text -
These all work. Thanks.
beginner
> Not the most beautiful solution, but it works.
>
>
> - Show quoted text -
Yeah it works! Thanks.
Steven D'Aprano
> I know the * operator. However, a 'partial unpack' does not seem to
> work.
>
> def g():
> return (1,2)
>
> def f(a,b,c):
> return a+b+c
>
> f(*g(),10) will return an error.
No it doesn't, it _raises_ an exception. This is a function that returns
an error:
def function():
"""Returns an error."""
return Error() # defined elsewhere
But to answer your question:
> Do you know how to get that to work?
It's a little bit messy, but this works:
>>> f(*(g() + (10,)))
13
This is probably easier to read:
>>> t = g() + (10,); f(*t)
13
--
Steven.
Steven D'Aprano
> Things
> are logically single values or they are logically lists of values
Except for strings, and string-like objects.
And files.
And records/structs, and tuples.
And lists. And sets.
And bit strings. And tree-like structures.
And, well, just about everything really.
But apart from those minor exceptions, I agree completely with your
recommendation.
(Ha ha only serious.)
--
Steven.
Jeff
> the below structure:
>
> Big Record
> Small Record Type A
> Many Small Record Type B
> Small Record Type C
>
> It is pretty natural to use lists, although after a while it is
> difficult to figure out the meaning of the fields in the lists. If
> only there were a way to 'attach' names to members of the list.
You could use dictionaries:
big_record = {
"small_record_a": { ... },
"many_small_record_b": {
"sub_record_of_b": { ... },
"sub_record_of_b2": { ... },
},
"small_record_c": { ... },
}
Marc 'BlackJack' Rintsch
> I need nested lists to represent nested records in a script. Since the
> structure of the underlying data is nested, I think it is probably
> reasonable to represent them as nested lists. For example, if I have
> the below structure:
>
> Big Record
> Small Record Type A
> Many Small Record Type B
> Small Record Type C
>
> It is pretty natural to use lists, although after a while it is
> difficult to figure out the meaning of the fields in the lists. If
> only there were a way to 'attach' names to members of the list.
That's where you may start looking into classes. The simplest one is for
just holding attributes seems to be the "bunch":
In [15]: class Bunch(object):
....: def __init__(self, **kwargs):
....: self.__dict__ = kwargs
....:
In [16]: small_a = Bunch(foo=42, bar=23)
In [17]: many_b = [1, 2, 3]
In [18]: small_c = Bunch(name='eric', profession='viking')
In [19]: big_record = Bunch(small_a=small_a, many_b=many_b, small_c=small_c)
In [20]: big_record.small_a.bar
Out[20]: 23
In [21]: big_record.many_b[1]
Out[21]: 2
> For the unpacking question, I encountered it when working with list
> comprehensions. For example:
>
> [ f(*x,1,2) for x in list] is difficult to do if I don't want to
> expand *x to x[0]..x[n]. There are usually 7-10 items in the list and
> it is very tedious and error prone.
If you are the designer of `f` then just receive the whole `x` as *one*
argument.
Ciao,
Marc 'BlackJack' Rintsch