R语言

您所在的位置:网站首页 R语言apply函数 R语言

R语言

2024-06-12 04:42| 来源: 网络整理| 查看: 265

R语言中的apply函数族 前言

  最初学习R的时候,当成“又一门编程语言”来学习,但是怎么学都觉得别扭。现在我的看法倾向于,R不是一种通用型的编程语言,而是一种统计领域的软件工具。因此,不能用通用型编程的思维来设计R代码。R是一种面向数组(array-oriented)的语法,它更像数学,方便科学家将数学公式转化为R代码。在使用R时,要尽量用array的方式思考,避免for循环。

  这是为什么呢?原因在于R的循环操作for和while,都是基于R语言本身来实现的,而向量操作是基于底层的C语言函数实现的,从性能上来看,就会有比较明显的差距了。那么如何使用C的函数来实现向量计算呢,就是要用到apply的家族函数,包括apply, sapply, tapply, mapply, lapply, rapply, vapply, eapply等。

目录

 1. apply的家族函数

 2. apply函数

 3. lapply函数

 4. sapply函数

 5. vapply函数

 6. mapply函数

 7. tapply函数

 8. rapply函数

 9. eapply函数

 10. example汇总

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: 自定义的调用函数

…: 更多参数,可选

  例1:比如,对一个矩阵的每一行求和,下面就要用到apply做循环了。

> x apply(x,1,sum) [1] 15 18 21 24

  例2:下面计算一个稍微复杂点的例子,按行循环,让数据框的x1列加1,并计算出x1,x2列的均值。

# 生成data.frame > x 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 for(i in 1:nrow(x)){ + row 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 x 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会自动把数据框按列进行分组,再进行计算。

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 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 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 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" 5. 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 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 row.names(a) a x1 x2 a 3 2 b 6 3 c 9 7 d 12 12

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

6. 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 y z 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 m 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 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。那么,我们在使用’…’去传入其他的参数的时候,一定要看清楚传递过程的描述,才不会出现的算法上的错误。

8. 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 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类型的数据进行方便的数据过滤了。

9. 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 env$beta env$logic 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函数使用好。

10. example汇总  Example_1

  split函数能够分解类型更加复杂的对象,我们看下面的例子:我加载了一个叫datasets(数据集)的包,然后观察里面的airquality(空气质量)数据框,你可以看到数据的前6行,数据大概有100行。我们可以看到有Ozone、 Solar.R、 Wind、Tem等的测量值,比如我只想计算Ozone、Solar.R、 Wind和Tem在一个月内的平均值。那么我需要做的是,把这个数据框按月分组,然后利用apply函数或者是colMeans函数来计算不同变量的列均值。

library(datasets) head(airquality) s apply(m, 2, sum) [1] 3 7 11 15 19  Example_3

  一维array的例子(即vector)

> v ind tapply(v, ind) [1] 1 1 1 2 2 > tapply(v, ind, sum) a b 6 9 > tapply(v, ind, fivenum) $a [1] 1.0 1.5 2.0 2.5 3.0 $b [1] 4.0 4.0 4.5 5.0 5.0

  二维array的例子(即matrix)

> m m [,1] [,2] [,3] [,4] [,5] [1,] 1 3 5 7 9 [2,] 2 4 6 8 10 > ind ind [,1] [,2] [,3] [,4] [,5] [1,] 1 1 1 2 2 [2,] 1 1 2 2 2 > tapply(m, ind) [1] 1 1 1 1 1 2 2 2 2 2 > tapply(m, ind, mean) 1 2 3 8 > tapply(m, ind, fivenum) $`1` [1] 1 2 3 4 5 $`2` [1] 6 7 8 9 10  Example_4

by

by(dataframe, INDICES, FUN, ..., simplify=TRUE)

  by 可以当成dataframe上的 tapply 。 indices 应当和dataframe每列的长度相同。返回值是 by 类型的object。若simplify=FALSE,本质上是个list。

> df ind res res ind: 1 a b 2 7 ------------------------------------------------------------ ind: 2 a b 4.5 9.5 > class(res) [1] "by" > names(res) [1] "1" "2"  Example_5

  在 list 上逐个元素调用 FUN 。可以用于dataframe上,因为dataframe是一种特殊形式的list。例

> lst lapply(lst, mean) $a [1] 3 $b [1] 8 > lapply(lst, fivenum) $a [1] 1 2 3 4 5 $b [1] 6 7 8 9 10

  比 lapply 多了一个 simplify 参数。如果 simplify=FALSE ,则等价于 lapply 。否则,在上一种情况的基础上,将 lapply 输出的list简化为vector或matrix。例

> lst sapply(lst, mean) a b 3 8 > sapply(lst, fivenum) a b [1,] 1 6 [2,] 2 7 [3,] 3 8 [4,] 4 9 [5,] 5 10  Example_6 tapply实现crosstable功能

  以一个例子演示。原始数据为按年份year、地区loc和商品类别type进行统计的销售量。我们要制作两个销售总量的crosstable,一个以年份为行、地区为列,一个以年份为行,类别为列。

> df df year loc type sale 1 2001 beijing A 1 2 2001 beijing B 2 3 2001 shanghai A 3 4 2001 shanghai B 4 5 2002 beijing A 5 6 2002 beijing B 6 7 2002 shanghai A 7 8 2002 shanghai B 8 9 2003 beijing A 9 10 2003 beijing B 10 11 2003 shanghai A 11 12 2003 shanghai B 12 > tapply(df$sale, df[,c('year','loc')], sum) loc year beijing shanghai 2001 3 7 2002 11 15 2003 19 23 > tapply(df$sale, df[,c('year','type')], sum) type year A B 2001 4 6 2002 12 14 2003 20 22  Example_7 # code1 x


【本文地址】


今日新闻


推荐新闻


CopyRight 2018-2019 办公设备维修网 版权所有 豫ICP备15022753号-3