Applying function to iterable?

Question

I just wrote this function:

def _apply(mols, fn, *args, **kwargs):
    return [fn(m, *args, **kwargs) for m in mols if m ]

And I started thinking:

Can this be rewritten using map?
Is this already implemented in somewhere in python?

As far as I know, map can't pass arguments to the function, on the other hand, it may be somehow optimized and using some partial binding or lambdas I can reimplement it using map. Would that be beneficial?

Somehow can you try to describe what the code is intended to do? — Paulo Bu, Feb 14 '14 at 10:18
@PauloBu - first of all, I changed the example code, previous one was just bad. What it does (or what my intention is), it applies function with args and kwargs to every item of itarable. — mnowotka, Feb 14 '14 at 10:21
Note that `map` is fast only if used with built-in functions, so better use a LC. — Ashwini Chaudhary, Feb 14 '14 at 10:35
@AshwiniChaudhary Even `def` functions would be faster, right? — thefourtheye, Feb 14 '14 at 10:46
@thefourtheye I don't think so, the only difference is that the expression with `lambda` will have to do an additional step of compiling the `lambda` to a code object first. — Ashwini Chaudhary, Feb 14 '14 at 10:59

score 6 · Accepted Answer · edited May 23 '17 at 12:13

6

Yes, you can

from functools import partial

clean = partial(filter, None)

def _apply(mols, fn, *args, **kwargs):
    f = partial(fn, *args, **kwargs)
    return map(f, clean(mols))

def foo(m, a, b, c=123):
    return [m, a, b, c]

print _apply([11,22,'',33], foo, 'aa', 'bb', c=475)

(in python2, consider itertools.imap/ifilter instead of map/filter to avoid temporary lists).

The above illustrates "partial application", even more elegant would be currying, i.e. a function that returns a partially applied version of itself when called with less arguments than expected. Python doesn't have currying built-in, but it's easy to implement as a decorator (see https://stackoverflow.com/a/9458386/989121):

@curry
def join_three(a,b,c):
    return '%s-%s-%s' % (a,b,c)

mols = [11,22,33]
print map(join_three('aa', 'bb'), mols)
# prints ['aa-bb-11', 'aa-bb-22', 'aa-bb-33']

That said, functional style is frowned upon in python, in most cases, comprehensions and generators are more "pythonic".

edited May 23 '17 at 12:13

Community

1
1

answered Feb 14 '14 at 10:26

georg

211,518
52
313
390

Yes, but is it any better then my solution? – mnowotka Feb 14 '14 at 10:27
1

Or simply `return map(partial(fn, *args, **kwargs), mols)`? – thefourtheye Feb 14 '14 at 10:27
And there is a name for this technique, its called Function Currying :) – thefourtheye Feb 14 '14 at 10:47
@thefourtheye: it's "partial application", not "currying". Similar yet different things. – georg Feb 14 '14 at 10:49
@thefourtheye: I added an example to the post. – georg Feb 14 '14 at 11:19

msvalkon · Answer 2 · 2014-02-14T10:46:23.013

2

Although I think what you currently have is quite pretty, something like this might work:

map(lambda m: fn(m, *args, **kwargs), filter(None, mols))

Filters out all elements from mols which evaluate to False, and then applies the function fn to these elements.

Time complexity for the algorithm is O(n).

If your mols is really large you might want to use itertools:

from itertools import imap, ifilter

list(imap(lambda m: fn(m, *args, **kwargs), ifilter(None, mols)))

edited Feb 14 '14 at 10:46

answered Feb 14 '14 at 10:25

msvalkon

11,887
2
42
38

The same comment here - is there any benefit instead of using your solution versus mine? – mnowotka Feb 14 '14 at 10:43
@mnowotka I doubt it. Using itertools might be beneficial speed wise if you've got a huge list of things to process. Your version is good as it is. – msvalkon Feb 14 '14 at 10:48

Applying function to iterable?

2 Answers2