lifting functions in python

Question

Say you have a function f:integers -> integers, one should be able to lift this function to act on sets of integers.

I.e. f:sets of integers -> sets of integers, by f({a,b,...}) = {f(a),f(b),...}

How can one do this succinctly in python? That is, not involving iterables (loops), potentially something more native and order-independent.

I would expect f({a,b,...}) to be the syntax, but it's not. Maybe something like act(f,{a,b,...})?

you mean set comprehension? `print({f(x) for x in {1,2,3}})` or `set(map(f,{1,2,3}))` — Jean-François Fabre, Dec 24 '17 at 21:42
note that sets are unordered so order of the result may not match order of the input. — Jean-François Fabre, Dec 24 '17 at 21:43
There's no way to do this without involving iteration. Sure, you can `map` it but, that's iteration too. You're probably after `map`, though. — Dimitris Fasarakis Hilliard, Dec 24 '17 at 21:53
Sweet, Jean's answer is what I was looking for. >There's no way to do with without involving iteration So I might be naive, but if one were able to compute on a GPU, would this "map" function still be iterable, or would the computations be done in parallel? — Noah C, Dec 24 '17 at 21:58
or for GPU pyCUDA: https://stackoverflow.com/questions/41957574/python-rewrite-a-looping-numpy-math-function-to-run-on-gpu — Jean-François Fabre, Dec 24 '17 at 22:37

Miket25 · Accepted Answer · 2017-12-24T22:25:49.150

0

Python 2.7.10

What you described is mapping; it does involve loops in the background, but it achieves your succinctness. Here's an example.

l = [1,2,3]   

#f returns n^2
def f(n):
    return n*n

l = map(f, l) #[1,4,9]

map applies the function f to every element of l.

map also works on sets; however, map returns back a list of values e.g. f({x1,x2,x3}) = [f(x1),f(x2),f(x3)], in an arbitrary order. You can turn the returned list back into a set by wrapping it as a set.

Python 3.6

In Python 3.6, map returns back a map object, and you will need to convert it to your desired typed. This example shows the map object converted to a list.

l = [1,2,3]
def f(n):
    return n*n
l = list(map(f, l)) #[1,4,9]

Alternatively, you can reduce the amount of code further using lambda functions, making it more succinct.

l = [1,2,3]
l = map(lambda x:x*x, l)

Where the lambda expression has the functionality f but used only there and non-existent afterwards.

edited Dec 24 '17 at 22:25

answered Dec 24 '17 at 21:57

Miket25

1,895
3
15
29

Note that the behavior you display is Python 2 only, you need to wrap it in `list`. – Dimitris Fasarakis Hilliard Dec 24 '17 at 21:58
@JimFasarakisHilliard Good call! Let me update it my answer to show the 3.6 behavior. – Miket25 Dec 24 '17 at 22:00
the issue with sets is undefined ordering. there's no way to associate inputs & outputs. – Jean-François Fabre Dec 24 '17 at 22:04

score 0 · Answer 2 · answered Dec 24 '17 at 22:23

The tools you want are map, and in itertools.

For example, to apply f on a collection c of elements, you can use

map(f, c)

Note that the application is lazy in Python 3, and eager in Python 2.7. Alternatively, you can also use a lazy comprehension:

g(f(x) for x in c)

score 0 · Answer 3 · answered Dec 24 '17 at 22:30

0

You can pass multiple arguments as well , like this:

def square(*args) :
    l = []
    for i in args:
        l.append(i**2)
    return l

It'll return like:

>>>> square(1,2,3,4)
>>>> [1,2,9,16]
>>>> square(1)
>>>> [1]
>>>> square(1,6)
>>>> [1,36]

answered Dec 24 '17 at 22:30

Ubdus Samad

1,218
1
15
27

score 0 · Answer 4 · answered Dec 24 '17 at 22:41

In Python currying is not a native feature but you can emulate it using functools.partial. For instance, you can use partial to lift a function f: A -> B to a function f': [A] -> [B].

from functools import partial
def f(...):
    ...

# lift f
f_lifted = partial(map, f)

score -1 · Answer 5 · answered Apr 19 '22 at 11:43

-1

from funcy import curry



def lift(fn):
    return curry(map)(fn)

answered Apr 19 '22 at 11:43

lo tolmencre

3,804
3
30
60

lifting functions in python

5 Answers5