R语言 apply函数家族详解

apply {base}

通过对数组或者矩阵的一个维度使用函数生成值得列表或者数组、向量。

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

X 阵列,包括矩阵

MARGIN 1表示矩阵行,2表示矩阵列,也可以是c(1,2)

例:

>xxx<-matrix(1:20,ncol=4)
>apply(xxx,1,mean)
[1] 8.5 9.5 10.5 11.5 12.5
>apply(xxx,2,mean)
[1] 3 8 13 18
>xxx
[,1] [,2] [,3] [,4]
[1,] 1 6 11 16
[2,] 2 7 12 17
[3,] 3 8 13 18
[4,] 4 9 14 19
[5,] 5 10 15 20
lapply {base}

通过对x的每一个元素运用函数,生成一个与元素个数相同的值列表

lapply(X, FUN, ...)

X表示一个向量或者表达式对象,其余对象将被通过as.list强制转换为list

例:

> x <- list(a = 1:10, beta = exp(-3:3), logic = c(TRUE,FALSE,FALSE,TRUE))
> x
$a
[1] 1 2 3 4 5 6 7 8 9 10
$beta
[1] 0.04978707 0.13533528 0.36787944 1.00000000 2.71828183 7.38905610
[7] 20.08553692
$logic
[1] TRUE FALSE FALSE TRUE
> lapply(x,mean)
$a
[1] 5.5
$beta
[1] 4.535125
$logic
[1] 0.5
sapply {base}

这是一个用户友好版本,是lapply函数的包装版。该函数返回值为向量、矩阵,如果simplify=”array”,且合适的情况下,将会通过simplify2array()函数转换为阵列。sapply(x, f, simplify=FALSE, USE.NAMES=FALSE)返回的值与lapply(x,f)是一致的。

sapply(X, FUN, ..., simplify = TRUE, USE.NAMES = TRUE)

X表示一个向量或者表达式对象,其余对象将被通过as.list强制转换为list

simplify 逻辑值或者字符串,如果可以,结果应该被简化为向量、矩阵或者高维数组。必须是命名的,不能是简写。默认值是TRUE,若合适将会返回一个向量或者矩阵。如果simplify=”array”,结果将返回一个阵列。

USE.NAMES 逻辑值,如果为TRUE,且x没有被命名,则对x进行命名。

例:

> sapply(k, paste,USE.NAMES=FALSE,1:5,sep="...")
[,1] [,2] [,3]
[1,] "a...1" "b...1" "c...1"
[2,] "a...2" "b...2" "c...2"
[3,] "a...3" "b...3" "c...3"
[4,] "a...4" "b...4" "c...4"
[5,] "a...5" "b...5" "c...5"
> sapply(k, paste,USE.NAMES=TRUE,1:5,sep="...")
a b c
[1,] "a...1" "b...1" "c...1"
[2,] "a...2" "b...2" "c...2"
[3,] "a...3" "b...3" "c...3"
[4,] "a...4" "b...4" "c...4"
[5,] "a...5" "b...5" "c...5"
> sapply(k, paste,USE.NAMES=TRUE,1:5,sep="...",simplyfy=TRUE)
a b c
[1,] "a...1...TRUE" "b...1...TRUE" "c...1...TRUE"
[2,] "a...2...TRUE" "b...2...TRUE" "c...2...TRUE"
[3,] "a...3...TRUE" "b...3...TRUE" "c...3...TRUE"
[4,] "a...4...TRUE" "b...4...TRUE" "c...4...TRUE"
[5,] "a...5...TRUE" "b...5...TRUE" "c...5...TRUE"
> sapply(k, paste,simplify=TRUE,USE.NAMES=TRUE,1:5,sep="...")
a b c
[1,] "a...1" "b...1" "c...1"
[2,] "a...2" "b...2" "c...2"
[3,] "a...3" "b...3" "c...3"
[4,] "a...4" "b...4" "c...4"
[5,] "a...5" "b...5" "c...5"
> sapply(k, paste,simplify=FALSE,USE.NAMES=TRUE,1:5,sep="...")
$a
[1] "a...1" "a...2" "a...3" "a...4" "a...5"
$b
[1] "b...1" "b...2" "b...3" "b...4" "b...5"
$c
[1] "c...1" "c...2" "c...3" "c...4" "c...5"
vapply {base}

vapply类似于sapply函数,但是它的返回值有预定义类型,所以它使用起来会更加安全,有的时候会更快

在vapply函数中总是会进行简化,vapply会检测FUN的所有值是否与FUN.VALUE兼容,以使他们具有相同的长度和类型。类型顺序:逻辑<</span>整型<</span>实数<</span>复数

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

X表示一个向量或者表达式对象,其余对象将被通过as.list强制转换为list

simplify 逻辑值或者字符串,如果可以,结果应该被简化为向量、矩阵或者高维数组。必须是命名的,不能是简写。默认值是TRUE,若合适将会返回一个向量或者矩阵。如果simplify=”array”,结果将返回一个阵列。

USE.NAMES 逻辑值,如果为TRUE,且x没有被命名,则对x进行命名。

FUN.VALUE 一个通用型向量,FUN函数返回值得模板

例:

> x<-data.frame(a=rnorm(4,4,4),b=rnorm(4,5,3),c=rnorm(4,5,3))
> vapply(x,mean,c(c=0))
a b c
1.8329043 6.0442858 -0.1437202
> k<-function(x)
+ {
+ list(mean(x),sd(x))
+ }
> vapply(x,k,c(c=0))

错误于vapply(x, k, c(c = 0)) : 值的长度必需为1,

但FUN(X[[1]])结果的长度却是2

> vapply(x,k,c(c=0,b=0))

错误于vapply(x, k, c(c = 0, b = 0)) : 值的种类必需是'double',

但FUN(X[[1]])结果的种类却是'list'

> vapply(x,k,c(list(c=0,b=0)))
a b c
c 1.832904 6.044286 -0.1437202
b 1.257834 1.940433 3.649194
tapply {base}

对不规则阵列使用向量,即对一组非空值按照一组确定因子进行相应计算

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

x 一个原子向量,典型的是一个向量

INDEX 因子列表,和x长度一样,元素将被通过as.factor强制转换为因子

simplify 若为FALSE,tapply将以列表形式返回阵列。若为TRUE,FUN则直接返回数值

例:

> height <- c(174, 165, 180, 171, 160)
> sex<-c("F","F","M","F","M")
> tapply(height, sex, mean)
F M
170 170
eapply {base}

eapply函数通过对environment中命名值进行FUN计算后返回一个列表值,用户可以请求所有使用过的命名对象。

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

env 将被使用的环境

all.names 逻辑值,指示是否对所有值使用该函数

USE.NAMES 逻辑值,指示返回的列表结果是否包含命名

例:

> require(stats)
>
> env <- new.env(hash = FALSE) # so the order is fixed
> env$a <- 1:10
> env$beta <- exp(-3:3)
> env$logic <- c(TRUE, FALSE, FALSE, TRUE)
> # what have we there?
> utils::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
>
> # compute the mean for each list element
> eapply(env, mean)
$logic
[1] 0.5
$beta
[1] 4.535125
$a
[1] 5.5
> unlist(eapply(env, mean, USE.NAMES = FALSE))
[1] 0.500000 4.535125 5.500000
>
> # median and quartiles for each element (making use of "..." passing):
> eapply(env, quantile, probs = 1:3/4)
$logic
25% 50% 75%
0.0 0.5 1.0
$beta
25% 50% 75%
0.2516074 1.0000000 5.0536690
$a
25% 50% 75%
3.25 5.50 7.75
> eapply(env, quantile)
$logic
0% 25% 50% 75% 100%
0.0 0.0 0.5 1.0 1.0
$beta
0% 25% 50% 75% 100%
0.04978707 0.25160736 1.00000000 5.05366896 20.08553692
$a
0% 25% 50% 75% 100%
1.00 3.25 5.50 7.75 10.00
mapply {base}

mapply是sapply的多变量版本。将对...中的每个参数运行FUN函数,如有必要,参数将被循环。

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

MoreArgs FUN函数的其他参数列表

SIMPLIFY 逻辑或者字符串,可以减少结果成为一个向量、矩阵或者更高维阵列,详见sapply的simplify参数

USE.NAMES 逻辑值,如果第一个参数...已被命名,将使用这个字符向量作为名字

例:

> mapply(rep, 1:4, 4:1)
[[1]]
[1] 1 1 1 1
[[2]]
[1] 2 2 2
[[3]]
[1] 3 3
[[4]]
[1] 4
rapply {base}

rapply是lapply的递归版本

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

X 一个列表

classes 关于类名的字符向量,或者为any时则匹配任何类

deflt 默认结果,如果使用了how=”replace”,则不能使用

how 字符串匹配三种可能结果

本文分享自微信公众号 - CDA数据分析师(cdacdacda)

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2015-11-07

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏用户2442861的专栏

桶排序

http://blog.csdn.net/houapple/article/details/6480100

23640
来自专栏ACM算法日常

递归算法复杂度Ω分析-分享

1. 深入认识递归 (1) 递归执行过程 例子:求N!。 这是一个简单的"累乘"问题,用递归算法也能解决。 n! ...

10910
来自专栏desperate633

LintCode 数字组合题目分析代码

给出一组候选数字(C)和目标数字(T),找到C中所有的组合,使找出的数字和为T。C中的数字可以无限制重复被选取。

5910
来自专栏tkokof 的技术,小趣及杂念

编程小知识之 Random接口返回值

平日工作中,(伪)随机数的使用一定是避不开的,拿 C# 为例,System 命名空间下的 Random 类型一般都是我们生成(伪)随机数的第一选择:

11930
来自专栏开源优测

[快学Python3]Number(数字)

概述 Python数值数据类型用于存储数值,并有一系列对应的函数用于处理数值类型的数据。 在Python中支持三种不同类型的数值类型: 整型(int) 通常称为...

27090
来自专栏前端儿

最长公共子序列

咱们就不拐弯抹角了,如题,需要你做的就是写一个程序,得出最长公共子序列。 tip:最长公共子序列也称作最长公共子串(不要求连续),英文缩写为LCS(Longes...

15510
来自专栏大闲人柴毛毛

贪心算法(四)——最小代价生成树

问题描述 n个村庄间架设通信线路,每个村庄间的距离不同,如何架设最节省开销? 这个问题中,村庄可以抽象成节点,村庄之间的距离抽象成带权值的边,要求最节约...

81360
来自专栏用户2442861的专栏

最大的子序列和问题

http://blog.csdn.net/zhutulang/article/details/7505785

73310
来自专栏Leetcode名企之路

【Leetcode】81. 搜索旋转排序数组 II

( 例如,数组 [0,0,1,2,2,5,6] 可能变为 [2,5,6,0,0,1,2] )。

23820
来自专栏尾尾部落

[算法总结] 二分查找

二分查找法作为一种常见的查找方法,将原本是线性时间提升到了对数时间范围,大大缩短了搜索时间,但它有一个前提,就是必须在有序数据中进行查找。

23620

扫码关注云+社区

领取腾讯云代金券