Applying a Map for a Partial Argument

Question

Given the following function f with two arguments, what is the standard way to apply a map only to x?

def f (x,y): print x,y 

In particular, I would like to perform the following operation on a map in one line.

 list=[1,2,3] fixed=10 for s in list: f(s,fixed) 

One way to do this:

 import functools map(functools.partial(lambda x,y:f(y,x),fixed),list) 

What's better?

Answer 1

First of all, there is no need to use lambda AND partial - they are alternatives:

 map(lambda x:f(x,fixed),srclist) 

Secondly, you can simply associate the second argument with partial if you know the name of the argument:

 map(functools.partial(f,y=fixed),srclist) 

Alternatively use a list comprehension:

 [f(x, fixed) for x in srclist] 

Answer 2

 map(lambda x: f(fixed,x), thelist) 

Or don't even use map() at all, use lists instead.

 [f(fixed, x) for x in thelist] 

PS: do not use list as a variable name, this is an important built-in name (list type).

Answer 3

Given the following function f with two arguments, what is the standard way to apply a map only to x?

A little discussion of currying and partial use

In terms of FP, your function f "uncurried" - although it conceptually takes two arguments, they are combined into a single product structure. In Python, everything is careless, all the time. You must immediately give all the arguments, or none of them.

There are various tricks to get around this, but conceptually you just want a curry function. That is, convert f(x,y) to f(x) , which returns a new function g(y) .

In languages ​​that have a default value, you can easily write this translation as:

 -- curry: take a function from (x,y) to one from x to a function from y to z curry :: ((x,y) -> z) -> (x -> y -> z) curry fxy = f (x, y) 

So, curry takes your curried f and its product arguments separately and applies the arguments when they are all available. The opposite is also quite simple:

 uncurry :: (x -> y -> z) -> ((x,y) -> z) uncurry f (x,y) = fxy 

How does this relate to partial applications?

• Currying takes a function that takes a 1 (n-product) argument structure and returns a new function that takes n arguments.
• A partial application takes a function of n arguments and applies them to k arguments, providing the function nk of the remaining arguments.

In an unidentified language, each of the arguments can be applied alternately (for example, partially in relation to the arity of the function). In black, you need to play some tricks to align the function first, as in the examples above.

I think it’s more flexible to be in the environment with the default map, since the partial application is free. In such an environment, functions that change the structure of the data into the pipeline are usually combined. For example. conveyor of whole modifications:

 (+1) . (*2) . (^3) $ 7 

- this is just a chain of partially applied, unprocessed functions, each of which works at the output of the previous function. This can be nice, as it visually separates the problems.

Answer 4

What happened with:

 def add(x, y): return x + y l = [1, 2, 3] from functools import partial plus10 = map(partial(add, y=10), l) print plus10 ## [11, 12, 13]