欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

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

程序员文章站 2022-06-27 09:57:06
简单参数设置就能搞定的事情,是不会用到do.call的。在运用r的过程中总会碰到这样一类函数,它们接受的参数数量可以是任意的,该函数会处理这些参数,并返回处理结果。最简单的例子就是data.frame...

简单参数设置就能搞定的事情,是不会用到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 

以上为个人经验,希望能给大家一个参考,也希望大家多多支持。如有错误或未考虑完全的地方,望不吝赐教。

相关标签: R语言 do.call