apply函数族介绍-来源网络

1 、 apply函数

数据量比较大的时候,R 语言for循环非常的慢,
apply函数是最常用的代替for循环的函数。apply函数可以对矩阵、数据框、数组(二维、多维),按行或列进行循环计算,对子元素进行迭代,并把子元素以参数传递的形式给自定义的FUN函数中,并以返回计算结果。

apply(X, MARGIN, FUN, ...)

X:数组、矩阵、数据框
MARGIN:按行计算或按按列计算,1表示按行,2表示按列
FUN:自定义的调用函数
…:更多参数,可选

示例:对一个矩阵的每一行求和

> x<-matrix(1:12,ncol=4,nrow=3)
> x
     [,1] [,2] [,3] [,4]
[1,]    1    4    7   10
[2,]    2    5    8   11
[3,]    3    6    9   12
> apply(x,1,sum)
[1] 22 26 30

计算一个稍微复杂点的例子,按行循环,让数据框的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))))   # 计算,并赋值到结果数据框
+ }

# 打印结果数据框
> df
  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种操作上面性能上的消耗。
```{r}
# 清空环境变量
> 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等操作方法。

2、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
$a
 [1]  1  2  3  4  5  6  7  8  9 10
$b
[1]  0.7585424 14.3662366 13.3772979 11.6658990  9.7011387 21.5321427
$c
[1]  TRUE FALSE FALSE  TRUE

# 分别计算每个KEY对应该的数据的分位数。
> lapply(x,fivenum)
$a
[1]  1.0  3.0  5.5  8.0 10.0

$b
[1]  0.7585424  9.7011387 12.5215985 14.3662366 21.5321427

$c
[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)
$x1
[1] 12

$x2
[1] 12

lapply会自动把数据框按列进行分组,再进行计算。

3、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不设置

示例:计算list中的每个KEY对应该的数据的分位数。

> 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)
$x1
[1] 12

$x2
[1] 12

> sapply(data.frame(x), sum, simplify=FALSE, USE.NAMES=FALSE)
$x1
[1] 12

$x2
[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)
  a   b   c   d   e   f 
"a" "b" "c" "d" "e" "f" 

# USE.NAMES=FALSE,则不设置数据名
> sapply(val,paste,USE.NAMES=FALSE)
[1] "a" "b" "c" "d" "e" "f"

4、vapply函数

vapply类似于sapply,提供了FUN.VALUE参数,用来控制返回值的行名,这样可以让程序更健壮。

vapply(X, FUN, FUN.VALUE, ..., USE.NAMES = TRUE)

X:数组、矩阵、数据框
FUN:自定义的调用函数
…:更多参数,可选
FUN.VALUE:定义返回值的行名row.names
USE.NAMES: 如果X为字符串,TRUE设置字符串为数据名,FALSE不设置

示例:对数据框的数据进行累计求和,并对每一行设置行名row.names

# 生成数据集
> x <- data.frame(cbind(x1=3, x2=c(2:1,4:5)))

# 设置行名,4行分别为a,b,c,d
> vapply(x,cumsum,FUN.VALUE=c('a'=0,'b'=0,'c'=0,'d'=0))
  x1 x2
a  3  2
b  6  3
c  9  7
d 12 12

# 当不设置时,为默认的索引值
> a<-sapply(x,cumsum);a
     x1 x2
[1,]  3  2
[2,]  6  3
[3,]  9  7
[4,] 12 12

# 手动的方式设置行名
> row.names(a)<-c('a','b','c','d')
> a
  x1 x2
a  3  2
b  6  3
c  9  7
d 12 12

通过使用vapply可以直接设置返回值的行名,
这样子做其实可以节省一行的代码,让代码看起来更顺畅,当然如果不愿意多记一个函数,那么也可以直接忽略它,只用sapply就够了。

5、mapply函数

mapply也是sapply的变形函数,类似多变量的sapply,但是参数定义有些变化。
第一参数为自定义的FUN函数,第二个参数’…’可以接收多个数据,作为FUN函数的参数调用。

mapply(FUN, ..., MoreArgs = NULL, SIMPLIFY = TRUE,USE.NAMES = TRUE)

FUN:自定义的调用函数
…:更多参数,可选
MoreArgs:参数列表
SIMPLIFY:是否数组化,当值array时,输出结果按数组进行分组
USE.NAMES:如果X为字符串,TRUE设置字符串为数据名,FALSE不设置

示例:比较3个向量大小,按索引顺序取较大的值。

> set.seed(1)

# 定义3个向量
> x<-1:10
> y<-5:-4
> z<-round(runif(10,-5,5))

# 按索引顺序取较大的值。
> mapply(max,x,y,z)
 [1]  5  4  3  4  5  6  7  8  9 10

再看一个例子,生成4个符合正态分布的数据集,分别对应的均值和方差为c(1,10,100,1000)。

> set.seed(1)

# 长度为4
> n<-rep(4,4)

# m为均值,v为方差
> m<-v<-c(1,10,100,1000)

# 生成4组数据,按列分组
> mapply(rnorm,n,m,v)
          [,1]      [,2]      [,3]       [,4]
[1,] 0.3735462 13.295078 157.57814   378.7594
[2,] 1.1836433  1.795316  69.46116 -1214.6999
[3,] 0.1643714 14.874291 251.17812  2124.9309
[4,] 2.5952808 17.383247 138.98432   955.0664

由于mapply是可以接收多个参数的,所以我们在做数据操作的时候,就不需要把数据先合并为data.frame了,直接一次操作就能计算出结果了。

6、tapply函数

tapply用于分组的循环计算,通过INDEX参数可以把数据集X进行分组,相当于group by的操作。

tapply(X, INDEX, FUN = NULL, ..., simplify = TRUE)

X:向量
FUN:自定义的调用函数
…:更多参数,可选
INDEX:用于分组的索引
simplify:是否数组化,当值array时,输出结果按数组进行分组

示例:计算不同品种的鸢尾花的花瓣(iris)长度的均值。

# 通过iris$Species品种进行分组
> tapply(iris$Petal.Length,iris$Species,mean)
    setosa versicolor  virginica 
     1.462      4.260      5.552

对向量x和y进行计算,并以向量t为索引进行分组,求和。

> set.seed(1)

# 定义x,y向量
> x<-y<-1:10;x;y
 [1]  1  2  3  4  5  6  7  8  9 10
 [1]  1  2  3  4  5  6  7  8  9 10

# 设置分组索引t
> t<-round(runif(10,1,100)%%2);t
 [1] 1 2 2 1 1 2 1 0 1 1

# 对x进行分组求和
> tapply(x,t,sum)
 0  1  2 
 8 36 11 

由于tapply只接收一个向量参考,通过’…’可以把再传给你FUN其他的参数,那么我们想去y向量也进行求和,把y作为tapply的第4个参数进行计算。

> tapply(x,t,sum,y)
 0  1  2 
63 91 66 

得到的结果并不符合我们的预期,结果不是把x和y对应的t分组后求和,而是得到了其他的结果。
第4个参数y传入sum时,并不是按照循环一个一个传进去的,而是每次传了完整的向量数据,那么再执行sum时sum(y)=55,所以对于t=0时,x=8 再加上y=55,
最后计算结果为63。那么,我们在使用’…’去传入其他的参数的时候,一定要看清楚传递过程的描述,才不会出现的算法上的错误。

7、rapply函数

rapply是一个递归版本的lapply,它只处理list类型数据,对list的每个元素进行递归遍历,如果list包括子元素则继续遍历。

rapply(object, f, classes = "ANY", deflt = NULL, how = c("unlist", "replace", "list"), ...)

object:list数据
f:自定义的调用函数
…:更多参数,可选
classes:匹配类型, ANY为所有类型
deflt:非匹配类型的默认值
how:3种操作方式,当为replace时,则用调用f后的结果替换原list中原来的元素;当为list时,新建一个list,类型匹配调用f函数,不匹配赋值为deflt;当为unlist时,会执行一次unlist(recursive = TRUE)的操作
…: 更多参数,可选

示例:对一个list的数据进行过滤,把所有数字型numeric的数据进行从小到大的排序

> x=list(a=12,b=1:4,c=c('b','a'))
> y=pi
> z=data.frame(a=rnorm(10),b=1:10)
> a <- list(x=x,y=y,z=z)

# 进行排序,并替换原list的值
> rapply(a,sort, classes='numeric',how='replace')
$x
$x$a
[1] 12
$x$b
[1] 4 3 2 1
$x$c
[1] "b" "a"

$y
[1] 3.141593

$z
$z$a
 [1] -0.8356286 -0.8204684 -0.6264538 -0.3053884  0.1836433  0.3295078
 [7]  0.4874291  0.5757814  0.7383247  1.5952808
$z$b
 [1] 10  9  8  7  6  5  4  3  2  1

> class(a$z$b)
[1] "integer"

从结果发现,只有$z$a的数据进行了排序,检查$z$b的类型,发现是integer,是不等于numeric的,所以没有进行排序。

接下来,对字符串类型的数据进行操作,把所有的字符串型加一个字符串’++++’,非字符串类型数据设置为NA。

> rapply(a,function(x) paste(x,'++++'),classes="character",deflt=NA, how = "list")
$x
$x$a
[1] NA
$x$b
[1] NA
$x$c
[1] "b ++++" "a ++++"

$y
[1] NA

$z
$z$a
[1] NA
$z$b
[1] NA

只有$x$c为字符串向量,都合并了一个新字符串。那么,有了rapply就可以对list类型的数据进行方便的数据过滤了

8、eapply函数

对一个环境空间中的所有变量进行遍历。如果我们有好的习惯,把自定义的变量都按一定的规则存储到自定义的环境空间中,
那么这个函数将会让你的操作变得非常方便。当然,可能很多人都不熟悉空间的操作,那么请参考文章 揭开R语言中环境空间的神秘面纱,
解密R语言函数的环境空间。

eapply(env, FUN, ..., all.names = FALSE, USE.NAMES = TRUE)

env:环境空间
FUN:自定义的调用函数
…:更多参数,可选
all.names: 匹配类型, ANY为所有类型
USE.NAMES: 如果X为字符串,TRUE设置字符串为数据名,FALSE不设置

示例:下面我们定义一个环境空间,然后对环境空间的变量进行循环处理。


# 定义一个环境空间
> env# 向这个环境空间中存入3个变量
> env$a <- 1:10
> env$beta <- exp(-3:3)
> env$logic <- c(TRUE, FALSE, FALSE, TRUE)
> env# 查看env空间中的变量
> ls(env)
[1] "a"     "beta"  "logic"

# 查看env空间中的变量字符串结构
> ls.str(env)
a :  int [1:10] 1 2 3 4 5 6 7 8 9 10
beta :  num [1:7] 0.0498 0.1353 0.3679 1 2.7183 ...
logic :  logi [1:4] TRUE FALSE FALSE TRUE

计算env环境空间中所有变量的均值。

> eapply(env, mean)
$logic
[1] 0.5
$beta
[1] 4.535125
$a
[1] 5.5

再计算中当前环境空间中的所有变量的占用内存大小。

# 查看当前环境空间中的变量
> ls()
 [1] "a"     "df"     "env"    "x"     "y"    "z"    "X"  

# 查看所有变量的占用内存大小
> eapply(environment(), object.size)
$a
2056 bytes

$df
1576 bytes

$x
656 bytes

$y
48 bytes

$z
952 bytes

$X
1088 bytes

$env
56 bytes

eapply函数平时很难被用到,但对于R包开发来说,环境空间的使用是必须要掌握的。特别是当R要做为工业化的工具时,对变量的精确控制和管理是非常必要的。

本文全面地介绍了,R语言中的数据循环处理的apply函数族,基本已经可以应对所有的循环处理的情况了。同时,在apply一节中也比较了,3种数据处理方面的性能,R的内置向量计算,要优于apply循环,大幅优于for循环。那么我们在以后的R的开发和使用过程中,应该更多地把apply函数使用好。

忘掉程序员的思维,换成数据的思维,也许你就一下子开朗了。

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 206,214评论 6 481
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 88,307评论 2 382
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 152,543评论 0 341
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 55,221评论 1 279
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 64,224评论 5 371
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 49,007评论 1 284
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 38,313评论 3 399
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 36,956评论 0 259
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 43,441评论 1 300
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,925评论 2 323
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,018评论 1 333
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 33,685评论 4 322
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 39,234评论 3 307
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,240评论 0 19
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,464评论 1 261
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 45,467评论 2 352
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 42,762评论 2 345

推荐阅读更多精彩内容

  • 循环对于代码运行来说是非常消耗时间和资源的,在R中,要尽量少使用for while循环,用apply函数族的话对于...
    willnight阅读 3,450评论 0 2
  • 第一部分Common Lisp介绍第1章 介绍一下Lisp你在学的时候觉得已经明白了,写的时候更加确信了解了,教别...
    geoeee阅读 2,915评论 5 8
  • http://python.jobbole.com/85231/ 关于专业技能写完项目接着写写一名3年工作经验的J...
    燕京博士阅读 7,547评论 1 118
  • 我怎么还没睡 我需要一点味 我得承认异地恋的确比别人累 抱又抱不着我亲又亲不到 睡醒后发现又是没有你的大清早 最怕...
    莞毓阅读 235评论 0 0
  • 虽已入秋,但夏天的威力却一点没减少,太阳仍是360°无死角的曝晒着。作为见“光”死的妹子,简直快要晒到融化啦。是时...
    梅花伞阅读 1,723评论 0 0