「R」apply,lapply,sapply用法探索
本文节选自张丹的《R的极客理想》系列。
1. apply的家族函数
apply函数族是R语言中数据处理的一组核心函数，通过使用apply函数，我们可以实现对数据的循环、分组、过滤、类型控制等操作。但是，由于在R语言中apply函数与其他语言循环体的处理思路是完全不一样的，所以apply函数族一直是使用者玩不转一类核心函数。
很多R语言新手，写了很多的for循环代码，也不愿意多花点时间把apply函数的使用方法了解清楚，最后把R代码写的跟C似得，我严重鄙视只会写for的R程序员。
apply函数本身就是解决数据循环处理的问题，为了面向不同的数据类型，不同的返回值，apply函数组成了一个函数族，包括了8个功能类似的函数。这其中有些函数很相似，有些也不是太一样的。
我一般最常用的函数为apply和sapply，下面将分别介绍这8个函数的定义和使用方法。
2. apply函数
apply函数是最常用的代替for循环的函数。apply函数可以对矩阵、数据框、数组(二维、多维)，按行或列进行循环计算，对子元素进行迭代，并把子元素以参数传递的形式给自定义的FUN函数中，并以返回计算结果。
函数定义：
apply(X, MARGIN, FUN, ...)
参数列表：
- X:数组、矩阵、数据框
- MARGIN: 按行计算或按按列计算，1表示按行，2表示按列
- FUN: 自定义的调用函数
- …: 更多参数，可选
比如，对一个矩阵的每一行求和，下面就要用到apply做循环了。
> x<-matrix(1:12,ncol=3)
> apply(x,1,sum)
[1] 15 18 21 24
下面计算一个稍微复杂点的例子，按行循环，让数据框的x1列加1，并计算出x1,x2列的均值。
# 生成data.frame
> x <- cbind(x1 = 3, x2 = c(4:1, 2:5)); x
x1 x2
[1,] 3 4
[2,] 3 3
[3,] 3 2
[4,] 3 1
[5,] 3 2
[6,] 3 3
[7,] 3 4
[8,] 3 5
# 自定义函数myFUN，第一个参数x为数据
# 第二、三个参数为自定义参数，可以通过apply的'...'进行传入。
> myFUN<- function(x, c1, c2) {
+ c(sum(x[c1],1), mean(x[c2]))
# 把数据框按行做循环，每行分别传递给myFUN函数，设置c1,c2对应myFUN的第二、三个参数
> apply(x,1,myFUN,c1='x1',c2=c('x1','x2'))
[,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8]
[1,] 4.0 4 4.0 4 4.0 4 4.0 4
[2,] 3.5 3 2.5 2 2.5 3 3.5 4
通过这个上面的自定义函数myFUN就实现了，一个常用的循环计算。
如果直接用for循环来实现，那么代码如下：
# 定义一个结果的数据框
> df<-data.frame()
# 定义for循环
> for(i in 1:nrow(x)){
+ row<-x[i,] # 每行的值
+ df<-rbind(df,rbind(c(sum(row[1],1), mean(row)))) # 计算，并赋值到结果数据框
# 打印结果数据框
V1 V2
1 4 3.5
2 4 3.0
3 4 2.5
4 4 2.0
5 4 2.5
6 4 3.0
7 4 3.5
8 4 4.0
通过for循环的方式，也可以很容易的实现上面计算过程，但是这里还有一些额外的操作需要自己处理，比如构建循环体、定义结果数据集、并合每次循环的结果到结果数据集。
对于上面的需求，还有第三种实现方法，那就是完成利用了R的特性，通过向量化计算来完成的。
> data.frame(x1=x[,1]+1,x2=rowMeans(x))
x1 x2
1 4 3.5
2 4 3.0
3 4 2.5
4 4 2.0
5 4 2.5
6 4 3.0
7 4 3.5
8 4 4.0
那么，一行就可以完成整个计算过程了。
接下来，我们需要再比较一下3种操作上面性能上的消耗。
# 清空环境变量
> rm(list=ls())
# 封装fun1
> fun1<-function(x){
+ myFUN<- function(x, c1, c2) {
+ c(sum(x[c1],1), mean(x[c2]))
+ }
+ apply(x,1,myFUN,c1='x1',c2=c('x1','x2'))
# 封装fun2
> fun2<-function(x){
+ df<-data.frame()
+ for(i in 1:nrow(x)){
+ row<-x[i,]
+ df<-rbind(df,rbind(c(sum(row[1],1), mean(row))))
+ }
# 封装fun3
> fun3<-function(x){
+ data.frame(x1=x[,1]+1,x2=rowMeans(x))
# 生成数据集
> x <- cbind(x1=3, x2 = c(400:1, 2:500))
# 分别统计3种方法的CPU耗时。
> system.time(fun1(x))
用户 系统 流逝
0.01 0.00 0.02
> system.time(fun2(x))
用户 系统 流逝
0.19 0.00 0.18
> system.time(fun3(x))
用户 系统 流逝
0 0 0
从CPU的耗时来看，用for循环实现的计算是耗时最长的，apply实现的循环耗时很短，而直接使用R语言内置的向量计算的操作几乎不耗时。通过上面的测试，对同一个计算来说，优先考虑R语言内置的向量计算，必须要用到循环时则使用apply函数，应该尽量避免显示的使用for,while等操作方法。
3. lapply函数
lapply函数是一个最基础循环操作函数之一，用来对list、data.frame数据集进行循环，并返回和X长度同样的list结构作为结果集，通过lapply的开头的第一个字母’l’就可以判断返回结果集的类型。
函数定义：
lapply(X, FUN, ...)
参数列表：
- X:list、data.frame数据
- FUN: 自定义的调用函数
- …: 更多参数，可选
比如，计算list中的每个KEY对应该的数据的分位数。
# 构建一个list数据集x，分别包括a,b,c 三个KEY值。
> x <- list(a = 1:10, b = rnorm(6,10,5), c = c(TRUE,FALSE,FALSE,TRUE));x
[1] 1 2 3 4 5 6 7 8 9 10
[1] 0.7585424 14.3662366 13.3772979 11.6658990 9.7011387 21.5321427
[1] TRUE FALSE FALSE TRUE
# 分别计算每个KEY对应该的数据的分位数。
> lapply(x,fivenum)
[1] 1.0 3.0 5.5 8.0 10.0
[1] 0.7585424 9.7011387 12.5215985 14.3662366 21.5321427
[1] 0.0 0.0 0.5 1.0 1.0
lapply就可以很方便地把list数据集进行循环操作了，还可以用data.frame数据集按列进行循环，但如果传入的数据集是一个向量或矩阵对象，那么直接使用lapply就不能达到想要的效果了。
比如，对矩阵的列求和。
# 生成一个矩阵
> x <- cbind(x1=3, x2=c(2:1,4:5))
> x; class(x)
x1 x2
[1,] 3 2
[2,] 3 1
[3,] 3 4
[4,] 3 5
[1] "matrix"
> lapply(x, sum)
[[1]]
[1] 3
[[2]]
[1] 3
[[3]]
[1] 3
[[4]]
[1] 3
[[5]]
[1] 2
[[6]]
[1] 1
[[7]]
[1] 4
[[8]]
[1] 5
lapply会分别循环矩阵中的每个值，而不是按行或按列进行分组计算。
如果对数据框的列求和。
> lapply(data.frame(x), sum)
[1] 12
[1] 12
lapply会自动把数据框按列进行分组，再进行计算。
4. sapply函数
sapply函数是一个简化版的lapply，sapply增加了2个参数simplify和USE.NAMES，主要就是让输出看起来更友好，返回值为向量，而不是list对象。
函数定义：
sapply(X, FUN, ..., simplify=TRUE, USE.NAMES = TRUE)
参数列表：
- X:数组、矩阵、数据框
- FUN: 自定义的调用函数
- …: 更多参数，可选
- simplify: 是否数组化，当值array时，输出结果按数组进行分组
- USE.NAMES: 如果X为字符串，TRUE设置字符串为数据名，FALSE不设置
我们还用上面lapply的计算需求进行说明。
> x <- cbind(x1=3, x2=c(2:1,4:5))
# 对矩阵计算，计算过程同lapply函数
> sapply(x, sum)
[1] 3 3 3 3 2 1 4 5
# 对数据框计算
> sapply(data.frame(x), sum)
x1 x2
12 12
# 检查结果类型，sapply返回类型为向量，而lapply的返回类型为list
> class(lapply(x, sum))
[1] "list"
> class(sapply(x, sum))
[1] "numeric"
如果simplify=FALSE和USE.NAMES=FALSE，那么完全sapply函数就等于lapply函数了。
> lapply(data.frame(x), sum)
[1] 12
[1] 12
> sapply(data.frame(x), sum, simplify=FALSE, USE.NAMES=FALSE)
[1] 12
[1] 12
对于simplify为array时，我们可以参考下面的例子，构建一个三维数组，其中二个维度为方阵。
> a<-1:2
# 按数组分组
> sapply(a,function(x) matrix(x,2,2), simplify='array')
, , 1
[,1] [,2]
[1,] 1 1
[2,] 1 1
, , 2
[,1] [,2]
[1,] 2 2
[2,] 2 2
# 默认情况，则自动合并分组
> sapply(a,function(x) matrix(x,2,2))
[,1] [,2]
[1,] 1 2
[2,] 1 2
[3,] 1 2
[4,] 1 2
对于字符串的向量，还可以自动生成数据名。
> val<-head(letters)
# 默认设置数据名
> sapply(val,paste,USE.NAMES=TRUE)