各种apply

属于循环函数

lapply:用途,有一个对象列表,遍历这个对象列表,对列表的每个元素运用函数

sapply:是lapply的一个变体,简化了lapply()的结果

apply:对数组进行行或列运算的函数,对矩阵和高维数组做总结

tapply:table apply()的缩写,将函数应用于向量的子集

mapply:是lapply的多变量版本

split:不对对象做任何操作,将对象分成子块,和lapply,sapply结合使用

lapply

定义

lapply(X, FUN,...)

处理对象：列表（list）、向量（会被自动转为列表）、数据框（按列处理，因数据框本质是列组成的列表）。不是列表会强制转换成列表，as.list，转换失败则报错

操作逻辑：对 X 中的每个元素（如列表的每个子元素、向量的每个值、数据框的每列）应用函数 FUN。这个可以是匿名函数

。。。：函数FUN对应的参数

返回结果：始终是列表（与输入 X 长度相同）。

参数

X：需要处理的对象，可以是列表（list）、向量（vector）、数据框（data.frame）等。如果是向量或数据框，会被自动转换为列表处理。

FUN：要应用于 X 中每个元素的函数（可以是内置函数、自定义函数或匿名函数）。

...：可选参数，传递给 FUN 的额外参数。

lapply(1:3,runif,min=0,max=10)
输出：
[[1]]
[1] 7.468843

[[2]]
[1] 7.222380 1.295965

[[3]]
[1] 6.203360 7.137720 8.839319

x <- list(a = matrix(1:4,2,2),b = matrix(1:6,3,2) )
lapply(x, function(e){e[,1]})
输出：
$a
[1] 1 2

$b
[1] 1 2 3

sapply(X, FUN,...)

定义

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

处理对象：与 lapply 相同（列表、向量、数据框）。

操作逻辑：功能与 lapply 一致，是 lapply 的 “简化版”。

返回结果：会自动根据结果简化格式（若可能）：

若结果长度均为 1的列表，返回向量；

若结果长度相同且大于 1的列表，返回矩阵；

否则返回列表（与 lapply 一致）。

参数

X：需要处理的对象，可以是向量、列表、数据框等（会被转换为列表处理）。

FUN：要应用于 X 中每个元素的函数（内置函数、自定义函数或匿名函数）。

...：传递给 FUN 的额外参数。

simplify：逻辑值（默认 TRUE），控制是否简化返回结果：

TRUE（默认）：尝试将结果简化为向量、矩阵或数组；

FALSE：返回列表（与 lapply() 效果一致）。

USE.NAMES：逻辑值（默认 TRUE），若 X 有名称，是否在结果中保留名称。

# 向量型
lapply(1:3, function(x) x^2)
sapply(1:3, function(x) x^2)
输出：
> lapply(1:3, function(x) x^2)
[[1]]
[1] 1

[[2]]
[1] 4

[[3]]
[1] 9

> sapply(1:3, function(x) x^2)
[1] 1 4 9

#矩阵
x <- list(a=c(1:3),b=c(4:6))
lapply(x, function(x) x^2)
sapply(x,function(x) x^2)
输出：
> x <- list(a=c(1:3),b=c(4:6))
> lapply(x, function(x) x^2)
$a
[1] 1 4 9

$b
[1] 16 25 36

> sapply(x,function(x) x^2)
     a  b
[1,] 1 16
[2,] 4 25
[3,] 9 36

#列表
x <- list(a = matrix(1:4,2,2),b = matrix(1:6,3,2) )
lapply(x, function(e){e[,1]})
sapply(x,function(e){e[,1]})
输出：
> x <- list(a = matrix(1:4,2,2),b = matrix(1:6,3,2) )
> lapply(x, function(e){e[,1]})
$a
[1] 1 2

$b
[1] 1 2 3

> 
> sapply(x,function(e){e[,1]})
$a
[1] 1 2

$b
[1] 1 2 3

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

定义

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

处理对象：矩阵（matrix）、数据框（data.frame）等二维结构。

操作逻辑：对矩阵 / 数据框的行或列应用函数 FUN。

参数 MARGIN：指定按行（1）还是按列（2）操作，c(1,2) 表示同时按行和列。

参数...：fun的参数

返回结果：

若按行 / 列操作结果为单值，返回向量；

否则返回矩阵。

若函数 FUN 对每行 / 列返回单个值，则返回一个向量（长度等于行数或列数）；

若函数 FUN 返回多个值，则返回一个矩阵（行 / 列数与结果长度匹配）。

参数

X：必需，要处理的二维对象（矩阵 matrix 或数据框 data.frame）。

MARGIN：必需，指定操作维度的整数：

1：表示对行应用函数；

2：表示对列应用函数；

c(1, 2)：表示同时对行和列应用函数（较少用）。

FUN：必需，要应用的函数（可以是内置函数，如 sum、mean；也可以是自定义函数）。

...：可选，传递给 FUN 的额外参数。

示例

#返回向量
a <- array(rnorm(8),c(2,2,2))
a
apply(a, 1, mean)
apply(matrix(1:4,2,2), 1, sum)
输出：
> a <- array(rnorm(8),c(2,2,2))
> a
, , 1

            [,1]      [,2]
[1,] 1.084975792 -1.543686
[2,] 0.002772449 -1.345166

, , 2

           [,1]       [,2]
[1,] -2.2785034 -1.2829330
[2,]  0.2937729 -0.7703536

> # apply(a, c(1,2), mean)
> apply(a, 1, mean)
[1] -1.0050367 -0.4547435
> apply(matrix(1:4,2,2), 1, sum)
[1] 4 6

#矩阵
apply(a, c(1,2), mean)
输出：
> apply(a, c(1,2), mean)
           [,1]     [,2]
[1,] -0.5967638 -1.41331
[2,]  0.1482727 -1.05776

#处理数据框
> df <- data.frame(a = 1:3,b = 4:6,c = 7:9)
> col_sd <- apply(df, 2, sd)
> print(col_sd)
a b c 
1 1 1 
> apply(df, 1,function(x) sum(x^2))
[1]  66  93 126

#处理NA
> mat_with_na <- matrix(c(1:5, NA, 7:12), nrow = 3)
> col_means_na <- apply(mat_with_na, 2, mean, na.rm = TRUE)
> print(col_means_na) 
[1]  2.0  4.5  8.0 11.0

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

定义

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

属于lapply和sapply的多变量版。

处理对象：多个向量 / 列表（长度可以不同，按最短长度循环）。

操作逻辑：对多个输入对象的对应元素同时应用函数 FUN（类似 “多变量循环”）。

参数

FUN：必需，要应用的函数（可以是内置函数、自定义函数或匿名函数）。

...：多个输入对象（向量、列表等），函数 FUN 的参数会按这些对象的对应元素依次取值。

MoreArgs：可选，一个列表，包含需要传递给 FUN 的额外固定参数（不参与循环的参数）。

SIMPLIFY：逻辑值，默认 TRUE，表示自动简化结果（转为向量 / 矩阵）；FALSE 则返回列表。

USE.NAMES：逻辑值，默认 TRUE，若输入有命名，会为结果添加名称。

返回结果：若 SIMPLIFY=TRUE（默认），返回简化后的向量 / 矩阵；否则返回列表。

示例

mapply() 的核心是 **“并行迭代”**：对多个输入对象（如 x1, x2, ..., xn），依次取每个对象的第 1 个元素、第 2 个元素…… 作为函数 FUN 的参数，执行函数并收集结果。

例如，对 x = c(a1, a2, a3) 和 y = c(b1, b2, b3)，mapply(FUN, x, y) 等价于：

list(FUN(a1, b1), FUN(a2, b2), FUN(a3, b3))

#应用向量
> mapply(sum,1:3,4:6)
[1] 5 7 9
> mapply(sum,1:3,4:6,SIMPLIFY = FALSE)
[[1]]
[1] 5

[[2]]
[1] 7

[[3]]
[1] 9

#自定义函数
> mapply(function(a,b,c) a+b+c,1:3,4:6,7)
[1] 12 14 16
#MoreArgs不参与函数内部循环，参与的是函数调用的循环，比如c长度3，则会调用3次function
> mapply(function(a,b,c) a+b+c,1:3,4:6,MoreArgs = list(c=c(7,8,9)))
     [,1] [,2] [,3]
[1,]   12   14   16
[2,]   13   15   17
[3,]   14   16   18
> mapply(function(a,b,c,d) a*b+c+d,1:3,4:6,MoreArgs = list(c=c(7,8),d=c(9,10,11)))
     [,1] [,2] [,3]
[1,]   20   26   34
[2,]   22   28   36
[3,]   22   28   36
警告信息:
1: In a * b + c + d : 长的对象长度不是短的对象长度的整倍数
2: In a * b + c + d : 长的对象长度不是短的对象长度的整倍数
3: In a * b + c + d : 长的对象长度不是短的对象长度的整倍数

tapply

定义

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

处理对象：向量（X），结合分组因子（INDEX）。

操作逻辑：先按 INDEX 对向量 X 进行分组，再对每个组应用函数 FUN。

参数 INDEX：一个或多个因子（factor），用于指定分组方式（类似 SQL 中的 GROUP BY）。

返回结果：通常为向量或数组（分组结果的汇总）。

参数

X：必需，待处理的向量（数值型、字符型等均可）。

INDEX：必需，一个或多个因子（factor） 组成的列表，用于指定分组方式（即按什么规则分组）。

FUN：必需，用于每个分组的函数（如 mean、sum、length 等）。

...：可选，传递给 FUN 的额外参数（如 na.rm = TRUE 用于忽略缺失值）。

default：可选，当分组中无数据时的默认返回值，默认为 NA。

simplify：可选，逻辑值，若为 TRUE（默认），则尝试将结果简化为向量或数组；若为 FALSE，则始终返回列表。

示例

> height <- c(175, 162, 180, 158, 178, 165)
> gender <- factor(c("男", "女", "男", "女", "男", "女"))
> tapply(X = height, INDEX = gender, FUN = mean)
      男       女 
177.6667 161.6667 
> height <- c(175, 162, 180, 158, 178, 165)
> gender <- factor(c("男", "女", "男", "女", "男", "女"))
> tapply(X = height, INDEX = gender, FUN = mean,simplify = FALSE)
$男
[1] 177.6667

$女
[1] 161.6667

#多因子嵌套组合
> score <- c(85, 92, 78, 90, 88, 76, 95, 82)
> gender <- factor(c("男", "女", "男", "女", "男", "女", "男", "女"))
> age_group <- factor(c("青年", "青年", "中年", "中年", "青年", "青年", "中年", "老年"))
> tapply(X = score, INDEX = list(gender, age_group), FUN = mean, na.rm = TRUE)
   老年 青年 中年
男   NA 86.5 86.5
女   82 84.0 90.0

#处理缺失值
> data <- c(1, 2, NA, 4, 5, NA)
> group <- factor(c("X", "X", "X", "Y", "Y", "Y"))
> tapply(data, group, mean) 
 X  Y 
NA NA 
> tapply(data, group, mean, na.rm = TRUE)
  X   Y 
1.5 4.5 
> 

总结

处理列表 / 向量且需要明确返回列表 → lapply；

处理列表 / 向量且希望结果简化 → sapply；

处理矩阵 / 数据框的行 / 列 → apply；

需要分组统计（按因子分组） → tapply；

需要对多个输入对象的对应元素操作 → mapply。