R 中循环的教程——用法与替代方案

for 循环详解

这种循环结构由“init”（初始化）的矩形框、菱形的决策节点以及矩形框 i1 组成，会被执行已知次数。

在流程图语境中，矩形框表示“执行不涉及决策的某些操作”。而菱形（或称菱形决策符号）则是“决策符号”，因此对应只能有两个逻辑答案的问题，即 True (T) 或 False (F)。

注意，为简化起见，图中略去了其他可能的符号。

初始化矩形中的一条或多条指令之后，会对某个变量上的条件进行求值，该变量可以在某个给定序列内取值。图中菱形表示的就是：“变量 v 的当前值是否属于序列 seq？”。

换言之，您在测试 v 的当前值是否在指定范围内。通常您会在初始化中定义这个范围，例如用 1:100 来确保循环开始。

如果条件不满足，结果为 False，则循环永不执行。这由 for 循环结构右侧的游离箭头表示。随后程序将执行循环块之后遇到的第一条指令。

若条件满足，则会执行一条（或一组）指令 i1。该指令块也可能是另一个循环。在这种情况下，就称为嵌套循环。

完成后，会再次对条件求值。这由从 i1 返回到顶部、紧接初始化框之后的连线表示。在 R（以及 Python）中，可以用直白的自然语言来表达：询问我们的变量是否属于某个取值范围。

注意，在其他语言中，例如 C，条件通常会显式使用逻辑运算符来表示，如大于、小于、等于等……

下面是一个简单的 for 循环示例：

# Create a vector filled with random normal values
u1 <- rnorm(30)
print("This loop calculates the square of the first 10 elements of vector u1")

# Initialize `usq`
usq <- 0. 

for (i in 1:10) {
    # i-th element of `u1` squared into `i`-th position of `usq`
    usq[i] <- u1[i] * u1[i]
    print(usq[i])
}

print(i)技术支持

for 代码块包含在花括号中。花括号可以紧跟在测试条件之后，也可以另起一行，后面最好配合缩进。二者都非强制，但花括号确实能增强代码可读性，并便于定位循环块及其中可能的错误。

注意，平方向量 usq 在此处被初始化。在纯 RStudio 代码中这并非必要，但在标记化版本中，knitr 会因为在循环中使用前未找到该向量的引用而无法编译，从而在 RStudio 内抛出错误。关于 knitr 的更多信息，请访问R Markdown 页面。

嵌套 for 循环

既然您已经知道 for 循环也可以嵌套，那么您可能会想，为什么以及何时需要在代码中这样做。

假设您希望通过将元素设置为特定值来操作一个二维数组。

那么您可能会写出如下代码：

# Insert your own integer here
my_int <- 42

nr <- as.integer(my_int)

# Create a `n` x `n` matrix with zeros
mymat <- matrix(0, nr, nr)

# For each row and for each column, assign values based on position
# These values are the product of two indexes
for (i in 1:dim(mymat)[1]) {
    for (j in 1:dim(mymat)[2]) {
        mymat[i, j] = i * j
    }
}技术支持

提示：关于 matrix() 函数的更多信息，请访问R Documentation。

上面的代码中有两个嵌套的 for 循环，因此有两组花括号，每组都有自己的代码块并由各自的索引控制。也就是说，i 遍历行，j 遍历列。

 

生成了什么？

# Show the first 10x10 chunk or the first `nr` x `nr` chunk
if (nr > 10) {
    mymat[1:10, 1:10]
} else
    mymat[1:nr, 1:nr]技术支持

注意，为避免用户在屏幕上打印巨大表格，您在末尾添加了一个条件：仅当用户输入的整数大于 10 时，才打印前 10 x 10 的区域。否则，将打印 n x n 的区域。

完整代码如下：

# Insert your own integer here
my_int <- 42

nr <- as.integer(my_int)

# Create a `n` x `n` matrix with zeroes
mymat <- matrix(0, nr, nr)
技术支持

# For each row and for each column, assign values based on position
# These values are the product of two indexes
for (i in 1:dim(mymat)[1]) {
    for (j in 1:dim(mymat)[2]) {
        mymat[i, j] = i * j
    }
}

# Show the first 10x10 chunk or the first `nr` x `nr` chunk
if (nr > 10) {
    mymat[1:10, 1:10]
} else
    mymat[1:nr, 1:nr]技术支持

for 循环：流行但并非总是完美之选

for 循环无疑最为流行，其结构意味着迭代次数是固定且事先已知的，例如“生成前 200 个素数”或“列出最重要的 10 位客户”。

但如果您并不知道或无法控制迭代次数，且一个或多个无法预见的条件可能会发生，该怎么办？

例如，您可能想统计居住在某个邮政编码区域内的客户数量，或最近两天网页横幅上的点击次数，或其他类似不可预先预测的事件。

在这类情况下，while 循环及其“亲戚” repeat 可能会派上用场……

用 break 中断循环

当 R 解释器遇到 break 时，它会将控制权交给循环结束之后的那条指令（若存在）。在嵌套循环的情况下，break 只会退出最内层的循环。

下面是一个示例。

这段代码定义了一个 m x n 的零矩阵，然后进入嵌套的 for 循环来填充矩阵位置，但仅在两个索引不相等时进行。其目的是创建一个下三角矩阵，即主对角线以下的元素为非零，上面的元素保持为初始化的 0。

当索引相等时，内层循环（遍历列索引 j）的条件满足，执行 break，最内层循环被中断，直接跳到内层循环之后的指令。这条指令是一个 print()。然后，控制流回到外层 for 条件（行索引 i），再进行求值。

如果索引不同，则进行赋值，并将计数器加 1。最后，程序打印计数器 ctr，其中包含被赋值的元素数量。

# Make a lower triangular matrix (zeroes in upper right corner)
m = 10
n = 10

# A counter to count the assignment
ctr = 0

# Create a 10 x 10 matrix with zeroes
mymat = matrix(0, m, n)

for (i in 1:m) {
    for (j in 1:n) {
        if (i == j) {
            break
        } else {
            # you assign the values only when i<>j
            mymat[i, j] = i * j
            ctr = ctr + 1
        }
    }
    print(i * j)
}

# Print how many matrix cells were assigned
print(ctr)技术支持

注意，即便在并非绝对必要时加上花括号也许略显谨慎，但通常这样做能确保凡是用 { 打开的，就会用 } 关闭。如果您发现 { 或 } 的数量不匹配，就知道有错误，尽管反之未必成立！

在循环中使用 next

next 会终止某次具体的迭代并跳到下一轮。实际上，它会跳转到当前循环条件的求值处。

在其他语言中，您可能会看到等价但略显混淆的叫法“continue”，含义相同：无论您身在何处，一旦条件触发，就跳到循环条件的求值。

一个更简单的示例是在条件发生时继续循环但丢弃某次迭代：

m = 20

for (k in 1:m) {
    if (!k %% 2)
        next
    print(k)
}技术支持

这段代码会打印区间 1:m（此处 m=20）内的所有奇数。换句话说，所有除以 2 余数非零的整数（因此使用取模运算符 %%）将被打印，如 if 测试所示。

余数为零的数字将不会被打印，因为程序跳至 i in 1:m 条件的求值，并忽略后续任何指令。在此例中，print(k) 被忽略。

v1 <- c(3,4,5)
v2 <- c(3,4,6)
v3 <- c(0,0,0)
n = length(v1)

for (i in 1:n) {
    v3[i] <- v1[i] + v2[i]
}
v3技术支持

v3 = v1 + v2
v3技术支持

A <- matrix(1:6, nrow = 3, ncol = 2)
B <- matrix(c(2,4,3,1,5,7), nrow=3, ncol=2)

C= A + B
C技术支持

R 中的向量化详解

既然看起来基本运算次数相同，为什么向量化运行更快？

最佳解释需要深入 R 的内部机制，这值得单开一文。简而言之：首先，R 是解释型语言，因此所有关于变量定义的细节都由解释器处理。例如，您无需指定数字是浮点型，或使用指针在内存中分配空间。

R 解释器会在您输入命令时从上下文“理解”这些问题，但它是逐条命令处理的。因此，即便重复同一命令，每次也都要处理这些定义。

相反，编译器会在编译阶段对整个代码的定义与声明“逐一清算”；代码会在您执行之前被翻译为紧凑、优化的二进制。因此，当 R 函数以这些底层语言编写时，它们更高效。

实际上，如果查看底层代码，您会发现对 C 或 C++ 的调用，通常封装在所谓的“包装器”代码中实现。

其次，在支持向量化的语言（如 R 或 Matlab）中，每条使用数值数据的指令，都是对一个天生定义为向量的对象进行操作，即便它只有一个元素。例如，当您定义一个单独的数值变量时，它在 R 内部的表示始终是一个向量，尽管仅包含一个数。

循环仍然存在于底层，但位于更底层且更快的 C/C++ 编译级别。拥有向量的优势在于：解释器只需对整个向量进行一次定义解析，而不管其大小；而对标量进行循环时，定义与分配需要逐元素进行，这就更慢。

最后，采用原生向量格式，能够利用非常高效的线性代数例程（如 BLAS，Basic Linear Algebra Subprograms）。因此在执行向量化指令时，R 可以借力这些高效的数值例程。由此可得出的建议是：若可能，尽量在单次函数调用中处理完整的数据结构，以避免各种复制操作。

闲话少说，先看一个向量化的通用示例，下一小节将深入更具体、常用的 R 向量化函数，以替代循环。

R 中向量化的一个示例

回到“增长数据”的概念，这是“更新”数据框的一种典型低效方式。

首先，使用 replicate(m, rnorm(n)) 创建一个 m x n 的矩阵，其中 m=10 个列向量、每个有 n=10 个元素，由 rnorm(n) 构造（生成正态随机数）。

然后将其转换为数据框（因此是 10 个观测、10 个变量），并使用嵌套的 for 循环对每个元素执行代数运算：在每次迭代中，用一个正弦函数为由两个索引指向的每个元素递增。

以下示例略显“人为”，但它可以代表在随机噪声上叠加一个信号：

# This is a bad loop with 'growing' data
set.seed(42)
m = 10
n = 10

# Create matrix of normal random numbers
mymat <- replicate(m, rnorm(n))

# Transform into data frame
mydframe <- data.frame(mymat)

for (i in 1:m) {
  for (j in 1:n) {
    mydframe[i, j] <- mydframe[i, j] + 10 * sin(0.75 * pi)
    print(mydframe)
  }
}技术支持

在这里，大部分执行时间都消耗在复制与管理循环上。

来看一下向量化解法：

set.seed(42)
m = 10
n = 10
mymat <- replicate(m, rnorm(n))
mydframe <- data.frame(mymat)
mydframe <- mydframe + 10 * sin(0.75 * pi)
mydframe技术支持

这看起来更简单：最后一行取代了嵌套的 for 循环。注意 使用 set.seed() 以确保两种实现给出完全相同的结果。

现在让我们量化两种方案的执行时间。

您可以使用 R 的系统命令（如 system.time()）对一段代码进行计时，如下所示：

提示：只需将要评估的代码放在 system.time() 函数的括号中。

# Insert `system.time()` to measure loop execution
for (i in 1:m) {
  for (j in 1:n) {
    mydframe[i, j] <- mydframe[i, j] + 10 * sin(0.75 * pi)
  }
}

# Add `system.time()` to measure vectorized execution
mydframe <- mydframe + 10 * sin(0.75 * pi) 技术支持

在上述代码中，您仅在开始时完成选择 m 与 n、创建矩阵及其转换为数据框的工作，然后分别用两次 system.time() 调用，来比较 for 代码块与向量化“一行解”的耗时。

您会发现，即便在 m=n=10 的最小设置下，向量化版本也快约 7 倍，尽管对这种低规模场景而言，对用户的意义不大。

当设置为 m=n=100 时，差异在人感知层面变得明显；而增至 1000 时，for 循环会让人感觉卡顿数十秒，而向量化形式仍可在眨眼间完成。

在 m=n=10000 时，for 循环会卡顿一分钟以上，而向量化方案仅需 2.54 秒。当然，这些测量应谨慎对待，并会受硬件与软件配置影响；尽量避免在浏览器开几十个标签页、后台运行多个程序的情况下进行测试。不过，这些数字足以说明差异。

公允地说，增大 m 与 n 也会显著影响矩阵的生成，您可以通过在复制函数外再套一层 system.time() 来轻松观察到这一点。

欢迎您通过改变 m 与 n 来观察执行时间的变化，并将执行时间绘制为 m x n 乘积的函数。这是相关指标，因为它表示所创建矩阵的尺寸，也量化了通过 nset-ed for 循环完成任务所需的迭代次数。

以上是一个向量化的示例。当然还有许多其他示例。在 R 项目通讯（R News）第 46 页中，介绍了一些对数组或矩阵特定维度计算求和与均值的高效函数，如：rowSums()、colSums()、rowMeans() 和 colMeans()。

此外，该通讯还提到：“……‘apply’ 家族的函数，命名为 [s,l,m,t]apply，用于将另一个函数应用到对象的元素/维度上。这些 ‘apply’ 函数为有时相当复杂的任务提供了简洁语法，比写得不好的循环更易读也更快。”