Function that turns sequence into list

Question

We know that

list(map(f,[1,2],[3,4],[6,7]))

is equivalent to

[f(1,3,6),f(2,4,7)]

I want to know if there is built-in function tolist that is equivalent to [], so that

tolist(a,b,c,d)

is equivalent to [a,b,c,d].

I think such a function is useful in functional programming. Because many functions take list parameter instead of sequence.

Of course, a simple custom way is lambda *x:list(x), but I always feels it is syntactically cumbersome, especially use it in functional programming style like

map(lambda *x:list(x),[1,2],[3,4],[6,7])

So my question is that if there is no such built-in tolist, whether we could build it on the fly more elegantly using FP packages like toolz?

PS: What I actually want to achieve is threaded version of add (I know numpy, but I don't want to use it at the moment)

from toolz.curried import *
import operator as op
def addwise(*args):
    return list(map(compose(reduce(op.add),lambda *x:list(x)),*args))

then

addwise([1,2],[3,4],[6,7])

will gives

[10, 13]

I don't think there is a builtin. You can write it as `def tolist(*args): return list(args)`, but I can't see why you would want to (you can do most of the things with a tuple that you can with a list). — Martin Bonner supports Monica, Nov 16 '17 at 08:05
In particular, the arguments to `map` are *iterables*, not lists. — Martin Bonner supports Monica, Nov 16 '17 at 08:08
Hi, @MartinBonner. Thank you very much for reply. But I don't understand your "you can do most of the things with a tuple that you can with a list". What does it mean? And is it possible to make `addwise` more succinct(especially get rid of lambda)? — user15964, Nov 16 '17 at 15:14
you could write it as `lambda*x:x`, which 7 chars shorter... — georgexsh, Nov 17 '17 at 20:36

score 1 · Answer 1 · edited Nov 27 '17 at 02:55

If

function is useful (....) Because many functions take list parameter

it is a good sign that lambda expression is not a right fit. You don't want to repeat yourself every time you want to apply this pattern.

Sadly we are far from Clojure conciseness:

user=> (map + [1 2] [3 4] [6 7])
(10 13)

but we can still express it in a fairly Pythonic and elegant way:

def apply(f):
    def _(*args):
        return f(args)
    return _

which can be used as:

from toolz.curried import reduce 

map(apply(reduce(op.add)), [1,2], [3,4], [6,7])

or even better

map(apply(sum), [1,2], [3,4], [6,7])

although in this case map, can be combined with zip:

map(sum, zip([1, 2], [3, 4], [6, 7])))

Function that turns sequence into list

1 Answers1