分组函数（tapply，by，aggregate）和* apply family

sapply(vec, f) ：输入是一个向量。 输出是一个向量/矩阵，其中元素i是f(vec[i]) ，如果f具有多元素输出，则给出一个矩阵

lapply(vec, f) ：与sapply相同，但输出是列表？

适用 - 当您想要将函数应用于矩阵（和更高维的类似物）的行或列时; 通常不建议数据帧，因为它首先会强制转换为矩阵。

# 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

如果你想要二维矩阵的行/列平均值或和，一定要调查高度优化的闪电般的colMeans ， rowMeans ， colSums ， rowSums 。

lapply - 当你想依次将一个函数应用到列表中的每个元素并返回列表。

这是许多其他应用函数的主力。 剥离他们的代码，你会经常在下面找到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 - 当你想依次将一个函数应用到列表中的每个元素，但你想要一个向量而不是一个列表。

如果你发现自己打字没有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 - 对于当你有几个数据结构（例如向量，列表），并且你想要对每个元素的第一个元素和每个元素的第二个元素应用一个函数时，将结果强制转换为一个向量/数组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

Map - SIMPLIFY = FALSE包装mapply ，因此保证返回一个列表。

Map(sum, 1:5, 1:5, 1:5)
[[1]]
[1] 3

[[2]]
[1] 6

[[3]]
[1] 9

[[4]]
[1] 12

[[5]]
[1] 15

rapply - 用于当您想要递归地将函数应用于嵌套列表结构的每个元素时。

为了让你了解一些不寻常的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 - 当你想将一个函数应用到一个矢量的子集 ，并且子集由其他矢量定义时，通常是一个因子。

适用于家庭的黑羊，种类繁多。 帮助文件使用短语“粗糙阵列”可能有点令人困惑，但实际上它非常简单。

矢量：

x <- 1:20

定义组的一个因素（长度相同！）：

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

在由y定义的每个子组中，将x的值y ：

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

更复杂的例子可以在子组由几个因素的列表的唯一组合定义的情况下处理。 tapply在精神上类似于R中常见的分裂应用合并函数（ aggregate ， by ， ave ， ddply等），因此它的黑羊状态。