Python：试图折叠第二个参数的函数映射

Question

注意：请在评论之前阅读下面的“更新更新”部分。这里有一些微妙之处。据我所知，没有任何答案在上下文中有效。

我试图找到一个类似于python'map'的函数，它具有略微不同的功能。这个例子最好解释一下。 '地图'功能可以执行以下操作：

In [1]: def f(x,y): 
       return x+y 
In [2]: map(f, ['a','b','c'],['1','2','3']) 

Out[2]: ['a1', 'b2', 'c3'] 

因此，map将f变成一个新函数，我们称之为f_zipper。 f_zipper将其参数压缩并将f应用于每个压缩对。

我想什么来构建的是，我会打电话给“magical_map”，其行为如下功能：

In [1]: def f(x,y): 
       return x+y 
In [2]: magical_map(f, ['a','b','c'],'1') 

Out[2]: ['a1', 'b1', 'c1'] 

所以magical_map让一堆调用F（一个在每个元素第一个参数列表），但它将它们全部折叠到第二个参数上。

注意：我需要一个真正的功能解决方案，可以这么说，因为我不能访问第二个参数。

即我什么都做以后是构建以下功能：

intermed_func = functools.partial(magical_map, f) 
final_func = functools.partial(intermed_func, arg_I_know) 

然后final_func可以被称为

final_func(last_min_arg) 

，并返回

[f(arg_I_know[0], last_min_arg), f(arg_I_know[1], last_min_arg), ...] 

我基本上难以理解如何构建'magical_map'。任何帮助都会很棒。我在这个问题上找不到任何运气。

谢谢！

更好更新：

解决在上下文中的问题比简单地写当两个参数是在一次知道，工作的功能更难。问题是，在这方面他们不知道。更确切地说，我需要能够对所有三个字符串进行以下'final_func'应用分割。现在，使用'map'给出以下行为。

def splitfunc(string, arg): 
    return string.split(arg) 

intermed_func = functools.partial(map, splitfunc) 
final_func = functools.partial(intermed_func, ["a_b","v_c","g,g"]) 

final_func("_") 

Out[xx]: [['a', 'b'], ['v_c'], ['g,g']] 

但是当我将magical_map定义为建议（以下所有方式）时，我得到错误或不正确的行为。例如。

def magical_map(func, mylist, arg): 
    return map(f, mylist, [arg]*len(mylist)) 

然后我运行：

intermed_func = functools.partial(magical_map, splitfunc) 
final_func = functools.partial(intermed_func, ["a_b","v,c","g,g"]) 

final_func("_") 

我得到：

['a_b_', 'v,c_', 'g,g_'] 

Answer 1

这个怎么样慵懒的版本：

>>> def add(x,y): 
...  return x+y 
... 
>>> def magic_map(func,*args): 
...  return itertools.starmap(func,itertools.izip(*args)) #just zip in python 3. 
... 
>>> list(magic_map(add,['a', 'b', 'c'], itertools.repeat('1'))) 
['a1', 'b1', 'c1'] 

请注意，我们需要zip采取两个系列的短，使得我们可以通过一个无限的迭代要么这个论据允许我们使用itertools.repeat扩展一个。这懒洋洋地评价为好，所以我想你甚至可以通过2个无限iterables和它的工作好 - 只要你不尝试实际遍历整个返回的对象;-)

---

这里是一个试图以类似于你在做什么上下文中使用这个（虽然我不完全理解你在做什么，所以这可能是遥远）：

import itertools 
import functools 

def magic_map(func,*args): 
    return itertools.starmap(func,itertools.izip(*args)) #just zip in python 3. 

lst = ["a_b","v_c","g,g"] 
print list(magic_map(str.split, lst, itertools.repeat('_'))) 

intermed_func = functools.partial(magic_map,str.split) 
print list(intermed_func(lst ,itertools.repeat('_'))) 

final_func = functools.partial(intermed_func,lst) 
print list(final_func(itertools.repeat('_'))) 

输出是：

[['a', 'b'], ['v', 'c'], ['g,g']] 
[['a', 'b'], ['v', 'c'], ['g,g']] 
[['a', 'b'], ['v', 'c'], ['g,g']] 

这是你想要的（我认为）。

Answer 2

在Python 3：

像往常一样，这是itertools to the rescue：

>>> import itertools 
>>> list(map(f, ['a','b','c'], itertools.repeat("1"))) 
['a1', 'b1', 'c1'] 

对于多个值，使用itertools.cycle()

>>> list(map(f, ['a','b','c','d'], itertools.cycle("12"))) 
['a1', 'b2', 'c1', 'd2'] 

Answer 3

这个怎么样？

def magical_map(func, list, arg): 
    return map(func, list, [arg]*len(list)) 

实际上，因为这是一个单行函数，所以可能只是写出来而不是单独定义它。

Answer 4

使用itertools.repeat。

def magic_map(f, l, v): 
    return map(f, l, itertools.repeat(v, len(l)) 

使用方法如下：

>>> magic_map(f, ['a', 'b', 'c'], '1') 
['a1', 'b1', 'c1'] 

编辑：

map，为thg435指出，云，直至不再争论结束。

Answer 5

如何

from functools import partial 
def map_with(f, it, **kwargs): 
    return map(partial(f, **kwargs), it) 

def f(x,y): 
    return x+y 

print map_with(f, ['a', 'b', 'c'], y='1') # ['a1', 'b1', 'c1']