题 分组函数(tapply,by,aggregate)和* apply系列


每当我想在R中做一些“map”py时,我通常会尝试使用一个函数 apply 家庭。

但是,我从来没有完全理解它们之间的差异 - 如何{sapplylapply等等}将函数应用于输入/分组输入,输出将是什么样的,甚至输入可以是什么 - 所以我经常只是通过它们直到我得到我想要的。

有人可以解释如何使用哪一个?

我当前(可能不正确/不完整)的理解是......

  1. sapply(vec, f):输入是一个向量。输出是矢量/矩阵,其中元素 i 是 f(vec[i]),给你一个矩阵if f 有一个多元素输出

  2. lapply(vec, f): 与...一样 sapply,但输出是一个列表?

  3. apply(matrix, 1/2, f):输入是一个矩阵。输出是一个向量,其中是元素 i 是f(矩阵的row / col i)
  4. tapply(vector, grouping, f):output是一个矩阵/数组,其中矩阵/数组中的元素是值 f 在分组 g 矢量,和 g 被推到行/列名称
  5. by(dataframe, grouping, f):让 g 是一个分组。应用 f 到组/数据帧的每一列。漂亮打印分组和价值 f 在每一栏。
  6. aggregate(matrix, grouping, f): 如同 by但是,聚合将所有内容都粘贴到数据帧中,而不是打印输出。

附带问题:我还没有学过plyr或重塑 - 会 plyr 要么 reshape 完全取代所有这些?


915
2017-08-17 18:31


起源


在你身边的问题:对于很多事情,plyr是直接的替代品 *apply() 和 by。 plyr(至少对我而言)似乎更加一致,因为我总是确切地知道它所期望的数据格式以及它将吐出的确切内容。这给我带来了很多麻烦。 - JD Long
另外,我建议添加: doBy 以及。的选择和应用能力 data.table。 - Iterator
sapply 只是 lapply 加上 simplify2array 在输出上。 apply 确实强制转换为原子矢量,但输出可以是矢量或列表。 by 将数据帧拆分为子数据帧,但不使用 f 在列上分开。只有当'data.frame'类的方法有可能时 f 按列顺序应用 by。 aggregate 是通用的,因此对于第一个参数的不同类存在不同的方法。 - 42-
助记符:l代表'list',s代表'简化',t代表'per type'(分组的每个级别都是一个类型) - Lutz Prechelt


答案:


R具有许多*应用功能,这些功能在帮助文件中有很好的描述(例如 ?apply)。但是,他们中有足够的东西,开始使用可能难以决定哪一个适合他们的情况甚至记住它们。他们可能有一般意义上说“我应该在这里使用* apply函数”,但是最初要保持一致是很困难的。

尽管事实(在其他答案中已经指出),* apply系列的大部分功能都被非常受欢迎的系列覆盖 plyr 包,基本功能仍然有用,值得了解。

这个答案旨在作为一种 路标 for new useRs帮助指导他们针对特定问题的正确* apply函数。注意,这是  旨在简单地反刍或替换R文档!希望这个答案可以帮助您确定哪种*应用功能适合您的情况,然后您可以进一步研究它。除了一个例外,性能差异将无法解决。

  • 应用  - 要将函数应用于行或列时 矩阵(和更高维的类似物);通常不建议使用数据帧,因为它会首先强制转换为矩阵。

    # Two dimensional matrix
    M <- matrix(seq(1,16), 4, 4)
    
    # apply min to rows
    apply(M, 1, min)
    [1] 1 2 3 4
    
    # apply max to columns
    apply(M, 2, max)
    [1]  4  8 12 16
    
    # 3 dimensional array
    M <- array( seq(32), dim = c(4,4,2))
    
    # Apply sum across each M[*, , ] - i.e Sum across 2nd and 3rd dimension
    apply(M, 1, sum)
    # Result is one-dimensional
    [1] 120 128 136 144
    
    # Apply sum across each M[*, *, ] - i.e Sum across 3rd dimension
    apply(M, c(1,2), sum)
    # Result is two-dimensional
         [,1] [,2] [,3] [,4]
    [1,]   18   26   34   42
    [2,]   20   28   36   44
    [3,]   22   30   38   46
    [4,]   24   32   40   48
    

    如果您想要行/列平均值或2D矩阵的总和,请务必 调查高度优化,闪电般快速 colMeansrowMeanscolSumsrowSums

  • lapply  - 当你想将一个函数应用于a的每个元素时 依次列出并获取列表。

    这是许多其他* apply函数的主力。剥 回复他们的代码,你会经常发现 lapply 下。

    x <- list(a = 1, b = 1:3, c = 10:100) 
    lapply(x, FUN = length) 
    $a 
    [1] 1
    $b 
    [1] 3
    $c 
    [1] 91
    lapply(x, FUN = sum) 
    $a 
    [1] 1
    $b 
    [1] 6
    $c 
    [1] 5005
    
  • sapply  - 当你想将一个函数应用于a的每个元素时 反过来列出,但你想要一个 向量 回来,而不是一个清单。

    如果你发现自己在打字 unlist(lapply(...)),停下来考虑一下 sapply

    x <- list(a = 1, b = 1:3, c = 10:100)
    # Compare with above; a named vector, not a list 
    sapply(x, FUN = length)  
    a  b  c   
    1  3 91
    
    sapply(x, FUN = sum)   
    a    b    c    
    1    6 5005 
    

    在更高级的用途 sapply 它将试图强迫 如果合适,结果为多维数组。例如,如果我们的函数返回相同长度的向量, sapply 将它们用作矩阵的列:

    sapply(1:5,function(x) rnorm(3,x))
    

    如果我们的函数返回一个二维矩阵, sapply 将基本上做同样的事情,将每个返回的矩阵作为单个长向量处理:

    sapply(1:5,function(x) matrix(x,2,2))
    

    除非我们指明 simplify = "array",在这种情况下,它将使用单个矩阵来构建一个多维数组:

    sapply(1:5,function(x) matrix(x,2,2), simplify = "array")
    

    这些行为中的每一个当然都取决于我们的函数返回相同长度或维度的向量或矩阵。

  • vapply  - 当你想使用时 sapply 但也许需要 从代码中挤出更多的速度。

    对于 vapply,你基本上给R一个什么样的东西的例子 你的函数将返回,这可以节省一些时间强制返回 值适合单个原子向量。

    x <- list(a = 1, b = 1:3, c = 10:100)
    #Note that since the advantage here is mainly speed, this
    # example is only for illustration. We're telling R that
    # everything returned by length() should be an integer of 
    # length 1. 
    vapply(x, FUN = length, FUN.VALUE = 0L) 
    a  b  c  
    1  3 91
    
  • mapply  - 当你有几个数据结构时(例如 向量,列表)并且您想要将函数应用于第1个元素 每个,然后是每个的第二个元素等,强制结果 到矢量/数组,如 sapply

    在您的功能必须接受的意义上,这是多变量的 多个参数。

    #Sums the 1st elements, the 2nd elements, etc. 
    mapply(sum, 1:5, 1:5, 1:5) 
    [1]  3  6  9 12 15
    #To do rep(1,4), rep(2,3), etc.
    mapply(rep, 1:4, 4:1)   
    [[1]]
    [1] 1 1 1 1
    
    [[2]]
    [1] 2 2 2
    
    [[3]]
    [1] 3 3
    
    [[4]]
    [1] 4
    
  • 地图  - 一个包装 mapply 同 SIMPLIFY = FALSE,所以保证返回一个列表。

    Map(sum, 1:5, 1:5, 1:5)
    [[1]]
    [1] 3
    
    [[2]]
    [1] 6
    
    [[3]]
    [1] 9
    
    [[4]]
    [1] 12
    
    [[5]]
    [1] 15
    
  • rapply  - 当你想要一个函数应用于a的每个元素时 嵌套列表 结构,递归。

    给你一些不寻常的想法 rapply 是的,我在第一次发布这个答案时忘记了!显然,我相信很多人都会使用它,但是YMMV。 rapply 最好用应用的用户定义函数说明:

    # Append ! to string, otherwise increment
    myFun <- function(x){
        if(is.character(x)){
          return(paste(x,"!",sep=""))
        }
        else{
          return(x + 1)
        }
    }
    
    #A nested list structure
    l <- list(a = list(a1 = "Boo", b1 = 2, c1 = "Eeek"), 
              b = 3, c = "Yikes", 
              d = list(a2 = 1, b2 = list(a3 = "Hey", b3 = 5)))
    
    
    # Result is named vector, coerced to character          
    rapply(l, myFun)
    
    # Result is a nested list like l, with values altered
    rapply(l, myFun, how="replace")
    
  • tapply  - 当您想要应用函数时  一个 向量和子集由一些其他向量定义,通常是a 因子。

    *的黑羊适用于各种各样的家庭。帮助文件的使用 短语“衣衫褴褛的阵列”可能有点 扑朔迷离,但实际上 非常简单。

    矢量:

    x <- 1:20
    

    定义组的因子(长度相同!):

    y <- factor(rep(letters[1:5], each = 4))
    

    将值添加到 x 在每个子组内定义 y

    tapply(x, y, sum)  
     a  b  c  d  e  
    10 26 42 58 74 
    

    可以在定义子组的地方处理更复杂的示例 通过几个因素列表的独特组合。 tapply 是 在精神上类似于split-apply-combine功能 常见于R(aggregatebyaveddply等等)因此它 黑羊身份。


1204
2017-08-21 22:50



相信你会发现的 by 是纯粹的分裂和 aggregate 是 tapply 在他们的核心。我认为黑羊制作出色的面料。 - 42-
很棒的回应!这应该是官方R文档:)的一部分。一个小小的建议:也许在使用时添加一些子弹 aggregate 和 by 还有? (在你的描述之后我终于理解了它们,但是它们非常常见,因此分离出来并为这两个函数提供一些具体的例子可能是有用的。) - grautur
@grautur我正在从这个答案中积极地修剪东西,以避免它(a)太长时间和(b)重写文档。我决定这一点 aggregate, by等等基于* apply函数,你使用它们的方式与用户的观点不同,它们应该在一个单独的答案中进行总结。我可能会尝试,如果我有时间,或者也许其他人会打败我,赢得我的upvote。 - joran
也, ?Map 作为亲戚 mapply - baptiste
@jsanders - 我根本不同意这一点。 data.frames是R的绝对核心部分,也是一个 list 对象经常使用 lapply 尤其。它们还充当容器,用于在传统的矩形数据集中将多种类型的矢量/因子分组在一起。而 data.table 和 plyr 可能会添加某种类型的语法,有些人可能会觉得更舒服,他们正在扩展并采取行动 data.frame分别是。 - thelatemail


在旁注,这里是各种各样的 plyr 函数对应于基数 *apply 功能(从plyr网页的介绍到plyr文档 http://had.co.nz/plyr/

Base function   Input   Output   plyr function 
---------------------------------------
aggregate        d       d       ddply + colwise 
apply            a       a/l     aaply / alply 
by               d       l       dlply 
lapply           l       l       llply  
mapply           a       a/l     maply / mlply 
replicate        r       a/l     raply / rlply 
sapply           l       a       laply 

其中一个目标 plyr 是为每个函数提供一致的命名约定,在函数名中对输入和输出数据类型进行编码。它还提供输出的一致性,输出来自 dlply() 很容易通过 ldply() 产生有用的输出等

从概念上讲,学习 plyr 并不比理解基地困难 *apply 功能。

plyr 和 reshape 在我的日常使用中,函数已经取代了几乎所有这些函数。但是,从介绍到Plyr文件:

相关功能 tapply 和 sweep 没有相应的功能 plyr,并保持有用。 merge 对于将摘要与原始数据相结合非常有用。


171
2017-08-17 19:20



当我从头开始学习R时,我发现plyr很容易学习 *apply() 一系列功能。为了我, ddply() 因为我熟悉SQL聚合函数,所以非常直观。 ddply() 成为解决许多问题的锤子,其中一些可以用其他命令更好地解决。 - JD Long
我想我认为背后的概念 plyr 功能类似于 *apply 功能,所以如果你可以做一个,你可以做另一个,但是 plyr 功能更容易记住。但我完全同意 ddply() 锤子! - JoFrhwld
知道了,我不得不尽快拿起plyr!它的前缀单独命名是金... - grautur
+1用于添加关于tapply和sweep的注释。很高兴知道plyr能做什么,不能做什么。 - John Robertson
plyr包装有 join() 执行类似于合并的任务的函数。也许更重要的是在plyr的背景下提及它。 - marbel


来自幻灯片21 http://www.slideshare.net/hadley/plyr-one-data-analytic-strategy

apply, sapply, lapply, by, aggregate

(希望很清楚 apply 对应@Hadley的 aaply 和 aggregate 对应@Hadley的 ddply 如果你没有从这张图片中得到它,那么同一幻灯片的幻灯片20将会澄清。)

(左边是输入,顶部是输出)


119
2017-10-09 05:29



幻灯片中有拼写错误吗?左上角的单元格应该是aaply - JHowIX


首先从 Joran的出色答案  - 怀疑任何事情都可以更好。

然后,以下助记符可能有助于记住每个之间的区别。虽然有些是显而易见的,但有些可能不那么明显 - 对于这些,你会在Joran的讨论中找到理由。

助记符

  • lapply 是一个 名单 应用哪些动作在列表或向量上并返回一个列表。
  • sapply 是一个 简单  lapply (函数默认为在可能的情况下返回向量或矩阵)
  • vapply 是一个 验证申请 (允许预先指定返回对象类型)
  • rapply 是一个 递归 申请嵌套列表,即列表中的列表
  • tapply 是一个 标记 适用于标签识别子集的位置
  • apply  是 通用:将函数应用于矩阵的行或列(或更一般地,应用于数组的维度)

建立正确的背景

如果使用 apply 家人仍然觉得你有点陌生,那么你可能会错过一个关键的观点。

这两篇文章可以提供帮助。他们提供了激励的必要背景 函数式编程技术 正在提供的 apply 一系列功能。

Lisp的用户将立即认识到这种范式。如果你不熟悉Lisp,一旦你了解FP,你将获得一个强大的观点用于R - 和 apply 会更有意义。


88
2018-04-25 00:20





因为我意识到这个帖子的(非常优秀的)答案缺乏 by 和 aggregate 解释。这是我的贡献。

通过

by 函数,如文档中所述,可以作为“包装” tapply。的力量 by 当我们想要计算任务时出现 tapply无法处理。一个例子是这段代码:

ct <- tapply(iris$Sepal.Width , iris$Species , summary )
cb <- by(iris$Sepal.Width , iris$Species , summary )

 cb
iris$Species: setosa
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  2.300   3.200   3.400   3.428   3.675   4.400 
-------------------------------------------------------------- 
iris$Species: versicolor
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  2.000   2.525   2.800   2.770   3.000   3.400 
-------------------------------------------------------------- 
iris$Species: virginica
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  2.200   2.800   3.000   2.974   3.175   3.800 


ct
$setosa
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  2.300   3.200   3.400   3.428   3.675   4.400 

$versicolor
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  2.000   2.525   2.800   2.770   3.000   3.400 

$virginica
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  2.200   2.800   3.000   2.974   3.175   3.800 

如果我们打印这两个对象, ct 和 cb,我们“基本上”具有相同的结果,唯一的区别在于它们如何显示和不同 class 属性,分别 by 对于 cb 和 array 对于 ct

正如我所说,的力量 by 当我们不能使用时出现 tapply;以下代码是一个例子:

 tapply(iris, iris$Species, summary )
Error in tapply(iris, iris$Species, summary) : 
  arguments must have same length

R说参数必须具有相同的长度,比如“我们想要计算 summary 变量中的所有变量 iris 沿着因素 Species“:但是R不能这样做,因为它不知道如何处理。

随着 by 函数R为特定方法调度 data frame 上课然后让 summary 即使第一个参数(和类型)的长度不同,函数仍然有效。

bywork <- by(iris, iris$Species, summary )

bywork
iris$Species: setosa
  Sepal.Length    Sepal.Width     Petal.Length    Petal.Width          Species  
 Min.   :4.300   Min.   :2.300   Min.   :1.000   Min.   :0.100   setosa    :50  
 1st Qu.:4.800   1st Qu.:3.200   1st Qu.:1.400   1st Qu.:0.200   versicolor: 0  
 Median :5.000   Median :3.400   Median :1.500   Median :0.200   virginica : 0  
 Mean   :5.006   Mean   :3.428   Mean   :1.462   Mean   :0.246                  
 3rd Qu.:5.200   3rd Qu.:3.675   3rd Qu.:1.575   3rd Qu.:0.300                  
 Max.   :5.800   Max.   :4.400   Max.   :1.900   Max.   :0.600                  
-------------------------------------------------------------- 
iris$Species: versicolor
  Sepal.Length    Sepal.Width     Petal.Length   Petal.Width          Species  
 Min.   :4.900   Min.   :2.000   Min.   :3.00   Min.   :1.000   setosa    : 0  
 1st Qu.:5.600   1st Qu.:2.525   1st Qu.:4.00   1st Qu.:1.200   versicolor:50  
 Median :5.900   Median :2.800   Median :4.35   Median :1.300   virginica : 0  
 Mean   :5.936   Mean   :2.770   Mean   :4.26   Mean   :1.326                  
 3rd Qu.:6.300   3rd Qu.:3.000   3rd Qu.:4.60   3rd Qu.:1.500                  
 Max.   :7.000   Max.   :3.400   Max.   :5.10   Max.   :1.800                  
-------------------------------------------------------------- 
iris$Species: virginica
  Sepal.Length    Sepal.Width     Petal.Length    Petal.Width          Species  
 Min.   :4.900   Min.   :2.200   Min.   :4.500   Min.   :1.400   setosa    : 0  
 1st Qu.:6.225   1st Qu.:2.800   1st Qu.:5.100   1st Qu.:1.800   versicolor: 0  
 Median :6.500   Median :3.000   Median :5.550   Median :2.000   virginica :50  
 Mean   :6.588   Mean   :2.974   Mean   :5.552   Mean   :2.026                  
 3rd Qu.:6.900   3rd Qu.:3.175   3rd Qu.:5.875   3rd Qu.:2.300                  
 Max.   :7.900   Max.   :3.800   Max.   :6.900   Max.   :2.500     

它确实有效,结果非常令人惊讶。这是一个阶级的对象 by 那个 Species (比如说,对于他们每个人)计算 summary 每个变量。

请注意,如果第一个参数是a data frame,调度函数必须具有该类对象的方法。例如,我们使用此代码 mean 函数我们将拥有完全没有意义的代码:

 by(iris, iris$Species, mean)
iris$Species: setosa
[1] NA
------------------------------------------- 
iris$Species: versicolor
[1] NA
------------------------------------------- 
iris$Species: virginica
[1] NA
Warning messages:
1: In mean.default(data[x, , drop = FALSE], ...) :
  argument is not numeric or logical: returning NA
2: In mean.default(data[x, , drop = FALSE], ...) :
  argument is not numeric or logical: returning NA
3: In mean.default(data[x, , drop = FALSE], ...) :
  argument is not numeric or logical: returning NA

骨料

aggregate 可以看作是另一种不同的使用方式 tapply 如果我们以这种方式使用它。

at <- tapply(iris$Sepal.Length , iris$Species , mean)
ag <- aggregate(iris$Sepal.Length , list(iris$Species), mean)

 at
    setosa versicolor  virginica 
     5.006      5.936      6.588 
 ag
     Group.1     x
1     setosa 5.006
2 versicolor 5.936
3  virginica 6.588

两个直接的区别在于第二个论点 aggregate  必须 成为一个清单 tapply  能够 (不是强制性的)是一个列表和输出 aggregate 是一个数据框而一个是 tapply 是一个 array

的力量 aggregate 是它可以轻松处理数据的子集 subset 参数和它有方法 ts 对象和 formula 同样。

这些元素使 aggregate 更容易使用它 tapply 在某些情况下。 以下是一些示例(可在文档中找到):

ag <- aggregate(len ~ ., data = ToothGrowth, mean)

 ag
  supp dose   len
1   OJ  0.5 13.23
2   VC  0.5  7.98
3   OJ  1.0 22.70
4   VC  1.0 16.77
5   OJ  2.0 26.06
6   VC  2.0 26.14

我们可以实现同样的目标 tapply 但语法稍微困难,输出(在某些情况下)可读性较差:

att <- tapply(ToothGrowth$len, list(ToothGrowth$dose, ToothGrowth$supp), mean)

 att
       OJ    VC
0.5 13.23  7.98
1   22.70 16.77
2   26.06 26.14

还有一些我们不能使用的时候 by 要么 tapply 我们必须使用 aggregate

 ag1 <- aggregate(cbind(Ozone, Temp) ~ Month, data = airquality, mean)

 ag1
  Month    Ozone     Temp
1     5 23.61538 66.73077
2     6 29.44444 78.22222
3     7 59.11538 83.88462
4     8 59.96154 83.96154
5     9 31.44828 76.89655

我们无法获得以前的结果 tapply 在一次通话中我们必须计算平均值 Month 对于每个元素然后将它们组合起来(还要注意我们必须调用它们 na.rm = TRUE,因为 formula 的方法 aggregate 函数默认有 na.action = na.omit):

ta1 <- tapply(airquality$Ozone, airquality$Month, mean, na.rm = TRUE)
ta2 <- tapply(airquality$Temp, airquality$Month, mean, na.rm = TRUE)

 cbind(ta1, ta2)
       ta1      ta2
5 23.61538 65.54839
6 29.44444 79.10000
7 59.11538 83.90323
8 59.96154 83.96774
9 31.44828 76.90000

与...同时 by 实际上以下函数调用返回错误(但很可能与提供的函数有关,我们实际上无法实现) mean):

by(airquality[c("Ozone", "Temp")], airquality$Month, mean, na.rm = TRUE)

其他时候结果是相同的,差异只是在类中(然后它是如何显示/打印的,而不仅仅是 - 例如,如何将其子集化)对象:

byagg <- by(airquality[c("Ozone", "Temp")], airquality$Month, summary)
aggagg <- aggregate(cbind(Ozone, Temp) ~ Month, data = airquality, summary)

以前的代码实现了相同的目标和结果,在某些方面,使用的工具只是个人品味和需求的问题;前两个对象在子集方面有非常不同的需求。


39
2017-08-28 02:28



正如我所说的那样,当我们不能使用tapply时,会产生权力;以下代码就是一个例子:这就是你在上面所使用的词汇。并且您已经给出了计算摘要的示例。好吧,我们可以说汇总统计数据只能计算它需要清理:例如 data.frame(tapply(unlist(iris[,-5]),list(rep(iris[,5],ncol(iris[-5])),col(iris[-5])),summary)) 这是tapply的用法. With the right splitting there is nothing you cant do with tapply. The only thing is it returns a matrix. Please be careful by saying we cant use tapply` - Onyambu


有很多很好的答案可以讨论每个函数的用例差异。答案都没有讨论性能上的差异。这是合理的,因为各种函数期望各种输入并产生各种输出,但是它们中的大多数具有通过系列/组来评估的一般共同目标。我的回答是关注绩效。由于上述原因,从矢量创建的输入包含在时间中,也包括在内 apply功能未测量。

我测试了两种不同的功能 sum 和 length 立刻。测试的体积输入为50M,输出为50K。我还包括两个目前流行的包,当问到问题时没有广泛使用, data.table 和 dplyr。如果你的目标是良好的表现,那么两者绝对值得一看。

library(dplyr)
library(data.table)
set.seed(123)
n = 5e7
k = 5e5
x = runif(n)
grp = sample(k, n, TRUE)

timing = list()

# sapply
timing[["sapply"]] = system.time({
    lt = split(x, grp)
    r.sapply = sapply(lt, function(x) list(sum(x), length(x)), simplify = FALSE)
})

# lapply
timing[["lapply"]] = system.time({
    lt = split(x, grp)
    r.lapply = lapply(lt, function(x) list(sum(x), length(x)))
})

# tapply
timing[["tapply"]] = system.time(
    r.tapply <- tapply(x, list(grp), function(x) list(sum(x), length(x)))
)

# by
timing[["by"]] = system.time(
    r.by <- by(x, list(grp), function(x) list(sum(x), length(x)), simplify = FALSE)
)

# aggregate
timing[["aggregate"]] = system.time(
    r.aggregate <- aggregate(x, list(grp), function(x) list(sum(x), length(x)), simplify = FALSE)
)

# dplyr
timing[["dplyr"]] = system.time({
    df = data_frame(x, grp)
    r.dplyr = summarise(group_by(df, grp), sum(x), n())
})

# data.table
timing[["data.table"]] = system.time({
    dt = setnames(setDT(list(x, grp)), c("x","grp"))
    r.data.table = dt[, .(sum(x), .N), grp]
})

# all output size match to group count
sapply(list(sapply=r.sapply, lapply=r.lapply, tapply=r.tapply, by=r.by, aggregate=r.aggregate, dplyr=r.dplyr, data.table=r.data.table), 
       function(x) (if(is.data.frame(x)) nrow else length)(x)==k)
#    sapply     lapply     tapply         by  aggregate      dplyr data.table 
#      TRUE       TRUE       TRUE       TRUE       TRUE       TRUE       TRUE 

# print timings
as.data.table(sapply(timing, `[[`, "elapsed"), keep.rownames = TRUE
              )[,.(fun = V1, elapsed = V2)
                ][order(-elapsed)]
#          fun elapsed
#1:  aggregate 109.139
#2:         by  25.738
#3:      dplyr  18.978
#4:     tapply  17.006
#5:     lapply  11.524
#6:     sapply  11.326
#7: data.table   2.686

30
2017-12-08 22:42



dplyr低于applt函数是正常的吗? - Dimitri Petrenko
@DimitriPetrenko我不这么认为,不知道为什么会在这里。最好根据自己的数据进行测试,因为有很多因素可以发挥作用。 - jangorecki


这可能值得一提 aveave 是 tapply亲切的堂兄。它以一种形式返回结果,您可以直接插回数据框。

dfr <- data.frame(a=1:20, f=rep(LETTERS[1:5], each=4))
means <- tapply(dfr$a, dfr$f, mean)
##  A    B    C    D    E 
## 2.5  6.5 10.5 14.5 18.5 

## great, but putting it back in the data frame is another line:

dfr$m <- means[dfr$f]

dfr$m2 <- ave(dfr$a, dfr$f, FUN=mean) # NB argument name FUN is needed!
dfr
##   a f    m   m2
##   1 A  2.5  2.5
##   2 A  2.5  2.5
##   3 A  2.5  2.5
##   4 A  2.5  2.5
##   5 B  6.5  6.5
##   6 B  6.5  6.5
##   7 B  6.5  6.5
##   ...

基本包中没有任何东西可以像 ave 对于整个数据帧(如 by 就好像 tapply 对于数据框)。但你可以捏造它:

dfr$foo <- ave(1:nrow(dfr), dfr$f, FUN=function(x) {
    x <- dfr[x,]
    sum(x$m*x$m2)
})
dfr
##     a f    m   m2    foo
## 1   1 A  2.5  2.5    25
## 2   2 A  2.5  2.5    25
## 3   3 A  2.5  2.5    25
## ...

20
2017-11-06 00:00





尽管这里有很多很好的答案,但还有2个基本功能值得一提,非常有用 outer 功能和模糊 eapply 功能

outer 是一个非常有用的功能隐藏作为一个更普通的功能。如果您阅读了帮助 outer 它的描述说:

The outer product of the arrays X and Y is the array A with dimension  
c(dim(X), dim(Y)) where element A[c(arrayindex.x, arrayindex.y)] =   
FUN(X[arrayindex.x], Y[arrayindex.y], ...).

这似乎只对线性代数类型的东西有用。但是,它可以很像使用 mapply 将函数应用于两个输入向量。不同之处在于 mapply 将函数应用于前两个元素,然后应用于后两个元素,而 outer 将该函数应用于来自第一个向量的一个元素和来自第二个向量的一个元素的每个组合。例如:

 A<-c(1,3,5,7,9)
 B<-c(0,3,6,9,12)

mapply(FUN=pmax, A, B)

> mapply(FUN=pmax, A, B)
[1]  1  3  6  9 12

outer(A,B, pmax)

 > outer(A,B, pmax)
      [,1] [,2] [,3] [,4] [,5]
 [1,]    1    3    6    9   12
 [2,]    3    3    6    9   12
 [3,]    5    5    6    9   12
 [4,]    7    7    7    9   12
 [5,]    9    9    9    9   12

当我有一个值向量和一个条件向量时,我亲自使用了这个,并希望看到哪些值符合哪些条件。

eapply

eapply 就好像 lapply 除了不将函数应用于列表中的每个元素,它将函数应用于环境中的每个元素。例如,如果要在全局环境中查找用户定义函数的列表:

A<-c(1,3,5,7,9)
B<-c(0,3,6,9,12)
C<-list(x=1, y=2)
D<-function(x){x+1}

> eapply(.GlobalEnv, is.function)
$A
[1] FALSE

$B
[1] FALSE

$C
[1] FALSE

$D
[1] TRUE 

坦率地说,我不会使用它,但如果你正在构建大量的软件包或创建很多环境,它可能会派上用场。


20
2018-05-16 03:59