दूर करने के लिए कैसे अतिरिक्त {} जब

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]} 

(कम टाइपिंग, लेकिन पहले स्थानांतरित करने की आवश्यकता है)

प्रश्न: उपर्युक्त करने के लिए कोई और बेहतर तरीका? मैंने दूसरे मानचित्र और उसके दोस्तों को देखा, और मैं जो कुछ भी करता हूं उससे ज्यादा सीधे करने के लिए कोई फ़ंक्शन नहीं देख सका।

Answer 1

आप Level 1 या उसके संक्षिप्त रूप में Apply की जरूरत है, @@@

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

Answer 2

एक संभव तरीका foo को List से lst के प्रत्येक तत्व के सिर को बदलने के लिए है:

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

Answer 3

कुछ और से चुनने की संभावनाएं:

यह एक मैं योड के जवाब का एक और वर्बोज़ संस्करण है।यह सूची lst केवल (सिर foo के साथ सिर List बदल देता है) के स्तर 1 पर foo लागू होता है:

Apply[foo, lst, {1}] 

यह वही करता है, लेकिन सूची lst (अनिवार्य रूप से आंद्रेई का जवाब) से अधिक नक्शे Apply:

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

और यह सिर्फ [x] स्तर 1 से पैटर्न की सूची [x__] foo के साथ बदलता है:

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 है केवल(जो अपेक्षाकृत सबसे अधिक कुशल लगता है) में भी OneIdentity विशेषता है।

संपादित

देखे गए प्रदर्शन को बूस्ट करने के लिए एक विश्वसनीय स्पष्टीकरण (लियोनिद Shifrin की टिप्पणी के लिए धन्यवाद) एक अलग मार्ग के साथ जाना चाहिए।

डिफ़ॉल्ट रूप से 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}} 

इन परिणामों के बाद हम निष्कर्ष निकाल सकते हैं कि सामान्य रूप से योड के दृष्टिकोण (@@@) सबसे कुशल हैं, जबकि Plus और Times के मामले में आंद्रेई द्वारा प्रदान किया गया है Map के स्वचालित संकलन के कारण बेहतर पी का विकृति (@@ # & /@)।

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}} वही काम करता है।