【R语言】R语言中的循环

张敬信

哈尔滨工业大学基础数学博士

编程中减少代码重复的两个工具，一是循环，一是函数。

循环，用来处理对多个同类输入做相同事情（即迭代），如对不同列做相同操作、对不同数据集做相同操作。

R语言有三种方式实现循环：

（1）for循环、while循环

（2）apply函数族

（3）泛型函数map

一. for循环、while循环

首先作两点说明：

（1）关于“for循环运行速度慢”的说法，实际上已经过时了，现在的R、Matlab等软件经过多年的内部优化已经不慢了，之所以表现出来慢，是因为你没有注意两个关键点：

提前为保存循环结果分配存储空间；
为循环体中涉及到的数据选择合适的数据结构。

（2）apply函数族和泛型函数map能够更加高效简洁地实现一般的for循环、while循环，但这不代表for循环、while循环就没用了，它们可以在更高的层次使用（相对于在逐元素级别使用）

1. 基本for循环

例如，有如下的tibble数据：

library(tidyverse)
df <- tibble(
  a = rnorm(10),
  b = rnorm(10),
  c = rnorm(10),
  d = rnorm(10)
)

用复制-粘贴法，计算每一列的中位数：

median(df$a)
median(df$b)
median(df$c)
median(df$d)

为了避免“粘贴-复制多于两次”，改用for循环实现：

output <- vector("double", ncol(df))     #1.输出
for (i in seq_along(df)) {               #2.迭代器
  output[[i]] <- median(df[[i]])         #3.循环体
output  #输出结果略

for循环有三个组件：

(1) 输出：output <- vector("double", length(x))

在循环开始之前，最好为输出分配足够的存储空间，这样效率更高：若每循环一次，就用c()合并一次，效率会很低下。

通常是用vector()函数创建一个给定长度的空向量，它有两个参数：向量类型（logical, integer, double, character等）、向量长度。

(2)迭代器：i in seq_along(df)

确定怎么循环：每次for循环将对i赋一个seq_along(df)中的值，可将i理解为代词it. 其中seq_along()是“1:length(df)”的安全版本，它能保证遇到长度为0的向量时，仍能正确工作：

y <- vector("double", 0)
seq_along(y)

1:length(y)

你可能不会故意创建长度为0的向量，但容易不小心创建，则会导致报错。

(3) 循环体：output[[i]] <- median(df[[i]])

即执行具体操作的代码，它将重复执行，每次对不同的i值。

第1次迭代将执行：output[[1]] <- median(df[[1]])，

第2次迭代将执行：output[[2]] <- median(df[[2]])，

……

2. for循环变种

基本的for循环有4个变种：

(1) 修改已存在的对象，创建的新对象

有时需要用for循环修改一个已存在的对象，例如，对数据框 df 的每一列做归一化：

rescale01 <- function(x) {
  rng <- range(x, na.rm = TRUE)
  (x - rng[1]) / (rng[2] - rng[1])
df$a <- rescale01(df$a)
df$b <- rescale01(df$b)
df$c <- rescale01(df$c)
df$d <- rescale01(df$d)

用for循环来做，先考虑其3个组件：

输出：已经存在，与输入相同。

迭代器 ：可以将数据框看作是多个列构成的列表，故可以用seq_along(df)来迭代每一列。

循环体 ：应用函数rescale01().

于是写出如下的for循环：

for (i in seq_along(df)) {
    df[[i]] <- rescale01(df[[i]])
}

通常来说，你可以用这种循环来修改一个列表或数据框，注意这里是用[[ ]], 而不是[ ]. 因为原子向量最好用[[ ]], 这样能清楚地表明你处理的是一个单独的元（而不是子集）。

(2) 循环模式

· 根据数值索引：for(i in seq_along(xs), 用x[[i]] 提取值。

· 根据元素值：for(x in xs). 若你只关心附带作用，这特别有用。例如绘图、保存文件等，因为很难高效率地保存这种结果。

· 根据名字：for(nm in names(xs)). 对每个名字，访问其对应的值 x[[nm]], 若你需要使用图形标题或文件的名称，这就很有用。当创建命名的输出时，确保按如下方式命名结果向量：

results <- vector("list", length(x))
names(results) <- names(x)

注：用数值索引迭代是最常用的形式，因为只要给定位置，名字和元素值都可以提取：

for (i in seq_along(x)) {
    name <- names(x)[[i]]
    value <- x[[i]]
}

(3) 结果长度未知

有时候，你可能不知道输出结果有多长。例如，你想要模拟一些长度随机的随机向量。你可能优先想到通过逐步增加长度的方法解决该问题：

means <- c(0, 1, 2)
output <- double()
for (i in seq_along(means)) {
  n <- sample(100, 1)
  output <- c(output, rnorm(n, means[[i]]))
str(output)

但这种做法很低效，因为每次迭代，R都要复制上一次迭代的全部数据，其复杂度为 O(n^2) .

一个好的方法是，先将结果保存为列表，等循环结束再将列表重组为一个单独的向量：

out <- vector("list", length(means))
for (i in seq_along(means)) {
  n <- sample(100, 1)
  out[[i]] <- rnorm(n, means[[i]])
str(out)

str(unlist(out))

这里是用unlist()函数将一个向量的列表摊平为一个单独的向量。更严格的方法是用purrr包中的flatten_dbl(), 若输入不是double型的列表，将会报错。

还有两种结果长度未知的情形：

· 生成一个长字符串。不是用paste()函数将上一次的迭代结果拼接到一起，而是将结果保存为字符向量，再用函数paste(output, collapse= " ")合并为一个单独的字符串；

· 生成一个大的数据框。不是依次用rbind()函数合并每次迭代的结果，而是将结果保存为列表，再用dplyr包中的bind_rows(output)函数合并成一个单独的数据框。

所以，遇到上述模式时，要先转化为更复杂的结果对象，最后再做一步合并。

(4) 迭代次数未知（while循环）

有时候你甚至不知道输入序列有多长，这通常出现在做模拟的时候。例如，你可能想要在一行中循环直到连续出现3个“Head”，此时不适合用for循环，而是适合用while循环。

while循环更简单些，因为它只包含两个组件：条件、循环体：

while (condition) {
  #body
}

While循环是比for循环更一般的循环，因为for循环总可以改写为while循环，但while循环不一定能改写为for循环：

for (i in seq_along(x)) {
  #循环体
#等价于
i <- 1
while (i <= length(x)) {
  #循环体
  i <- i + 1
}

下面用while循环实现：抛一枚硬币直到连续出现3次“正面”，需要的次数：

flip <- function() sample(c("Tail", "Head"), 1)
flips <- 0
nheads <- 0
while (nheads < 3) {
  if (flip() == "Head") {
    nheads <- nheads + 1
  } else {
    nheads <- 0
  flips <- flips + 1
flips

while循环并不常用，但在模拟时常用，特别是在预先不知道迭代次数的情形。

二. apply函数族

apply函数族可以代替大部分的for循环、while循环，其大意是“应用（apply）”某函数（fun）到一系列的对象上。根据应用到的对象的不同，是一族apply函数。

常用的有：

分组计算：apply()和tapply()
循环迭代：lapply()和sapply()
多变量计算：mapply()

函数apply()

apply()函数是最常用的代替for循环的函数。apply函数可以对矩阵、数据框、数组(二维、多维)，按行或列进行循环计算，对子元素进行迭代，并把子元素以参数传递的形式给自定义的FUN函数中，并以返回计算结果。基本格式为：

apply(x, MARGIN=..., fun, ...)

其中，x为数据对象（矩阵、多维数组、数据框）；

MARGIN=1表示按行，2表示按列；

fun表示要作用的函数。

x<-matrix(1:6, ncol=3)
x

apply(x,1,mean) #按行求均值

apply(x,2,mean) #按列求均值

2. 函数tapply()

按一组因子INDEX对数据列 x 分组，再分别对每组作用上函数fun。基本格式为：

tapply(x, INDEX, fun, ..., simplify=TRUE)

其中，x通常为向量；

INDEX为与x长度相同的因子列表（若不是因子，R会强制转化为因子）；

simplify=TRUE且fun计算结果为标量值，则返回值为数组，若为FALSE，则返回值为list对象

dat <- data.frame(height=c(174,165,180,171,160), sex=c("F","F","M","M","F"))
tapply(dat$height,dat$sex, mean)   #计算分组均值: 不同sex对应的height的均值

3. 函数lapply()

该函数是一个最基础循环操作函数，用来对vector、list、data.frame逐元、逐成分、逐列分别应用函数fun，并返回和 x 长度同样的 list 作为结果。

基本格式为：

lapply(x, fun, ...)

其中，x为数据对象（列表、数据框、向量）。

x<-list(a=1:5, b=exp(0:3))
x

lapply(x, mean)

4. 函数sapply()

sapply() 是 lapply() 的简化版本，多了一个参数simplify，若simplify=FALSE，则同lapply()，若为TRUE，则将输出的list简化为向量或矩阵。基本格式为：

sapply(x, fun, ..., simplify=TRUE, USE.NAMES=...)

5. 函数mapply()

是函数sapply()的多变量版本，将对多个变量的每个参数作用某函数。基本格式为：

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

其中，

MoreArgs为fun函数的其它参数列表；

SIMPLIFY为逻辑值或字符串，取值为TRUR时，将结果转化为一个向量、矩阵或高维阵列（但不是所有结果都可转化）；

... 可以接收多个数据，mapply将fun应用于这些数据的第一个元素组成的数组，然后是第二个元素组成的数组，以此类推。

返回值是vector或matrix，取决于fun返回值是一个还是多个。

#重复生成列表list(x=1:2), 重复次数times=1:3,结果为列表
mapply(rep, times=1:3, MoreArgs = list(x=1:2))

mapply(function(x,y) x^y, c(1:3), c(1:3))

mapply(function(x,y) c(x+y, x^y), c(1:3), c(1:3))

Alco <- data.frame(AlcoholDrunk=c("YES","YES","NO","YES","YES","YES",NA,"YES","YES","YES","YES","YES","YES","NO","NO","NO","NO","YES"), 
AmountDrunk=c(3.0, 1.0, NA ,3.0,  NA, 0.0,  NA, 0.0, NA, 1.7,  NA,  NA, 0.0,  NA,  NA,  NA,  NA, 2.0))

其中，变量AlcoholDrunk有三种取值，“YES”表示有饮酒史；“NO”表示无饮酒史；NA表示数据不可获取。

定义alcohol()函数实现功能：若AlcoholDrunk是NA，直接返回NA；若是NO，返回NO；否则返回变量AmountDrunk的值。因为需要传递两个变量的值，就需要用mapply()函数：

alcohol <- function(texVal, numVal){
  if(is.na(texVal)) {return("NA")}
      else if(texVal=="NO") {return("NO")}
  else if(is.na(numVal)) {return("amount Unknown")}
  else {return(numVal)}
mapply(alcohol, Alco$AlcoholDrunk, Alco$AmountDrunk)