R语言中的apply函数用法_r apply_hs6605015的博客

刚开始接触R语言时，会听到各种的R语言使用技巧，其中最重要的一条就是不要用循环，效率特别低，要用向量计算代替循环计算。
那么，这是为什么呢？原因在于R的循环操作for和while，都是基于R语言本身来实现的，而向量操作是基于底层的C语言函数实现的，从性能上来看，就会有比较明显的差距了。那么如何使用C的函数来实现向量计算呢，就是要用到apply的家族函数，包括apply, sapply, tapply, mapply, lapply, rapply, vapply, eapply等。
1. apply的家族函数

apply函数族是R语言中数据处理的一组核心函数，通过使用apply函数，我们可以实现对数据的循环、分组、过滤、类型控制等操作。但是，由于在R语言中apply函数与其他语言循环体的处理思路是完全不一样的，所以apply函数族一直是使用者玩不转一类核心函数。
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)
  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 <- 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')
  x1 x2
a  3  2
b  6  3
c  9  7
d 12 12
通过使用vapply可以直接设置返回值的行名，这样子做其实可以节省一行的代码，让代码看起来更顺畅，当然如果不愿意多记一个函数，那么也可以直接忽略它，只用sapply就够了 
7. tapply函数
 
tapply用于分组的循环计算，通过INDEX参数可以把数据集X进行分组，相当于group by的操作。 
函数定义： 
tapply(X, INDEX, FUN = NULL, ..., simplify = TRUE)
参数列表： 
X: 向量
 INDEX: 用于分组的索引
 FUN: 自定义的调用函数
 …: 接收多个数据
 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。那么，我们在使用’…’去传入其他的参数的时候，一定要看清楚传递过程的描述，才不会出现的算法上的错误。
                                    R语言apply、lapply、sapply、tspply函数
在描述性统计量方面，R语言提供了数不胜数的选择，这里主要讲apply、lapply、sapply、tspply函数的用法和区别。这四者的基本用法非常相似，都是对的行或者列执行同样的运算，如：mean, sum, sd, var, min, max等，但是针对的数据对象和输出的结果方面有一定的差别。
1、apply
对矩阵、数据框、数组(二维、多维)等矩阵型数据，按行或列应用函数FUN进行循环计算，并以返回计算结果。如果是数据集是数据框，那么系统会将其转为矩阵，但是如果所有列不是数字类型或者类型不一致，将会导致转换失败，那么appl
                                    apply家族函数的使用
对数据集进行操作的时候，我们经常需要写循环操作，比如对于矩阵的每一列计算它的平均值等等，而R语言的向量化操作可以节省非常多循环的代码。所以说在R语言里面，当你要写循环的时候，一定要对自己先说三遍，不写循环！不写循环！不写循环！因为apply()函数就是代替循环写法的一系列非常好用的函数，各式各样批量化的操作都不在话下。之前写过的dplyr包完整指南也是批量操作的一个神器。不过对于普通数据集apply系列的家庭成员们已经完全可以搞定了~下面举例说一下函数的具体用法
1.apply
                                    apply()`可以应用于Pandas中的Series和DataFrame对象。在Series对象上，`apply()`将会对Series中的每个元素应用指定的函数并返回一个新的Series对象；在DataFrame对象上，`apply()`将会对每一行或者每一列应用指定的函数并返回一个新的DataFrame对象。
obj.call(thisObj,arg[,arg2[,arg3[,...agr]]]);
thisObj继承obj的属性和方法(obj原型链上的属性和方法不能被继承),后面的参数会当成obj的参数安装顺序传递进去。
function animal(type,nickname){
    this.type = type;
    this.nickname = nickname;
    this.sayHello = function(){
      return 'h
python apply函数的具体含义如下：
apply(func [, args [, kwargs ]]) 函数用于当函数参数已经存在于一个元组或字典中时，间接地调用函数。args是一个包含将要提供给函数的按位置传递的参数的元组。如果省略了args，任何参数都不会被传递，kwargs是一个包含关键字参数的字典。
apply()的返回值就是func()的返回值，apply()的元素参数是有序的，元素的顺序必须和func()形式参数的顺序一致
二、使用示例：
下面给几个例子来详细的说明一下apply的用法:
1、假设是执行没有带参数的方法：
def say():
apply(x, MARGIN, FUN, ...)
其中，x为数据对象，MARGIN是维度的下标，FUN是由你指定的函 数，而...则包括了任何想传递给FUN的参数。在矩阵或数据框 中，MARGIN=1表示行，MARGIN=2表示列。请看以下例子。
#求矩阵每一行或者每一列的均值，可以使用apply()函数
mydata<-matrix(rnorm(30),nrow=6)#生成服从正态.
                                    R语言的循环效率并不高，所以并不推荐循环以及循环嵌套。为了实现循环功能的情况下，兼顾效率，R语言提供了`apply`系列函数，用于对规则的数据进行函数式的迭代处理。
                                    在R语言中，apply系列函数的基本作用是对数组（array，可以是多维）或者列表（list）按照元素或元素构成的子集合进行迭代，并将当前元素或子集合作为参数调用某个指定函数。apply族函数分别有apply函数，tapply函数，lapply函数，mapply函数。每一个函数都有自己的特点，在处理不同类型的数据可以选用相对应的函数。apply族函数分别有apply函数，tapply函数，lapp
                                    apply 的简单用法指南R中的apply族函数是一组R向量化函数，允许通过数组执行复杂的任务，避免使用for循环。R中的apply() 功能apply可用于数组、矩阵或数据框。apply...
                                    原标题：R语言向量化运算：apply函数族用法心得作者：鲁伟，热爱数据，坚信数据技术和代码改变世界。R语言和Python的忠实拥趸，为成为一名未来的数据科学家而奋斗终生。个人公众号：数据科学家养成记 (微信ID：louwill12)当初入坑R语言的时候，就在各种场合看到老司机的忠告，“尽量避免使用循环！”一开始并不明白这其中的奥义，直到后来对R语言有深入接触后，才领会R语言在向量化运算方面的强大功...
                                    R语言有很重要的apply族函数：lapply sapply apply tapply mapply。这些函数底层通过C实现，效率比手工遍历高效。apply族函数是高效能计算的运算向量化(Vectorization)实现方法之一，比起传统的for,while常常能获得更好的性能。
1. apply 对matrix指定维度操作
###1. apply 对matrix指定维度操作
x <- cbind(x1 = 3, x2 = c(4:1, 2:5),x3= c(1:8))
dimnames(x)
lapply( )不仅适用于向量，也适用于列表。假设我们有一份学生列表：
现在，我们想创建一个字符向量，其中每个元素都具有如下形式：
James, 25 year-old man, loves reading, writing.
函数 sprintf( )通过将占位符（例如：%s 对应字符串，%d 对应整数）替换为相应的输入参数来格式化文本。举个例子：
输出结果：
[1] “Hello, Tom! Your numbe
                                    使用R做数据处理时，基本不需要用循环，而且效率特别低，所以就衍生出来apply族函数代替循环计算。
apply的家族函数，包括apply, sapply, tapply, mapply, lapply, rapply, vapply, eapply等。我们可以实现对数据的循环、分组、过滤、类型控制等操作。
下面将分别介绍这8个函数的定义和使用方法
1、apply
apply函数是最常用的代替for...