如何删除多余的映射时的函数列表

Question

简单的问题，因为这样

Clear[a, b, c, d, e, f]; 
lst = {{a, b}, {c, d}, {e, f}}; 

列表，并假设我已经定义了这样的功能{}：

foo[x_,y_]:=Module[{},...] 

而且我想这一功能应用到列表中，所以如果我型

Map[foo, lst] 

这给

{foo[{a, b}], foo[{c, d}], foo[{e, f}]} 

我希望它出来作为

{foo[a, b], foo[c, d], foo[e, f]} 

所以它的工作原理。

这样做的最好方法是什么？假设我不能修改函数foo []定义（说它是内置的）

只有2种方式，我知道现在是

Map[foo[#[[1]], #[[2]]] &, lst] 
{foo[a, b], foo[c, d], foo[e, f]} 

（工作量太大），或

MapThread[foo, Transpose[lst]] 
{foo[a, b], foo[c, d], foo[e, f]} 

（少打字，但需要先转位）

问题：还有其他更好的方法可以做到吗？我查看了其他Map和它的朋友，我看不到一个功能比我更直接。

Answer 1

您在Level 1或其缩写形式需要Apply，@@@

foo@@@lst  
{foo[a, b], foo[c, d], foo[e, f]} 

Answer 2

一种可能的方式是从List的lst每个元素的头更改为foo：

foo @@ # & /@ lst 
{foo[a, b], foo[c, d], foo[e, f]} 

Answer 3

一些更多选择的可能性：

This one i是尤达答案的一个更详细的版本。它在列表lst只（用头foo替换头List）的1级适用foo：

Apply[foo, lst, {1}] 

这确实是相同的，但在列表lst（基本上是安德烈的回答）映射Apply：

Map[Apply[foo, #] &, lst ] 

而这只是替换模式列表[X__]以foo在1级[X]：

Replace[lst, List[x__] -> foo[x], 1] 

Answer 4

只是为了报告的两种方法（@@@，@@ # & /@）令人费解的性能测试：

 T = RandomReal[{1,100}, {1000000, 2}]; 

     H[F_Symbol, T_List] := 

        First@AbsoluteTiming[F @@@ T;]/First@AbsoluteTiming[F @@ # & /@ T;] 

     Table[{ToString[F], H[F, T]}, {F, {Plus, Subtract, Times, Divide, Power, Log}}] 

Out[3]= {{"Plus",  4.174757}, 
     {"Subtract", 0.2596154}, 
     {"Times", 3.928230}, 
     {"Divide", 0.2674164}, 
     {"Power", 0.3148629}, 
     {"Log",  0.2986936}} 

这些结果不是随机的，而是大致比例非常不同的数据大小。

@@@是更快Subtract大约3-4次，Divide，Power，Log而@@ # & /@是更快Plus和Times引起另一个问题，这（为一个可以相信）有可能会稍微
通过澄清4倍以下评价：

Attributes@{Plus, Subtract, Times, Divide, Power, Log} 

只有Plus和Times有属性Flat和Orderless，之间的休息，而只有Power（这似乎相对最有效）也有一个属性OneIdentity。

编辑

一个可靠的解释观测到的性能提升（感谢列昂尼德·希夫林的言论）应沿着不同的路线走。

默认情况下有MapCompileLength -> 100，因为我们可以检查评估SystemOptions["CompileOptions"]。 要重置地图autocompilation我们可以评估：

SetSystemOptions["CompileOptions" -> "MapCompileLength" -> Infinity] 

现在我们可以通过评估一次我们H测试的两种方法相对性能 - 对相关符号的性能测试功能列表：

  Table[{ToString[F], H[F, T]}, {F, {Plus, Subtract, Times, Divide, Power, Log}}] 

Out[15]= {{"Plus",  0.2898246}, 
      {"Subtract", 0.2979452}, 
      {"Times",  0.2721893}, 
      {"Divide", 0.3078512}, 
      {"Power",  0.3321622}, 
      {"Log",  0.3258972}} 

有了这些结果，我们可以得出结论，一般来说尤达的方法（@@@）是最有效的，而由Andrei提供的方法在Plus和Times的情况下更好，因为自动编译的Map允许更好的p （@@ # & /@）的性能。

Answer 5

上Apply[]的答案是现货，并且是做正确的事，但你想干什么，用Sequence[]头更换List[]头，即List[List[3,5],List[6,7]]应该成为List[Sequence[3,5],Sequence[6,7]]。

如果删除任何参数列表的头部，序列头就是自然保留的，所以Delete[Plus[3,5],0]和Delete[{3,5},0]和Delete[List[3,5],0]都会产生Sequence[3,5]。

所以foo@Delete[#,0]&/@{{a, b}, {c, d}, {e, f}}会给你一样的foo@@@{{a, b}, {c, d}, {e, f}}。

或者，foo[#/.List->Sequence]&/@{{a, b}, {c, d}, {e, f}}也做同样的事情。