Làm thế nào để loại bỏ các phụ {} khi Lập bản đồ một chức năng vào một danh sách

Question

Simple câu hỏi, đưa ra một danh sách như thế này

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

và cho rằng tôi có một hàm được định nghĩa như thế này:

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

Và Tôi muốn áp dụng chức năng này vào danh sách, vì vậy Nếu tôi nhập

Map[foo, lst] 

Điều này cung cấp

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

Tôi muốn nó đi ra như

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

để nó hoạt động.

Cách tốt nhất để làm điều này là gì? Giả sử tôi không thể thay đổi chức năng foo [] định nghĩa (nói nó là xây dựng-in)

Chỉ 2 cách tôi biết bây giờ là

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

(quá nhiều công việc), hoặc

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

(ít đánh máy hơn, nhưng cần phải chuyển vị trí trước)

Câu hỏi: Còn cách nào khác tốt hơn để làm điều này? Tôi đã xem bản đồ khác và bạn bè của nó, và tôi không thể nhìn thấy một chức năng để làm điều đó trực tiếp hơn những gì tôi có.

Answer 1

Bạn cần Apply tại Level 1 hoặc hình thức ngắn của nó, @@@

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

Answer 2

Một cách có thể là thay đổi người đứng đầu mỗi phần tử của lst từ List để foo:

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

Answer 3

Một vài chi tiết khả năng để chọn từ:

Cái này tôi s một phiên bản chi tiết hơn về câu trả lời của yoda.Nó áp dụng foo ở mức 1 của danh sách lst chỉ (thay thế người đứng đầu List với người đứng đầu foo):

Apply[foo, lst, {1}] 

này không giống nhau, nhưng bản đồ Apply qua danh sách lst (thực chất là Andrei của câu trả lời):

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

Và điều này chỉ thay thế Danh sách mẫu [x__] với foo [x] ở mức 1:

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

Answer 4

Chỉ cần báo cáo thử nghiệm hiệu năng khó hiểu của phương pháp cả hai (@@@, @@ # & /@):

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

Các kết quả này không phải ngẫu nhiên, nhưng khoảng tỷ lệ thuận với kích thước dữ liệu rất khác nhau.

@@@ là khoảng 3-4 lần nhanh hơn cho Subtract, Divide, Power, Log khi @@ # & /@ là nhanh hơn gấp 4 lần cho Plus và Times làm phát sinh một câu hỏi, trong đó (như người ta có thể tin rằng) có thể là một chút
làm rõ bởi việc đánh giá sau:

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

chỉ Plus và Times có các thuộc tính Flat và Orderless, trong khi số còn lại chỉ Power (có vẻ tương đối hiệu quả nhất ở đó) cũng có thuộc tính OneIdentity.

Sửa

Một lời giải thích đáng tin cậy để nâng cao hiệu suất quan sát được (nhờ nhận xét Leonid Shifrin của) nên đi dọc theo một con đường khác.

Theo mặc định, có MapCompileLength -> 100 vì chúng tôi có thể kiểm tra đánh giá SystemOptions["CompileOptions"]. Để thiết lập lại autocompilation của Bản đồ chúng ta có thể đánh giá:

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

Bây giờ chúng ta có thể kiểm tra hiệu suất tương đối của các phương pháp cả hai bằng cách đánh giá một lần nữa H của chúng tôi - chức năng kiểm tra hiệu suất trên biểu tượng có liên quan và danh sách:

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

Có những kết quả này chúng ta có thể kết luận rằng cách tiếp cận chung của Yoda (@@@) là hiệu quả nhất, trong khi đó Andrei cung cấp tốt hơn trong trường hợp Plus và Times do biên dịch tự động Map cho phép p tốt hơn sự biến dạng của (@@ # & /@).

Answer 5

Những câu trả lời trên Apply[] là chỗ trên, và là điều đúng đắn nên làm, nhưng những gì bạn đang cố gắng để làm, là để thay thế một đầu List[] với một cái đầu Sequence[], ví dụ: List[List[3,5],List[6,7]] nên trở thành List[Sequence[3,5],Sequence[6,7]].

Đầu chuỗi là thứ tự nhiên vẫn còn nếu đầu của bất kỳ danh sách tham số nào bị xóa, vì vậy, Delete[Plus[3,5],0] và Delete[{3,5},0] và Delete[List[3,5],0] tất cả sẽ tạo ra Sequence[3,5].

Vì vậy, foo@Delete[#,0]&/@{{a, b}, {c, d}, {e, f}} sẽ cung cấp cho bạn giống như foo@@@{{a, b}, {c, d}, {e, f}}.

Hoặc, foo[#/.List->Sequence]&/@{{a, b}, {c, d}, {e, f}} cũng làm như vậy.