Python: how to create a function pointer with a set argument?

My problem:

Given the following:

def foo(a,b)

I am trying to call the python 'map' function while passing in a list for 'a' but use a set value for 'b.'

Another relevant fact is that 'b' is user input and thus, I cannot use the syntax:

def foo(a,b='default value')

I want my 'map' call to look like this:

map(foo_wrapper,list_for_a)

where 'foo_wrapper' is some function that takes in 'a' but uses the user specified 'b.'

I don't know whether function pointers can be specified this way and suspect that they cannot.

My solution to this problem uses globals, so if there's a more elegant way and the above is impossible, I will mark that as the answer as well.

Here is my solution in a nutshell:

b = ''
def foo(a,b):
  print b,a

def foo_wrapper(a):
  foo(a,b)

def main():
  if sys.argv[1]:
    a = ['John', 'Jacob', 'Jingle all the way']
    global b
    b = sys.argv[1]
    map(foo_wrapper,a)

There may be a typo or two in the above; I am simplifying the problem from 开发者_运维技巧what I actually need to do.

Thanks for the replies!

You can use functools.partial() for this purpose:

from functools import partial

def f(a, b):
    return a + b

x = range(10)
print map(partial(f, b=3), x)

prints

[3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

You want something akin to currying. You can just use lambda here:

map(lambda x: f(x,3), a)

Use a list comprehension or a generator expression

[f(x, your_set) for x in your_list]

If you don't need a list as a result, but just a lazy evaluated iterator, you can use a generator expression (or if you meant Python 3's map).

(f(x, your_set) for x in your_list)

Edit:

For your functions that would be:

L = ['John', 'Jacob', 'Jingle all the way']
[foo(a, b=b) for a in L]

List comprehensions are a syntax sugar to replace uses of map with lambda. If you have one of the following:

L2 = map(lambda arg: f(arg) + arg, L1)
L2 = map(lambda (x,y): x + y, L1)
L2 = map(lambda <arg>: <expression>, L1)

They can be rewritten as list comprehensions:

L2 = [f(arg) + arg for arg in L1]
L2 = [x + y for x, y in L1]
L2 = [<expression> for <arg> in L1]

Generator expressions are similar, but instead of a list they return a lazy iterator, and are written with parens instead of square brackets. (And because map in Python 3 is changed to not return lists, there its equivalent is a generator expression.) Sometimes a list is not need, for example when you want to do:

','.join(map(lambda x: x.upper(), L))

The equivalent list comprehension is:

','.join([x.upper() for x in L])

But you actually don't need a list, so you can simply do:

','.join(x.upper() for x in L)