簡單參數(shù)設置就能搞定的事情，是不會用到do.call的。

在運用R的過程中總會碰到這樣一類函數(shù)，它們接受的參數(shù)數(shù)量可以是任意的，該函數(shù)會處理這些參數(shù)，并返回處理結果。

最簡單的例子就是data.frame

比如：

> x1 = 1:10
> x2 = 11:20
> x3 = 21:30
> data.frame(x1,x2,x3)
   x1 x2 x3
1   1 11 21
2   2 12 22
3   3 13 23
4   4 14 24
5   5 15 25
6   6 16 26
7   7 17 27
8   8 18 28
9   9 19 29
10 10 20 30

你可以在data.frame函數(shù)中加入任意多的向量參數(shù)（x1,x2,x3都是向量）。

不過現(xiàn)在的情況是：你明確知道你僅將這三個向量拼湊成一個數(shù)據框就行了，那么，你寫成data.frame(x1,x2,x3)是最好的方法，沒必要寫成如下的方式：

> do.call("data.frame",list(x1,x2,x3))
   X1.10 X11.20 X21.30
1      1     11     21
2      2     12     22
3      3     13     23
4      4     14     24
5      5     15     25
6      6     16     26
7      7     17     27
8      8     18     28
9      9     19     29
10    10     20     30

不過，假設你遇到的情況是這樣：你現(xiàn)在需要從磁盤上的某個文件中讀入所有行次的數(shù)據，但是隨情況變化，文件的長度會發(fā)生改變。

可是你打算編寫一個能同時應對各種長度文件的程序，程序目的是將文件中各行的內容豎過來，按列組成一個數(shù)據框。

那么請問你有哪些方法？——read.table()+t()，好吧，我承認我又輸了，看來do.call還不是最好的選項。

那么如果這個文件各行的類型不同呢？比如一行字符，一行數(shù)字，一行布爾值，如此循環(huán)延伸，你又能怎么辦？

f = file("abc.txt", "r")
n = length(count.fields("abc.txt")) / 3
l = list()
for (i in 1:n) {
        l[[(i-1)*3 + 1]] = scan(file = f, sep = ",", nlines = 1, what = "", quiet = TRUE)
        l[[(i-1)*3 + 2]] = scan(file = f, sep = ",", nlines = 1, what = 0, quiet = TRUE)
        l[[(i-1)*3 + 3]] = scan(file = f, sep = ",", nlines = 1, what = TRUE, quiet = TRUE)
}
names(l) = paste("l", 1:length(l), sep = "")
r = do.call("data.frame", l)
print(r)

仍然有替代方案：

（1）我就用read.table()+t()，大不了事后再按列轉換類型！

（2）仍然是上述循環(huán)，我不要每次都把值押入list中，我直接創(chuàng)建data.frame，之后再用cbind()逐列添加，這樣就用不著do.call了

那么現(xiàn)在再次提高難度：取消轉置函數(shù)t()的使用，不允許使用cbind()函數(shù)。那么你只能用do.call了。

我其實一點都不蠻橫，只要換一種情境即可——ffbase包，專門處理大數(shù)據的擴展包，其中ffdf對象與data.frame類似（不過可容納更多數(shù)據），但不容易增添新列，且無法轉置！ffdf函數(shù)是什么你不需要知道，你只要知道它也可以添加任意多的參數(shù)即可。

好吧，下面就是一個涉及ffbase包的程序片段

來感受一下do.call的用法吧：

addStrategyData <- function(detailList, index) {
 
  a = list()
  x = detailList[[index]]
  vMode = sapply(names(x), function(y) switch(y,
      "s" = "integer",
      "t" = "double",
      "f" = "logical"))
                                              
  names(vMode) = names(x)
  x = as.ffdf(x, vmode = vMode)
 
  for (i in 1:ncol(x)) a[[i]] = x[[i]]
  for (i in (length(a) + 1:length(detailList))) a[[i]] = ff(FALSE, length = nrow(x), vmode = "logical")
  a[[ncol(x) + index]] = ff(TRUE, length = nrow(x), vmode = "logical")
  names(a) = c(names(x), paste("S", 1:length(detailList), sep = ""))
  return(do.call("ffdf", a))
}

某些情況下，你知道某個函數(shù)接受參數(shù)的明確個數(shù)，但是太多了，你懶，所以用do.call；但更多的情況是你迫不得已，必須用它。

補充：R中的LAPPLY和DO.CALL有什么區(qū)別？

最近我在學習R，兩個函數(shù)lapply和do.call混淆了。 看起來，它們和Lisp中的map函數(shù)類似。 但是為什么有兩個不同的名字呢？ 為什么R不使用稱為map的函數(shù)？

有一個稱為Map的function，可能與其他語言的地圖類似：

lapply

返回與X相同長度的列表，其中每個元素都是將FUN應用于X的對應元素的結果。

do.call

構造并執(zhí)行一個函數(shù)調用，從一個名字或一個函數(shù)和一個參數(shù)列表傳遞給它。

Map將一個函數(shù)應用到給定vector的相應元素… Map是一個簡單的mapply包裝，它不會試圖簡化結果，類似于Common Lisp的mapcar（但是參數(shù)被回收）。 未來的版本可能允許對結果types進行一些控制。

1、Map是mapply的包裝

2、lapply是mapply

3、因此在許多情況下Map和lapply將是相似的。

例如，這里是lapply ：

 lapply(iris, class) $Sepal.Length [1] "numeric" $Sepal.Width [1] "numeric" $Petal.Length [1] "numeric" $Petal.Width [1] "numeric" $Species [1] "factor" 

和使用Map ：

 Map(class, iris) $Sepal.Length [1] "numeric" $Sepal.Width [1] "numeric" $Petal.Length [1] "numeric" $Petal.Width [1] "numeric" $Species [1] "factor" 

do.call采用一個函數(shù)作為input，并將其他參數(shù)潑到函數(shù)上。 例如，它被廣泛用于將列表組裝成更簡單的結構（通常使用rbind或cbind ）。

例如：

 x <- lapply(iris, class) do.call(c, x) Sepal.Length Sepal.Width Petal.Length Petal.Width Species "numeric" "numeric" "numeric" "numeric" "factor" 

lapply在列表上應用一個函數(shù)， do.call用參數(shù)列表調用一個函數(shù)。 這對我來說看起來很不一樣

用列表舉個例子：

 X <- list(1:3,4:6,7:9) 

用lapply你可以得到列表中每個元素的意思：

 > lapply(X,mean) [[1]] [1] 2 [[2]] [1] 5 [[3]] [1] 8 

do.call給出一個錯誤，正如意味著參數(shù)“trim”為1。

另一方面， rbind綁定所有參數(shù)。 所以綁定X行，你做：

 > do.call(rbind,X) [,1] [,2] [,3] [1,] 1 2 3 [2,] 4 5 6 [3,] 7 8 9 

如果你使用lapply ，R會將rbind應用于列表中的每一個元素，給你這個廢話：

 > lapply(X,rbind) [[1]] [,1] [,2] [,3] [1,] 1 2 3 [[2]] [,1] [,2] [,3] [1,] 4 5 6 [[3]] [,1] [,2] [,3] [1,] 7 8 9 

要有像Map這樣的東西，你需要?mapply ，這是完全不同的東西。 為了得到例如X中每個元素的平均值，但是使用不同的修整，可以使用：

 > mapply(mean,X,trim=c(0,0.5,0.1)) [1] 2 5 8 

lapply與map類似， do.call不是。 lapply將函數(shù)應用于列表的所有元素， do.call調用一個函數(shù)，其中所有的函數(shù)參數(shù)都在列表中。 所以對于一個n元素列表， lapply有n函數(shù)調用， do.call只有一個函數(shù)調用。 所以do.call與lapply完全不同。 希望這個澄清你的問題。

一個代碼示例：

 do.call(sum, list(c(1,2,4,1,2), na.rm = TRUE)) 

和：

 lapply(c(1,2,4,1,2), function(x) x + 1) 

用最簡單的話來說：

lapply（）為列表中的每個元素應用一個給定的函數(shù)，所以會有幾個函數(shù)調用。

do.call（）將給定的函數(shù)作為一個整體應用于列表，所以只有一個函數(shù)調用。

最好的學習方法是在R文檔中使用函數(shù)示例。

lapply()是一個類似地圖的函數(shù)。 do.call()是不同的。 它用于將parameter passing給列表forms的函數(shù)，而不是枚舉它們。 例如，

 > do.call("+",list(4,5)) [1] 9 

雖然有很多答案，這里是我的例子供參考。 假設我們有一個數(shù)據列表：

 L=list(c(1,2,3), c(4,5,6)) 

函數(shù)lapply返回一個列表。

 lapply(L, sum) 

上面的意思就像下面這樣。

 list( sum( L[[1]]) , sum( L[[2]])) 

現(xiàn)在讓我們?yōu)閐o.call做同樣的事情

 do.call(sum, L) 

它的意思是

 sum( L[[1]], L[[2]]) 

在我們的例子中，它返回21.總之，lapply總是返回一個列表，而do.call的返回types實際上取決于執(zhí)行的函數(shù)。

兩者的區(qū)別是：

 lapply(1:n,function,parameters) 

=>這個發(fā)送1，參數(shù)到function=>這個發(fā)送2，參數(shù)到function等等

 do.call 

只需發(fā)送1 … n作為一個向量和參數(shù)來運行

所以在應用你有n個函數(shù)調用，在do.call中你只有一個

我覺得在這方面一個重要的方面沒有得到certificate（或對我來說不明顯）。 也就是說，您可以使用do.call將list中的命名parameter passing給函數(shù)。

例如， runif需要參數(shù)n ， min和max 。 可以使用do.call來傳遞這些信息，如下所示。

 para <- list(n = 10, min = -1, max = 1) do.call(runif, para) #[1] -0.4689827 -0.2557522 0.1457067 0.8164156 -0.5966361 0.7967794 #[7] 0.8893505 0.3215956 0.2582281 -0.8764275 

以上為個人經驗，希望能給大家一個參考，也希望大家多多支持腳本之家。如有錯誤或未考慮完全的地方，望不吝賜教。

最新評論