R语言中do.call()的使用说明

这篇文章主要介绍了R语言中do.call()的使用说明，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧

简单参数设置就能搞定的事情，是不会用到do.call的。

在运用R的过程中总会碰到这样一类函数，它们接受的参数数量可以是任意的，该函数会处理这些参数，并返回处理结果。

最简单的例子就是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函数中加入任意多的向量参数（x1,x2,x3都是向量）。

不过现在的情况是：你明确知道你仅将这三个向量拼凑成一个数据框就行了，那么，你写成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

不过，假设你遇到的情况是这样：你现在需要从磁盘上的某个文件中读入所有行次的数据，但是随情况变化，文件的长度会发生改变。

可是你打算编写一个能同时应对各种长度文件的程序，程序目的是将文件中各行的内容竖过来，按列组成一个数据框。

那么请问你有哪些方法？——read.table()+t()，好吧，我承认我又输了，看来do.call还不是最好的选项。

那么如果这个文件各行的类型不同呢？比如一行字符，一行数字，一行布尔值，如此循环延伸，你又能怎么办？

				?

									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）仍然是上述循环，我不要每次都把值押入list中，我直接创建data.frame，之后再用cbind()逐列添加，这样就用不着do.call了

那么现在再次提高难度：取消转置函数t()的使用，不允许使用cbind()函数。那么你只能用do.call了。

我其实一点都不蛮横，只要换一种情境即可——ffbase包，专门处理大数据的扩展包，其中ffdf对象与data.frame类似（不过可容纳更多数据），但不容易增添新列，且无法转置！ffdf函数是什么你不需要知道，你只要知道它也可以添加任意多的参数即可。

好吧，下面就是一个涉及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))

									}

某些情况下，你知道某个函数接受参数的明确个数，但是太多了，你懒，所以用do.call；但更多的情况是你迫不得已，必须用它。

补充：R中的LAPPLY和DO.CALL有什么区别？

最近我在学习R，两个函数lapply和do.call混淆了。看起来，它们和Lisp中的map函数类似。但是为什么有两个不同的名字呢？为什么R不使用称为map的函数？

有一个称为Map的function，可能与其他语言的地图类似：

lapply

返回与X相同长度的列表，其中每个元素都是将FUN应用于X的对应元素的结果。

do.call

构造并执行一个函数调用，从一个名字或一个函数和一个参数列表传递给它。

Map将一个函数应用到给定vector的相应元素… Map是一个简单的mapply包装，它不会试图简化结果，类似于Common Lisp的mapcar（但是参数被回收）。未来的版本可能允许对结果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采用一个函数作为input，并将其他参数泼到函数上。例如，它被广泛用于将列表组装成更简单的结构（通常使用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在列表上应用一个函数， do.call用参数列表调用一个函数。这对我来说看起来很不一样

用列表举个例子：

				?

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

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

				?

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

do.call给出一个错误，正如意味着参数“trim”为1。

另一方面， rbind绑定所有参数。所以绑定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将函数应用于列表的所有元素， do.call调用一个函数，其中所有的函数参数都在列表中。所以对于一个n元素列表， lapply有n函数调用， do.call只有一个函数调用。所以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（）为列表中的每个元素应用一个给定的函数，所以会有几个函数调用。

do.call（）将给定的函数作为一个整体应用于列表，所以只有一个函数调用。

最好的学习方法是在R文档中使用函数示例。

lapply()是一个类似地图的函数。 do.call()是不同的。它用于将parameter passing给列表forms的函数，而不是枚举它们。例如，

				?

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

虽然有很多答案，这里是我的例子供参考。假设我们有一个数据列表：

				?

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

函数lapply返回一个列表。

				?

									lapply(L, sum)

上面的意思就像下面这样。

				?

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

现在让我们为do.call做同样的事情

				?

									do.call(sum, L)

它的意思是

				?

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

在我们的例子中，它返回21.总之，lapply总是返回一个列表，而do.call的返回types实际上取决于执行的函数。

两者的区别是：

				?

									lapply(1:n,function,parameters)

=>这个发送1，参数到function=>这个发送2，参数到function等等

				?

									do.call

只需发送1 … n作为一个向量和参数来运行

所以在应用你有n个函数调用，在do.call中你只有一个

我觉得在这方面一个重要的方面没有得到certificate（或对我来说不明显）。也就是说，您可以使用do.call将list中的命名parameter passing给函数。

例如， runif需要参数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