R 简介 ¶

1.1 R 环境 ¶

R 是一套用于数据处理、计算和图形显示的集成软件工具。除其他功能外，它还具有

• 有效的数据处理和存储工具，
• 一组用于对数组（尤其是矩阵）进行计算的运算符，
• 大量连贯的集成数据分析中间工具，
• 用于数据分析和显示的图形工具，可直接在计算机上或以硬拷贝形式显示，以及
• 一种经过完善的、简单有效的编程语言（称为“S”），其中包括条件、循环、用户定义的递归函数以及输入和输出工具。（实际上，系统提供的大多数函数都是用 S 语言编写的。）

术语“环境”旨在将其描述为一个经过全面规划和连贯的系统，而不是像其他数据分析软件那样，是逐渐积累的非常具体且不灵活的工具。

R 在很大程度上是用于开发交互式数据分析新方法的工具。它发展迅速，并已通过大量程序包进行了扩展。但是，大多数用 R 编写的程序本质上都是短暂的，是为单一数据分析编写的。

1.2 相关软件和文档 ¶

R 可以看作是 S 语言的一种实现，该语言由贝尔实验室的 Rick Becker、John Chambers 和 Allan Wilks 开发，也是S-PLUS 系统的基础。

S 语言的演变由 John Chambers 和合作者撰写的四本书来表征。对于 R，基本参考书是 Richard A. Becker、John M. Chambers 和 Allan R. Wilks 撰写的新 S 语言：数据分析和图形的编程环境。S 1991 年版本的新功能由 John M. Chambers 和 Trevor J. Hastie 编辑的S 中的统计模型中进行了介绍。方法包的正式方法和类基于 John M. Chambers 在数据编程中描述的内容。有关确切参考信息，请参见参考信息。

现在有很多书描述如何使用 R 进行数据分析和统计，并且 S/S-PLUS 的文档通常可以与 R 一起使用，同时牢记 S 实现之间的差异。请参见R 统计系统常见问题解答中的R 有哪些文档？。

1.3 R 和统计 ¶

我们对 R 环境的介绍并未提及统计，但许多人将 R 用作统计系统。我们更愿意将它视为一个环境，其中已实现许多经典和现代统计技术。其中一些内置于 R 基本环境中，但许多以包的形式提供。R 附带约 25 个包（称为“标准”和“推荐”包），还有更多包可通过CRAN系列互联网网站（通过https://CRAN.R-project.org）和其他地方获得。稍后将提供有关包的更多详细信息（请参见包）。

大多数经典统计和许多最新方法都可以与 R 一起使用，但用户可能需要做好一些准备工作来查找它们。

S（因此还有 R）与其他主要统计系统在理念上存在着重要的差异。在 S 中，统计分析通常作为一系列步骤来完成，中间结果存储在对象中。因此，虽然 SAS 和 SPSS 会从回归或判别分析中给出大量输出，但 R 会给出最少量的输出，并将结果存储在拟合对象中，以便通过其他 R 函数进行后续查询。

1.4 R 和窗口系统 ¶

使用 R 最方便的方式是在运行窗口系统的图形工作站上。本指南针对拥有此类设施的用户。特别是，我们偶尔会提到在 X 窗口系统上使用 R，尽管所述内容的大部分通常适用于 R 环境的任何实现。

大多数用户会发现，有时有必要直接与计算机上的操作系统进行交互。在本指南中，我们主要讨论与 UNIX 机器上的操作系统的交互。如果你在 Windows 或 macOS 下运行 R，则需要进行一些小的调整。

设置工作站以充分利用 R 的可自定义特性是一个直接但有些繁琐的过程，此处将不再进一步考虑。遇到困难的用户应寻求当地专家的帮助。

1.5 交互使用 R ¶

当你使用 R 程序时，它会在需要输入命令时发出提示。默认提示为“>”，在 UNIX 中它可能与 shell 提示相同，因此可能看起来什么都没有发生。但是，正如我们所看到的，如果你愿意，可以轻松更改为不同的 R 提示。我们将假设 UNIX shell 提示为“$”。

在 UNIX 下使用 R 时，建议首次执行以下过程

1. 创建一个单独的子目录，例如 work，用于保存你将在此问题上使用 R 的数据文件。每当你针对此特定问题使用 R 时，这都将是工作目录。

   $ mkdir work
   $ cd work
   

2. 使用以下命令启动 R 程序

   $ R
   

3. 此时可以发出 R 命令（稍后参见）。
4. 退出 R 程序的命令是

   > q()
   

   此时系统会询问您是否要保存 R 会话中的数据。在某些系统上，这会弹出一个对话框，而在其他系统上，您将收到一个文本提示，您可以回复 yes、no 或 cancel（使用单个字母缩写即可）来在退出前保存数据、不保存而退出或返回 R 会话。保存的数据将在将来的 R 会话中可用。

后续 R 会话很简单。

1. 将 work 设置为工作目录，然后像以前一样启动程序

   $ cd work
   $ R
   

2. 使用 R 程序，在会话结束时以 q() 命令终止。

要在 Windows 下使用 R，遵循的过程基本上是相同的。创建一个文件夹作为工作目录，并在 R 快捷方式的 开始于 字段中设置该文件夹。然后双击该图标启动 R。

1.6 入门会话 ¶

强烈建议希望在继续之前在计算机上体验 R 的读者完成 示例会话 中给出的入门会话。

1.7 获取函数和功能的帮助 ¶

R 具有类似于 UNIX 的 man 功能的内置帮助功能。要获取有关任何特定命名函数（例如 solve）的更多信息，命令是

> help(solve)

另一种方法是

> ?solve

对于由特殊字符指定的特性，参数必须用双引号或单引号括起来，使其成为“字符字符串”：对于一些具有语法含义的单词，包括 if、for 和 function，这也是必需的。

> help("[[")

两种形式的引号都可以用来转义对方，就像字符串 "It's important" 中一样。我们的惯例是优先使用双引号。

在大多数 R 安装中，可以通过运行以下命令以 HTML 格式获得帮助

> help.start()

这将启动一个 Web 浏览器，允许使用超链接浏览帮助页面。在 UNIX 上，后续帮助请求将发送到基于 HTML 的帮助系统。由 help.start() 加载的页面中的“搜索引擎和关键字”链接特别有用，因为它包含一个高级概念列表，用于搜索可用函数。这可能是一种快速了解情况并理解 R 提供的广度的绝佳方式。

help.search 命令（或 ??）允许以多种方式搜索帮助。例如，

> ??solve

尝试 ?help.search 以获取详细信息和更多示例。

通常可以通过以下方式运行帮助主题中的示例

> example(topic)

R 的 Windows 版本有其他可选的帮助系统：使用

> ?help

了解更多详细信息。

1.8 R 命令、大小写敏感性等。 ¶

从技术角度来看，R 是一种表达式语言，语法非常简单。它区分大小写，就像大多数基于 UNIX 的软件包一样，因此A和a是不同的符号，它们表示不同的变量。可以在 R 名称中使用的符号集取决于 R 运行所在的操作系统和国家/地区（从技术角度上讲，取决于所使用的区域设置）。通常允许使用所有字母数字符号²（在某些国家/地区，还包括带重音符号的字母）以及“.”和“_”，但有一个限制，即名称必须以“.”或字母开头，如果以“.”开头，则第二个字符不能是数字。名称的长度实际上不受限制。

基本命令由表达式或赋值组成。如果表达式作为命令给出，则会对其求值、打印（除非专门将其设为不可见），并且会丢失该值。赋值也会对表达式求值，并将该值传递给变量，但不会自动打印结果。

命令由分号（“;”）或换行符分隔。可以通过大括号（“{”和“}”）将基本命令组合成一个复合表达式。注释几乎可以放在³任何地方，以井号（“#”）开头，该行末尾的所有内容都是注释。

如果一行末尾的命令不完整，R 会给出不同的提示，默认情况下

+

在第二行及后续行，并继续读取输入，直到命令在语法上完整为止。用户可以更改此提示。我们通常会省略续行提示，并通过简单的缩进来表示续行。

在控制台中输入的命令行限制⁴为大约 4095 个字节（不是字符）。

1.9 召回和更正之前的命令 ¶

在许多版本的 UNIX 和 Windows 上，R 提供了一种机制，用于召回和重新执行之前的命令。可以使用键盘上的垂直箭头键向前和向后滚动命令历史记录。通过这种方式找到命令后，可以使用水平箭头键在命令中移动光标，并可以使用DEL键删除字符，或使用其他键添加字符。稍后会提供更多详细信息：请参阅命令行编辑器。

UNIX 下的召回和编辑功能具有高度可定制性。你可以通过阅读 readline 库的手册条目来了解如何执行此操作。

或者，Emacs 文本编辑器通过 ESS（Emacs Speaks Statistics）提供了更通用的支持机制，以便与 R 交互式地工作。请参阅 R 统计系统常见问题解答 中的 R 和 Emacs。

1.10 从文件执行命令或将输出转至文件 ¶

如果命令⁵存储在外部文件中，比如工作目录 work 中的 commands.R，则可以使用以下命令在 R 会话中随时执行这些命令

> source("commands.R")

对于 Windows，Source 也可在 File 菜单中找到。函数 sink,

> sink("record.lis")

会将控制台的所有后续输出转至外部文件 record.lis。命令

> sink()

会将其再次还原到控制台。

1.11 数据持久性和删除对象 ¶

R 创建和处理的实体称为对象。这些对象可以是变量、数字数组、字符字符串、函数或由这些组件构建的更通用的结构。

在 R 会话期间，对象将按名称创建并存储（我们将在下一部分讨论此过程）。R 命令

> objects()

(或者 ls()) 可用于显示当前存储在 R 中的（大多数）对象的名称。当前存储的对象集合称为工作空间。

要移除对象，可以使用函数 rm

> rm(x, y, z, ink, junk, temp, foo, bar)

在 R 会话期间创建的所有对象都可以永久存储在文件中，以便在将来的 R 会话中使用。在每个 R 会话结束时，您都有机会保存当前所有可用的对象。如果您表示要执行此操作，则对象将写入名为 .RData⁶ 的文件（位于当前目录中），并且会话中使用的命令行将保存到名为 .Rhistory 的文件中。

当稍后从同一目录启动 R 时，它会从该文件重新加载工作空间。同时，将重新加载关联的命令历史记录。

建议您为使用 R 进行的分析使用单独的工作目录。在分析期间，通常会创建名称为 x 和 y 的对象。此类名称在单个分析的上下文中通常有意义，但在同一目录中进行多次分析时，很难确定它们可能是什么。

2.1 向量和赋值 ¶

R 对命名的数据结构进行操作。最简单的此类结构是数字向量，它是一个由有序数字集合组成的单一实体。要设置一个名为 x 的向量（比如包含五个数字 10.4、5.6、3.1、6.4 和 21.7），请使用 R 命令

> x <- c(10.4, 5.6, 3.1, 6.4, 21.7)

这是一个赋值语句，使用函数 c()，在此上下文中，它可以采用任意数量的向量参数，其值是通过将参数首尾相连而获得的向量。⁷

表达式中单独出现的数字被视为长度为一的向量。

请注意赋值运算符（‘<-’），它由两个字符‘<’（“小于”）和‘-’（“减号”）严格并排组成，它“指向”接收表达式值的 对象。在大多数情况下，‘=’运算符可用作替代项。

还可以使用函数 assign() 进行赋值。与上述相同的赋值的等效方式如下

> assign("x", c(10.4, 5.6, 3.1, 6.4, 21.7))

通常的运算符 <- 可以被认为是此语法的一个快捷方式。

还可以使用赋值运算符的明显更改向其他方向进行赋值。因此，可以使用以下方式进行相同的赋值

> c(10.4, 5.6, 3.1, 6.4, 21.7) -> x

如果表达式用作完整命令，则该值将被打印并丢失⁸。因此，如果现在我们使用命令

> 1/x

五个值的倒数将打印在终端（当然，x 的值保持不变）。

进一步的赋值

> y <- c(x, 0, x)

将创建一个向量 y，其中包含 11 个条目，由两个 x 副本和中间位置的零组成。

2.2 向量算术 ¶

向量可用于算术表达式中，在这种情况下，逐个元素执行操作。出现在同一表达式中的向量不必全部具有相同的长度。如果它们不同，则表达式的值为与表达式中出现的最长向量具有相同长度的向量。表达式中较短的向量会根据需要（可能按分数）被循环利用，直到它们与最长向量的长度匹配。特别是常量只是被简单地重复。因此，对于以上赋值，命令

> v <- 2*x + y + 1

通过逐个元素相加生成一个新的长度为 11 的向量 v，其中包括重复 2.2 次的 2*x、重复一次的 y 和重复 11 次的 1。

基本算术运算符是通常的 +、-、*、/ 和 ^（用于求幂）。 此外，所有常见的算术函数都可用。log、exp、sin、cos、tan、sqrt 等都具有其通常的含义。 max 和 min 分别选择向量的最大元素和最小元素。 range 是一个函数，其值是一个长度为 2 的向量，即 c(min(x), max(x))。 length(x) 是 x 中的元素数， sum(x) 给出 x 中元素的总和， prod(x) 给出它们的乘积。

两个统计函数是 mean(x)，它计算样本均值，与 sum(x)/length(x) 相同， 和 var(x)，它给出

sum((x-mean(x))^2)/(length(x)-1)

或样本方差。如果 var() 的参数是一个 n 乘以 p 的矩阵，则该值是一个 p 乘以 p 的样本协方差矩阵，通过将行视为独立的 p 元样本向量得到。

sort(x) 返回一个与 x 大小相同的向量，其中元素按递增顺序排列；但是，还有其他更灵活的排序工具可用（请参见 order() 或 sort.list()，它们生成一个用于排序的排列）。

请注意，max 和 min 选择其参数中的最大值和最小值，即使给出了多个向量。并行最大值和最小值函数 pmax 和 pmin 返回一个向量（长度等于其最长的参数），其中每个元素包含任何输入向量中该位置的最大（最小）元素。

对于大多数目的，用户不必关心数字向量中的“数字”是整数、实数还是复数。在内部，计算以双精度实数或（如果输入数据为复数）双精度复数进行。

要处理复数，请提供一个明确的复数部分。因此

sqrt(-17)

将给出 NaN 和一个警告，但

sqrt(-17+0i)

将以复数形式进行计算。

2.3 生成规则序列 ¶

R 有许多用于生成常用数字序列的工具。例如 1:30 是向量 c(1, 2, …, 29, 30)。 冒号运算符在表达式中具有较高的优先级，因此，例如 2*1:15 是向量 c(2, 4, …, 28, 30)。将 n <- 10，然后比较序列 1:n-1 和 1:(n-1)。

构造 30:1 可用于反向生成序列。

函数 seq() 是用于生成序列的更通用的工具。它有五个参数，在任何一次调用中只能指定其中一些参数。如果给出了前两个参数，则指定序列的开头和结尾，如果这两个参数是给出的唯一两个参数，则结果与冒号运算符相同。即 seq(2,10) 与向量 2:10 相同。

传递给 seq() 和许多其他 R 函数的参数也可以以命名形式给出，在这种情况下，它们出现的顺序无关紧要。前两个参数可以命名为 from=value 和 to=value；因此 seq(1,30)、seq(from=1, to=30) 和 seq(to=30, from=1) 都与 1:30 相同。传递给 seq() 的后两个参数可以命名为 by=value 和 length=value，它们分别指定序列的步长和长度。如果未给出这两个参数，则假定默认 by=1。

例如

> seq(-5, 5, by=.2) -> s3

在 s3 中生成向量 c(-5.0, -4.8, -4.6, …, 4.6, 4.8, 5.0)。类似地

> s4 <- seq(length=51, from=-5, by=.2)

在 s4 中生成相同的向量。

第五个参数可以命名为 along=vector，通常用作创建序列 1, 2, …, length(vector) 的唯一参数，如果向量为空（它可以为空），则创建空序列。

一个相关的函数是 rep() ，它可以用于以各种复杂的方式复制对象。最简单的形式是

> s5 <- rep(x, times=5)

它将在 s5 中将 x 的五个副本首尾相连地放置。另一个有用的版本是

> s6 <- rep(x, each=5)

它在继续下一个元素之前重复 x 的每个元素五次。

2.4 逻辑向量 ¶

除了数字向量，R 还允许操作逻辑量。逻辑向量的元素可以具有值 TRUE、FALSE 和 NA（表示“不可用”，见下文）。前两个通常分别缩写为 T 和 F。但请注意，T 和 F 只是默认设置为 TRUE 和 FALSE 的变量，但不是保留字，因此可以被用户覆盖。因此，您应始终使用 TRUE 和 FALSE。

逻辑向量由条件生成。例如

> temp <- x > 13

将 temp 设置为与 x 长度相同的向量，其中 FALSE 值对应于 x 中不满足条件的元素，TRUE 值对应于满足条件的元素。

逻辑运算符为 <、<=、>、>=、==（表示精确相等）和 !=（表示不相等）。 此外，如果 c1 和 c2 是逻辑表达式，则 c1 & c2 是它们的交集（“与”），c1 | c2 是它们的并集（“或”），!c1 是 c1 的否定。

逻辑向量可用于普通算术中，在这种情况下，它们会强制转换为数字向量，FALSE 变成 0，TRUE 变成 1。但是，在某些情况下，逻辑向量及其强制转换的数字对应项并不等效，例如，请参阅下一小节。

2.5 缺失值 ¶

在某些情况下，向量的分量可能不完全已知。当一个元素或值“不可用”或在统计意义上为“缺失值”时，可以通过将特殊值 NA 分配给它来为其在向量中保留一个位置。 通常，对 NA 的任何操作都会变成 NA。此规则的动机很简单，即如果操作的规范不完整，则无法知道结果，因此不可用。

函数 is.na(x) 会生成一个与 x 大小相同的逻辑向量，当且仅当 x 中的相应元素为 NA 时，该向量的值为 TRUE。

> z <- c(1:3,NA);  ind <- is.na(z)

请注意，逻辑表达式 x == NA 与 is.na(x) 有很大不同，因为 NA 实际上不是一个值，而是一个标记，表示一个不可用的量。因此，x == NA 是一个与 x 长度相同的向量，所有 值都是 NA，因为逻辑表达式本身是不完整的，因此无法确定。

请注意，还有第二种“缺失”值，是由数值计算产生的，即所谓的 非数字，NaN， 值。示例如下：

> 0/0

或

> Inf - Inf

由于结果无法合理定义，因此两者都给出 NaN。

总之，is.na(xx) 对 NA 和 NaN 值都为 TRUE both。为了区分它们，is.nan(xx) 仅对 NaN 为 TRUE。

在不带引号打印字符向量时，缺失值有时会打印为 <NA>。

2.6 字符向量 ¶

字符量和字符向量在 R 中经常使用，例如作为绘图标签。在需要的地方，它们由双引号字符分隔的一系列字符表示，例如 "x-values"、"New iteration results"。

字符字符串使用匹配的双 (") 或单 (') 引号输入，但使用双引号（或有时不带引号）打印。它们使用 C 样式转义序列，使用 \ 作为转义字符，因此 \ 输入并打印为 \\，在双引号内 " 输入为 \"。其他有用的转义序列有 \n，换行符，\t，制表符和 \b，退格符——有关完整列表，请参见 ?Quotes。

字符向量可以通过 c() 函数连接成一个向量；其用法示例将经常出现。

paste() 函数接受任意数量的参数，并将它们逐个连接成字符串。参数中给出的任何数字都会以明显的方式强制转换为字符串，也就是说，转换方式与打印它们的方式相同。默认情况下，结果中的参数由单个空格分隔，但可以通过命名参数 sep=string 更改分隔符，将其更改为 string，甚至可以为空。

例如

> labs <- paste(c("X","Y"), 1:10, sep="")

将 labs 变成字符向量

c("X1", "Y2", "X3", "Y4", "X5", "Y6", "X7", "Y8", "X9", "Y10")

特别注意，短列表的回收也在这里发生；因此 c("X", "Y") 重复 5 次以匹配序列 1:10。 ⁹

2.7 索引向量；选择和修改数据集的子集 ¶

可以通过在向量名称后附加方括号中的索引向量来选择向量的元素子集。更一般地，任何求值为向量的表达式都可以通过在表达式后立即附加方括号中的索引向量来选择其元素的子集。

此类索引向量可以是四种不同类型中的任何一种。

1. 逻辑向量。在这种情况下，索引向量将被回收至与要从中选择元素的向量长度相同。选择与索引向量中 TRUE 对应的值，而省略与 FALSE 对应的值。例如

   > y <- x[!is.na(x)]
   

   创建（或重新创建）一个对象 y，其中将按相同顺序包含 x 的非缺失值。请注意，如果 x 有缺失值，则 y 将比 x 短。此外

   > (x+1)[(!is.na(x)) & x>0] -> z
   

   创建一个对象 z，并将向量 x+1 的值放入其中，其中 x 中的对应值既非缺失值，又为正值。

2. 正整数向量的向量。在这种情况下，索引向量中的值必须位于集合 {1, 2, …, length(x)} 中。向量的相应元素将按该顺序选择并在结果中连接。索引向量的长度可以是任意长度，结果的长度与索引向量的长度相同。例如，x[6] 是 x 的第六个分量，而

   > x[1:10]
   

   选择 x 的前 10 个元素（假设 length(x) 不小于 10）。此外

   > c("x","y")[rep(c(1,2,2,1), times=4)]
   

   （这件不太可能的事情）会生成一个长度为 16 的字符向量，其中包含重复四次的 "x", "y", "y", "x"。

3. 负整数数量向量。此类索引向量指定要 排除 而不是包含的值。因此

   > y <- x[-(1:5)]
   

   给予 y 所有元素，但 x 的前五个元素除外。

4. 字符字符串向量。此可能性仅适用于对象具有 names 属性以识别其组件的情况。在这种情况下，名称向量的子向量可以与上面第 2 项中的正整数标签以相同的方式使用。

   > fruit <- c(5, 10, 1, 20)
   > names(fruit) <- c("orange", "banana", "apple", "peach")
   > lunch <- fruit[c("apple","orange")]
   

   优点是字母数字 名称 通常比 数字索引 更容易记住。此选项与数据框特别有用，我们稍后会看到。

索引表达式也可以出现在赋值的接收端，在这种情况下，赋值操作仅对向量的 那些元素 执行。表达式必须采用 vector[index_vector] 的形式，因为在此处用任意表达式代替向量名称没有多大意义。

例如

> x[is.na(x)] <- 0

用零替换 x 中的任何缺失值，并且

> y[y < 0] <- -y[y < 0]

具有与

> y <- abs(y)

2.8 其他类型的对象 ¶

向量是 R 中最重要的对象类型，但还有其他几种类型，我们将在后面的章节中正式了解它们。

• 矩阵 或更一般的 数组 是向量的多维概括。事实上，它们 是 可以用两个或更多索引进行索引并以特殊方式打印的向量。请参阅 数组和矩阵。
• 因子 提供了处理分类数据的方法。请参阅 有序和无序因子。
• 列表是向量的一种通用形式，其中各个元素不必是同种类型，并且它们本身通常是向量或列表。列表提供了一种返回统计计算结果的便捷方式。参见 列表。
• 数据框是类矩阵结构，其中各列可以是不同类型。将数据框视为每观测单位一行，但（可能）同时包含数值变量和分类变量的“数据矩阵”。许多实验最好用数据框描述：处理是分类的，但响应是数字的。参见 数据框。
• 函数本身是 R 中的对象，可以存储在项目的 workspace 中。这提供了一种简单便捷的方式来扩展 R。参见 编写你自己的函数。

3.1 内在属性：模式和长度 ¶

R 操作的实体在技术上称为对象。示例包括数值（实数）或复数值向量、逻辑值向量和字符串向量。这些被称为“原子”结构，因为它们的组件都是同种类型或模式，即数值¹⁰、复数、逻辑、字符和原始。

向量必须具有所有相同模式的值。因此，任何给定的向量都必须明确地是逻辑、数值、复数、字符或原始。（此规则唯一的明显例外是将不可用数量列为特殊“值”NA，但实际上有几种类型的NA）。请注意，向量可以为空，但仍然具有模式。例如，空字符字符串向量列为character(0)，空数值向量列为numeric(0)。

R 还会操作称为 列表 的对象，其模式为 列表。这些是有序的对象序列，每个对象可以是任何模式。列表 被称为“递归”而不是原子结构，因为它们的组件本身也可以是列表。

其他递归结构是模式为 函数 和 表达式 的结构。函数是构成 R 系统一部分的对象，还有类似的用户编写函数，我们将在后面详细讨论。作为对象的表达式构成了 R 的高级部分，本指南不会讨论，除非在讨论 R 中用于建模的 公式 时间接讨论。

通过对象的 模式，我们指的是其基本组成部分的基本类型。这是对象“属性”的一个特例。每个对象的另一个属性是其 长度。函数 mode(object) 和 length(object) 可用于找出任何已定义结构的模式和长度 ¹¹。

对象的进一步属性通常由 attributes(object) 提供，请参阅 获取和设置属性。因此，模式 和 长度 也称为对象的“内在属性”。

例如，如果 z 是长度为 100 的复数向量，那么在表达式 mode(z) 中，字符字符串为 "complex"，length(z) 为 100。

R 几乎在任何可以被认为合理的地方处理模式更改（以及一些可能不合理的地方）。例如，使用

> z <- 0:9

我们可以输入

> digits <- as.character(z)

之后，digits 是字符向量 c("0", "1", "2", …, "9")。进一步的 强制转换 或模式更改会再次重建数值向量

> d <- as.integer(digits)

现在 d 和 z 相同。¹² 有大量形式为 as.something() 的函数，用于从一种模式强制转换为另一种模式，或用于赋予对象它可能尚未拥有的其他一些属性。读者应查阅不同的帮助文件以熟悉它们。

3.2 更改对象长度 ¶

“空”对象仍可能具有模式。例如

> e <- numeric()

使 e 成为模式为数字的空向量结构。类似地，character() 是一个空字符向量，依此类推。一旦创建了任何大小的对象，只需为其提供超出其先前范围的索引值，即可向其中添加新组件。因此

> e[3] <- 17

现在将 e 设为长度为 3 的向量（其前两个分量此时均为 NA）。这适用于任何结构，前提是附加分量的模式与对象在第一位置的模式一致。

这种自动调整对象长度的方法经常使用，例如在输入的 scan() 函数中。（参见 The scan() function。）

相反，截断对象的大小只需进行赋值即可。因此，如果 alpha 是长度为 10 的对象，则

> alpha <- alpha[2 * 1:5]

将其设为长度为 5 的对象，仅包含索引为偶数的前分量。（当然，旧索引不会保留。）然后，我们可以通过以下方式仅保留前三个值

> length(alpha) <- 3

并且可以以相同的方式扩展向量（通过缺失值）。

3.3 获取和设置属性 ¶

函数 attributes(object) 返回当前为该对象定义的所有非固有属性的列表。函数 attr(object, name) 可用于选择特定属性。这些函数很少使用，除非在某些特殊情况下为某些特定目的创建新属性时，例如将创建日期或操作员与 R 对象关联起来。但是，这个概念非常重要。

分配或删除属性时应小心，因为它们是 R 中使用的对象系统的一个组成部分。

当它用在赋值的左侧时，它可以用来将新属性与 object 关联起来，或更改现有属性。例如

> attr(z, "dim") <- c(10,10)

允许 R 将 z 视为 10x10 矩阵。

3.4 对象的类 ¶

R 中的所有对象都有一个 类，由函数 class 报告。对于简单的向量，这只是模式，例如 "numeric"、"logical"、"character" 或 "list"，但 "matrix"、"array"、"factor" 和 "data.frame" 是其他可能的值。

一个称为对象的特殊属性class 用于允许面向对象样式¹³的 R 编程。例如，如果一个对象具有 class "data.frame"，它将以某种方式打印，plot() 函数将以某种方式以图形方式显示它，而其他所谓的通用函数，如 summary() 将以对其 class 敏感的方式对其作为参数做出反应。

要暂时移除 class 的影响，请使用函数 unclass()。 例如，如果 winter 具有 class "data.frame"，则

> winter

将以数据框形式打印它，这有点像矩阵，而

> unclass(winter)

将以普通列表的形式打印它。只有在非常特殊的情况下，您才需要使用此功能，但其中一种情况是当您正在学习了解 class 和通用函数的概念时。

通用函数和 class 将在 Class、通用函数和对象面向 中进一步讨论，但只是简要讨论。

4.1 一个具体示例 ¶

例如，假设我们有一个来自澳大利亚所有州和领地的 30 名税务会计师样本¹⁴，并且他们的原籍州由一个字符向量指定，如下所示，其中州助记符为

> state <- c("tas", "sa",  "qld", "nsw", "nsw", "nt",  "wa",  "wa",
             "qld", "vic", "nsw", "vic", "qld", "qld", "sa",  "tas",
             "sa",  "nt",  "wa",  "vic", "qld", "nsw", "nsw", "wa",
             "sa",  "act", "nsw", "vic", "vic", "act")

请注意，对于字符向量，“已排序”表示按字母顺序排序。

同样，使用 factor() 函数创建 因子：

> statef <- factor(state)

print() 函数处理因子的方式与处理其他对象略有不同

> statef
 [1] tas sa  qld nsw nsw nt  wa  wa  qld vic nsw vic qld qld sa
[16] tas sa  nt  wa  vic qld nsw nsw wa  sa  act nsw vic vic act
Levels:  act nsw nt qld sa tas vic wa

要找出因子的级别，可以使用 levels() 函数。

> levels(statef)
[1] "act" "nsw" "nt"  "qld" "sa"  "tas" "vic" "wa"

4.2 函数 tapply() 和参差不齐的数组 ¶

继续前面的示例，假设我们在另一个向量中拥有相同税务会计师的收入（以适当的大货币单位表示）

> incomes <- c(60, 49, 40, 61, 64, 60, 59, 54, 62, 69, 70, 42, 56,
               61, 61, 61, 58, 51, 48, 65, 49, 49, 41, 48, 52, 46,
               59, 46, 58, 43)

现在，我们可以使用特殊函数 tapply() 来计算每个州的样本平均收入

> incmeans <- tapply(incomes, statef, mean)

给出带有由级别标记的组件的均值向量

   act    nsw     nt    qld     sa    tas    vic     wa
44.500 57.333 55.500 53.600 55.000 60.500 56.000 52.250

函数 tapply() 用于将函数（此处为 mean()）应用于第一个参数的每个组件组（此处为 incomes），该组由第二个组件的级别（此处为 statef¹⁵）定义，就好像它们是单独的向量结构一样。结果是一个结构，其长度与包含结果的因子的级别属性相同。读者应查阅帮助文档以了解更多详细信息。

进一步假设我们需要计算州收入均值的标准误差。为此，我们需要编写一个 R 函数来计算任何给定向量的标准误差。由于有一个内置函数 var() 来计算样本方差，因此此类函数是一个非常简单的单行函数，由赋值指定

> stdError <- function(x) sqrt(var(x)/length(x))

（稍后将在 编写自己的函数 中考虑编写函数。请注意，R 的内置函数 sd() 是不同的。） 在此赋值之后，通过以下方式计算标准误差

> incster <- tapply(incomes, statef, stdError)

然后计算的值为

> incster
act    nsw  nt    qld     sa tas   vic     wa
1.5 4.3102 4.5 4.1061 2.7386 0.5 5.244 2.6575

作为练习，您可能需要找出州平均收入的通常 95% 置信区间。为此，您可以再次使用 tapply() 和 length() 函数来找出样本量，并使用 qt() 函数来找出适当 t 分布的百分位数。（您还可以调查 R 对 t 检验的工具。）

函数 tapply() 还可以用于处理通过多个类别对向量进行更复杂的索引。例如，我们可能希望按州和性别对税务会计师进行划分。然而，在这个简单的实例中（只有一个因子），可以将发生的事情视为如下。向量中的值被收集到与因子中的不同条目对应的组中。然后将该函数分别应用于这些组中的每一个。该值是一个函数结果向量，由因子的 levels 属性标记。

向量和标记因子的组合是一个有时称为交错数组的示例，因为子类大小可能不规则。当子类大小都相同时，索引可以隐式完成，并且效率更高，正如我们在下一节中看到的那样。

4.3 有序因子 ¶

因子的级别按字母顺序存储，或按显式指定给 factor 的顺序存储（如果它们是显式指定的）。

有时，级别将具有我们想要记录并希望我们的统计分析利用的自然顺序。 ordered() 函数创建这样的有序因子，但其他方面与 factor 相同。对于大多数目的，有序因子和无序因子之间的唯一区别在于，前者在打印时显示级别的顺序，但为它们在拟合线性模型中生成的对比是不同的。

5.1 数组 ¶

数组可以看作是多重标引的数据项集合，例如数字。R 提供了创建和处理数组的简单工具，尤其是矩阵这种特殊情况。

维度向量是非负整数向量。如果其长度为k，则数组为k维，例如矩阵是2维数组。维度从一索引到维度向量中给出的值。

只有当向量的dim属性为维度向量时，R 才能将该向量用作数组。例如，假设z是包含 1500 个元素的向量。赋值

> dim(z) <- c(3,5,100)

为其提供了dim属性，使其可以被视为3 x 5 x 100 数组。

其他函数（例如 matrix() 和 array()）可用于更简单、更直观的赋值，如我们在array() 函数中所看到的。

数据向量中的值按其在 FORTRAN 中出现的顺序给出数组中的值，即“列主序”，第一个下标移动最快，最后一个下标移动最慢。

例如，如果数组（例如 a）的维度向量为 c(3,4,2)，则 a 中有 3 * 4 * 2 = 24 个条目，数据向量按 a[1,1,1], a[2,1,1], …, a[2,4,2], a[3,4,2] 的顺序保存这些条目。

数组可以是一维的：此类数组通常与向量以相同的方式处理（包括打印时），但例外情况可能会引起混淆。

5.2 数组索引。数组的子部分 ¶

数组的各个元素可以通过给出数组名称，后跟方括号中的下标（用逗号分隔）来引用。

更一般地说，可以通过给出 索引向量 序列来指定数组的子部分，以代替下标；但是，如果任何索引位置给出了一个空索引向量，则取该下标的全部范围。

继续前面的示例，a[2,,] 是一个 4 * 2 数组，维度向量为 c(4,2)，数据向量包含按以下顺序排列的值

c(a[2,1,1], a[2,2,1], a[2,3,1], a[2,4,1],
  a[2,1,2], a[2,2,2], a[2,3,2], a[2,4,2])

。 a[,,] 表示整个数组，这与完全省略下标并单独使用 a 相同。

对于任何数组（例如 Z），维度向量可以明确地引用为 dim(Z)（在赋值的任一侧）。

此外，如果数组名称仅给出 一个下标或索引向量，则仅使用数据向量的相应值；在这种情况下，维度向量将被忽略。但是，如果单个索引不是向量而是数组本身，则情况并非如此，我们接下来将对此进行讨论。

5.3 索引矩阵 ¶

除了在任何下标位置使用索引向量外，还可以将矩阵与单个 索引矩阵 一起使用，以便将数量向量分配给数组中元素的不规则集合，或将不规则集合作为向量提取出来。

矩阵示例让这个过程变得清晰。对于双重索引数组，可以给出一个由两列和任意行数组成的索引矩阵。索引矩阵中的条目是双重索引数组的行索引和列索引。例如，假设我们有一个 4 乘 5 数组 X，我们希望执行以下操作

• 将元素 X[1,3]、X[2,2] 和 X[3,1] 作为矢量结构提取出来，并且
• 用零替换数组 X 中的这些条目。

在这种情况下，我们需要一个 3 乘 2 下标数组，如下例所示。

> x <- array(1:20, dim=c(4,5))   # Generate a 4 by 5 array.
> x
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    5    9   13   17
[2,]    2    6   10   14   18
[3,]    3    7   11   15   19
[4,]    4    8   12   16   20
> i <- array(c(1:3,3:1), dim=c(3,2))
> i                             # i is a 3 by 2 index array.
     [,1] [,2]
[1,]    1    3
[2,]    2    2
[3,]    3    1
> x[i]                          # Extract those elements
[1] 9 6 3
> x[i] <- 0                     # Replace those elements by zeros.
> x
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    5    0   13   17
[2,]    2    0   10   14   18
[3,]    0    7   11   15   19
[4,]    4    8   12   16   20
>

索引矩阵中不允许出现负索引。允许出现 NA 和零值：包含零的行在索引矩阵中会被忽略，包含 NA 的行在结果中会产生一个 NA。

作为一个不太简单的示例，假设我们希望为由因子 blocks（b 个级别）和 varieties（v 个级别）定义的块设计生成一个（未简化的）设计矩阵。此外，假设实验中有 n 个小区。我们可以按以下方式进行

> Xb <- matrix(0, n, b)
> Xv <- matrix(0, n, v)
> ib <- cbind(1:n, blocks)
> iv <- cbind(1:n, varieties)
> Xb[ib] <- 1
> Xv[iv] <- 1
> X <- cbind(Xb, Xv)

要构造关联矩阵（假设为 N），我们可以使用

> N <- crossprod(Xb, Xv)

但是，生成此矩阵的一种更简单的直接方法是使用 table()：

> N <- table(blocks, varieties)

索引矩阵必须是数值的：作为矩阵提供的任何其他形式的矩阵（例如逻辑矩阵或字符矩阵）都将被视为索引矢量。

5.4 array() 函数 ¶

除了给矢量结构一个 dim 属性之外，还可以通过 array 函数从矢量构造数组，该函数的形式为

> Z <- array(data_vector, dim_vector)

例如，如果矢量 h 包含 24 个或更少的数字，则命令

> Z <- array(h, dim=c(3,4,2))

将使用 h 在 Z 中设置一个 3 乘 4 乘 2 数组。如果 h 的大小恰好为 24，则结果与

> Z <- h ; dim(Z) <- c(3,4,2)

相同。但是，如果 h 短于 24，则其值将从头开始循环使用以使其达到 24 的大小（参见 混合矢量和数组算术。循环使用规则），但 dim(h) <- c(3,4,2) 会发出关于长度不匹配的错误。作为一个极端的但常见的示例

> Z <- array(0, c(3,4,2))

使 Z 成为一个全零数组。

此时dim(Z)表示维度向量c(3,4,2)，Z[1:24]表示数据向量，就像在h中一样，Z[]带空下标或Z不带下标表示整个数组作为数组。

数组可用于算术表达式，结果是通过对数据向量进行逐元素运算形成的数组。dim运算符的属性通常需要相同，这将成为结果的维度向量。因此，如果A、B和C都是类似的数组，则

> D <- 2*A*B + C + 1

使D成为类似的数组，其数据向量是给定逐元素运算的结果。但是，关于混合数组和向量计算的精确规则必须更仔细地考虑一下。

• 混合向量和数组算术。循环利用规则

5.5 两个数组的外积 ¶

数组上的一个重要操作是外积。如果 a 和 b 是两个数值数组，它们的外积是一个数组，其维度向量是通过连接它们的两个维度向量（顺序很重要）获得的，其数据向量是通过形成 a 的数据向量的元素与 b 的数据向量的元素的所有可能乘积而获得的。外积由特殊运算符 %o% 形成：

> ab <- a %o% b

另一种方法是

> ab <- outer(a, b, "*")

乘法函数可以用两个变量的任意函数替换。例如，如果我们希望使用 R 向量 x 和 y 分别定义的 x 和 y 坐标的规则值网格对函数 f(x; y) = cos(y)/(1 + x^2) 进行求值，我们可以按如下方式进行

> f <- function(x, y) cos(y)/(1 + x^2)
> z <- outer(x, y, f)

特别是，两个普通向量的外积是一个双下标数组（即一个秩最多为 1 的矩阵）。请注意，外积运算符当然是非交换的。在编写自己的函数中将进一步考虑定义您自己的 R 函数。

一个示例：2 x 2 单数字矩阵的行列式 ¶

作为一个简单但可爱的示例，考虑行列式为 2 乘 2 的矩阵 [a, b; c, d]，其中每个条目都是范围 0, 1, ..., 9 中的非负整数，即数字。

问题是找到此形式的所有可能矩阵的行列式 ad - bc，并以 高密度 图的形式表示每个值出现的频率。这相当于找到行列式的概率分布，如果每个数字都是独立且均匀随机选择的。

一种巧妙的方法是使用 outer() 函数两次

> d <- outer(0:9, 0:9)
> fr <- table(outer(d, d, "-"))
> plot(fr, xlab="Determinant", ylab="Frequency")

请注意，此处 plot() 使用直方图之类的绘图方法，因为它“看到” fr 是 "table" 类的。使用 for 循环解决此问题的“明显”方法将在 分组、循环和条件执行 中讨论，效率太低，不切实际。

大约 20 个此类矩阵中有一个是奇异矩阵，这也许令人惊讶。

5.6 数组的广义转置 ¶

函数 aperm(a, perm) 可用于排列数组 a。参数 perm 必须是整数 {1, ..., k} 的排列，其中 k 是 a 中下标的数量。该函数的结果是一个与 a 大小相同的数组，但旧维度由 perm[j] 给出，成为新的第 j 维。考虑此操作的最简单方法是将其视为矩阵转置的概括。实际上，如果 A 是一个矩阵（即双下标数组），那么由下式给出的 B

> B <- aperm(A, c(2,1))

只是 A 的转置。对于此特殊情况，可以使用更简单的函数 t() ，因此我们可以使用 B <- t(A)。

5.7 矩阵工具 ¶

如上所述，矩阵只是一个具有两个下标的数组。然而，它是一个非常重要的特例，需要单独讨论。R 包含许多仅可用于矩阵的运算符和函数。例如，如上所述，t(X) 是矩阵转置函数。函数 nrow(A) 和 ncol(A) 分别给出矩阵 A 中的行数和列数。

• 矩阵乘法
• 线性方程和求逆
• 特征值和特征向量
• 奇异值分解和行列式
• 最小二乘拟合和 QR 分解

> A * B

> A %*% B

> x %*% A %*% x

> b <- A %*% x

> solve(A,b)

solve(A)

> ev <- eigen(Sm)

> evals <- eigen(Sm)$values

> eigen(Sm)

> evals <- eigen(Sm, only.values = TRUE)$values

> absdetM <- prod(svd(M)$d)

> absdet <- function(M) prod(svd(M)$d)

> ans <- lsfit(X, y)

> Xplus <- qr(X)
> b <- qr.coef(Xplus, y)
> fit <- qr.fitted(Xplus, y)
> res <- qr.resid(Xplus, y)

5.8 形成分区矩阵，cbind() 和 rbind() ¶

正如我们已经非正式地看到的那样，可以通过函数 cbind() 和 rbind() 从其他向量和矩阵构建矩阵。大致上 cbind() 通过水平或按列方式将矩阵绑定在一起来形成矩阵，而 rbind() 则通过垂直或按行方式绑定在一起来形成矩阵。

在赋值中

> X <- cbind(arg_1, arg_2, arg_3, ...)

对 cbind() 的参数必须是任意长度的向量或具有相同列大小的矩阵，即相同数量的行。结果是一个矩阵，其中连接的参数 arg_1、arg_2、… 形成列。

如果对 cbind() 的某些参数是向量，则它们可能比任何现有矩阵的列大小短，在这种情况下，它们将被循环扩展以匹配矩阵列大小（如果没有给出矩阵，则匹配最长向量的长度）。

函数 rbind() 对行执行相应的操作。在这种情况下，任何向量参数（可能循环扩展）当然都被视为行向量。

假设 X1 和 X2 具有相同数量的行。为了通过列将它们组合到矩阵 X 中，连同 1 的初始列，我们可以使用

> X <- cbind(1, X1, X2)

rbind() 或 cbind() 的结果始终具有矩阵状态。因此，cbind(x) 和 rbind(x) 可能分别允许向量 x 被视为列或行矩阵的最简单方法。

5.9 连接函数 c() 与数组 ¶

值得注意的是，虽然 cbind() 和 rbind() 是尊重 dim 属性的连接函数，但基本 c() 函数则不是，而是清除所有 dim 和 dimnames 属性的数字对象。这偶尔会很有用。

将数组强制转换回简单向量对象的官方方法是使用 as.vector()

> vec <- as.vector(X)

然而，可以通过仅使用一个参数来使用 c() 来实现类似的结果，仅仅是为了这个副作用

> vec <- c(X)

两者之间有细微的差别，但最终它们之间的选择在很大程度上取决于风格（前者更可取）。

5.10 因子的频率表 ¶

回想一下，因子定义了分组划分。类似地，一对因子定义了一个双向交叉分类，依此类推。 函数 table() 允许从等长因子计算频率表。如果有 k 个因子参数，结果是一个 k 维频率数组。

例如，假设 statef 是一个因子，它为数据向量中的每个条目提供状态代码。赋值

> statefr <- table(statef)

在 statefr 中给出了样本中每个状态的频率表。频率按因子的 levels 属性排序并标记。这个简单的情况等同于以下情况，但更方便：

> statefr <- tapply(statef, statef, length)

进一步假设 incomef 是一个因子，它为数据向量中的每个条目提供了一个适当定义的“收入等级”，例如使用 cut() 函数

> factor(cut(incomes, breaks = 35+10*(0:7))) -> incomef

然后计算频率的双向表

> table(incomef,statef)
         statef
incomef   act nsw nt qld sa tas vic wa
  (35,45]   1   1  0   1  0   0   1  0
  (45,55]   1   1  1   1  2   0   1  3
  (55,65]   0   3  1   3  2   2   2  1
  (65,75]   0   1  0   0  0   0   1  0

立即扩展到更高阶的频率表。

6.1 列表 ¶

R 中的列表是一个对象，它由一个有序的对象集合组成，称为其组件。

组件没有特别的需要具有相同的模式或类型，例如，一个列表可以由一个数字向量、一个逻辑值、一个矩阵、一个复数向量、一个字符数组、一个函数等组成。下面是一个创建列表的简单示例

> Lst <- list(name="Fred", wife="Mary", no.children=3,
              child.ages=c(4,7,9))

组件始终编号，并且始终可以这样引用。因此，如果Lst是一个有四个组件的列表的名称，则可以单独引用它们为Lst[[1]]、Lst[[2]]、Lst[[3]]和Lst[[4]]。此外，如果Lst[[4]]是一个向量下标数组，则Lst[[4]][1]是它的第一个条目。

如果Lst是一个列表，则函数length(Lst)给出它具有的（顶级）组件数。

列表的组件也可以命名，在这种情况下，组件可以通过在双方括号中用字符字符串代替数字来引用，或者更方便地通过给出以下形式的表达式来引用

> name$component_name

表示相同的事物。

这是一个非常有用的约定，因为它可以让你在忘记数字时更容易获得正确的组件。

因此，在上面给出的简单示例中

Lst$name与Lst[[1]]相同，是字符串"Fred"，

Lst$wife与Lst[[2]]相同，是字符串"Mary"，

Lst$child.ages[1]与Lst[[4]][1]相同，是数字4。

此外，还可以使用双重方括号中的列表组件名称，即 Lst[["name"]] 与 Lst$name 相同。当要提取的组件名称存储在另一个变量中时，这特别有用，如

> x <- "name"; Lst[[x]]

区分 Lst[[1]] 和 Lst[1] 非常重要。‘[[…]]’ 是用于选择单个元素的操作符，而 ‘[…]’ 是一个通用下标操作符。因此前者是 列表 Lst 中的第一个对象，如果它是一个命名列表，则 不 包含名称。后者是 列表 Lst 的一个子列表，仅包含第一个条目。如果它是一个命名列表，则名称将被转移到子列表中。

组件的名称可以缩写为唯一标识它们所需的最小字母数。因此 Lst$coefficients 可以最小指定为 Lst$coe，Lst$covariance 可以最小指定为 Lst$cov。

名称向量实际上只是列表的一个属性，就像其他任何属性一样，可以作为这样的属性进行处理。当然，除了列表之外的其他结构也可以赋予一个 名称 属性。

6.2 构造和修改列表 ¶

可以通过函数 list() 从现有对象中形成新列表。形式为

> Lst <- list(name_1=object_1, ..., name_m=object_m)

使用 object_1、…、object_m 为组件设置列表 Lst，并根据参数名称（可以自由选择）为这些组件指定名称。如果省略这些名称，则组件仅编号。用于形成列表的组件在形成新列表时会复制，而不会影响原始组件。

列表与任何带下标的对象一样，可以通过指定附加组件进行扩展。例如

> Lst[5] <- list(matrix=Mat)

• 连接列表

> list.ABC <- c(list.A, list.B, list.C)

6.3 数据框 ¶

数据框是具有类 "data.frame" 的列表。对于可以制成数据框的列表有一些限制，即

• 组件必须是矢量（数字、字符或逻辑）、因子、数字矩阵、列表或其他数据框。
• 矩阵、列表和数据框分别向新数据框提供与它们具有相同数量的列、元素或变量的变量。
• 作为数据框变量出现的矢量结构必须长度相同，矩阵结构必须行数相同。

对于许多目的，数据框可以看作是列可能具有不同模式和属性的矩阵。它可以以矩阵形式显示，并使用矩阵索引约定提取其行和列。

• 制作数据框
• attach() 和 detach()
• 使用数据框
• 附加任意列表
• 管理搜索路径

> accountants <- data.frame(home=statef, loot=incomes, shot=incomef)

> attach(lentils)

> u <- v+w

> lentils$u <- v+w

> detach()

> attach(any.old.list)

> search()
[1] ".GlobalEnv"   "Autoloads"    "package:base"

> search()
[1] ".GlobalEnv"   "lentils"      "Autoloads"    "package:base"
> ls(2)
[1] "u" "v" "w"

> detach("lentils")
> search()
[1] ".GlobalEnv"   "Autoloads"    "package:base"

7.1 read.table() 函数 ¶

要直接读取整个数据框，外部文件通常具有特殊形式。

• 文件的第一行应为数据框中每个变量的名称。
• 文件中的每一行都将第一个项目作为行标签和每个变量的值。

如果文件的第一行比第二行少一个项目，则假定此排列有效。因此，要作为数据框读取的文件的前几行可能如下所示。

Input file form with names and row labels: Price Floor Area Rooms Age Cent.heat 01 52.00 111.0 830 5 6.2 no 02 54.75 128.0 710 5 7.5 no 03 57.50 101.0 1000 5 4.2 no 04 57.50 131.0 690 6 8.8 no 05 59.75 93.0 900 5 1.9 yes ...

默认情况下，数字项（行标签除外）将作为数字变量读取，而非数字变量（如示例中的 Cent.heat）将作为字符变量读取。如有必要，可以更改此设置。

然后可以使用函数 read.table() 直接读取数据框

> HousePrice <- read.table("houses.data")

通常，您希望直接省略包括行标签并使用默认标签。在这种情况下，文件可以省略行标签列，如下所示。

Input file form without row labels: Price Floor Area Rooms Age Cent.heat 52.00 111.0 830 5 6.2 no 54.75 128.0 710 5 7.5 no 57.50 101.0 1000 5 4.2 no 57.50 131.0 690 6 8.8 no 59.75 93.0 900 5 1.9 yes ...

然后可以读取数据框，如下所示

> HousePrice <- read.table("houses.data", header=TRUE)

其中，header=TRUE 选项指定第一行是标题行，因此，从文件形式中可以推断出没有给出明确的行标签。

7.2 scan() 函数 ¶

假设数据向量长度相等，并且要并行读取。此外，假设有三个向量，第一个模式为字符，其余两个模式为数字，并且文件为 input.dat。第一步是使用 scan() 将三个向量作为列表读入，如下所示

> inp <- scan("input.dat", list("",0,0))

第二个参数是一个虚拟列表结构，用于建立要读取的三个向量的模式。存储在 inp 中的结果是一个列表，其组件是读入的三个向量。要将数据项分隔为三个单独的向量，请使用类似这样的赋值

> label <- inp[[1]]; x <- inp[[2]]; y <- inp[[3]]

更方便的是，虚拟列表可以具有命名组件，在这种情况下，可以使用名称来访问读入的向量。例如

> inp <- scan("input.dat", list(id="", x=0, y=0))

如果您希望分别访问变量，则可以将它们重新分配给工作框架中的变量

> label <- inp$id; x <- inp$x; y <- inp$y

或者列表可以附加到搜索路径的第 2 个位置（请参阅附加任意列表）。

如果第二个参数是单个值而不是列表，则读入单个向量，其所有组件的模式必须与虚拟值相同。

> X <- matrix(scan("light.dat", 0), ncol=5, byrow=TRUE)

有更多精细的输入工具，这些工具在手册中进行了详细说明。

7.3 访问内置数据集 ¶

R 提供了大约 100 个数据集（在 datasets 包中），其他数据集可在包中获得（包括 R 提供的推荐包）。要查看当前可用的数据集列表，请使用

data()

R 提供的所有数据集都可直接按名称获取。但是，许多包仍使用已过时的惯例，其中 data 也用于将数据集加载到 R 中，例如

data(infert)

这仍可与标准包一起使用（如本示例中所示）。在大多数情况下，这将加载同名 R 对象。但是，在少数情况下，它会加载多个对象，因此请参阅对象的在线帮助以了解预期结果。

• 从其他 R 包加载数据

data(package="rpart")
data(Puromycin, package="datasets")

7.4 编辑数据 ¶

当在数据框或矩阵上调用 edit 时，它会调出一个类似电子表格的单独环境用于编辑。这对于在读取数据集后进行小幅更改非常有用。命令

> xnew <- edit(xold)

将允许你编辑数据集 xold，并且完成后，更改后的对象将分配给 xnew。如果你想更改原始数据集 xold，最简单的方法是使用 fix(xold)，它等效于 xold <- edit(xold)。

使用

> xnew <- edit(data.frame())

通过电子表格界面输入新数据。

8.1 R 作为一组统计表 ¶

R 的一个便利用途是提供一组全面的统计表。提供函数来评估累积分布函数 P(X <= x)、概率密度函数和分位数函数（给定q，最小的x，使得 P(X <= x) > q），并模拟分布。

分布	R 名称	其他参数
beta	beta	shape1、shape2、ncp
binomial	binom	size、prob
Cauchy	cauchy	location、scale
chi-squared	chisq	df、ncp
exponential	exp	rate
F	f	df1、df2、ncp
gamma	gamma	shape、scale
geometric	geom	prob
hypergeometric	hyper	m、n、k
log-normal	lnorm	meanlog、sdlog
logistic	logis	location、scale
negative binomial	nbinom	size、prob
normal	norm	mean、sd
Poisson	pois	lambda
signed rank	signrank	n
Student’s t	t	df、ncp
uniform	unif	min、max
Weibull	weibull	shape、scale
Wilcoxon	wilcox	m、n

在此给出的名称前加上“d”表示密度，“p”表示 CDF，“q”表示分位数函数，“r”表示模拟（random deviates）。第一个参数对于 dxxx 是 x，对于 pxxx 是 q，对于 qxxx 是 p，对于 rxxx 是 n（rhyper、rsignrank 和 rwilcox 除外，对于它们是 nn）。并非在所有情况下都提供非中心参数 ncp：有关详细信息，请参见在线帮助。

所有 pxxx 和 qxxx 函数都具有逻辑参数 lower.tail 和 log.p，而 dxxx 函数具有 log。这允许通过以下方式获取累积（或“积分”）风险函数 H(t) = - log(1 - F(t))：

 - pxxx(t, ..., lower.tail = FALSE, log.p = TRUE)

或更准确的对数似然（通过 dxxx(..., log = TRUE)），直接。

此外，还有用于正态分布样本的学生化范围分布的函数 ptukey 和 qtukey，以及用于多项分布的函数 dmultinom 和 rmultinom。其他分布可在贡献的软件包中获得，尤其是 SuppDists。

以下是一些示例

> ## 2-tailed p-value for t distribution
> 2*pt(-2.43, df = 13)
> ## upper 1% point for an F(2, 7) distribution
> qf(0.01, 2, 7, lower.tail = FALSE)

请参阅 RNG 的在线帮助，了解如何在 R 中进行随机数生成。

8.2 检查数据集的分布 ¶

给定一组（单变量）数据，我们可以通过多种方式检查其分布。最简单的方法是检查数字。summary 和 fivenum 给出了两个略有不同的摘要 ，而 stem（“茎叶”图）显示了数字。

> attach(faithful)
> summary(eruptions)
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max.
  1.600   2.163   4.000   3.488   4.454   5.100
> fivenum(eruptions)
[1] 1.6000 2.1585 4.0000 4.4585 5.1000
> stem(eruptions)

  The decimal point is 1 digit(s) to the left of the |

  16 | 070355555588
  18 | 000022233333335577777777888822335777888
  20 | 00002223378800035778
  22 | 0002335578023578
  24 | 00228
  26 | 23
  28 | 080
  30 | 7
  32 | 2337
  34 | 250077
  36 | 0000823577
  38 | 2333335582225577
  40 | 0000003357788888002233555577778
  42 | 03335555778800233333555577778
  44 | 02222335557780000000023333357778888
  46 | 0000233357700000023578
  48 | 00000022335800333
  50 | 0370

茎叶图类似于直方图，R 有一个函数 hist 来绘制直方图。

> hist(eruptions)
## make the bins smaller, make a plot of density
> hist(eruptions, seq(1.6, 5.2, 0.2), prob=TRUE)
> lines(density(eruptions, bw=0.1))
> rug(eruptions) # show the actual data points

可以使用 density 绘制更精美的密度图，并且在此示例中，我们添加了 density 生成的线。带宽 bw 是通过反复试验选择的，因为默认值会产生过多的平滑（对于“有趣”的密度通常如此）。（可以使用更好的自动带宽选择方法，在此示例中，bw = "SJ" 给出了一个好的结果。）

我们可以使用函数 ecdf 绘制经验累积分布函数。

> plot(ecdf(eruptions), do.points=FALSE, verticals=TRUE)

显然，此分布与任何标准分布都相差甚远。较右侧的模式怎么样，比如持续时间超过 3 分钟的喷发？让我们拟合一个正态分布并叠加拟合的 CDF。

> long <- eruptions[eruptions > 3]
> plot(ecdf(long), do.points=FALSE, verticals=TRUE)
> x <- seq(3, 5.4, 0.01)
> lines(x, pnorm(x, mean=mean(long), sd=sqrt(var(long))), lty=3)

分位数-分位数（Q-Q）图可以帮助我们更仔细地检查这一点。

par(pty="s")       # arrange for a square figure region
qqnorm(long); qqline(long)

这显示了合理的拟合，但右尾比正态分布的预期要短。让我们将此与 t 分布的模拟数据进行比较

x <- rt(250, df = 5)
qqnorm(x); qqline(x)

如果它是随机样本，通常会显示比正态分布预期更长的尾部。我们可以通过以下方式针对生成分布绘制 Q-Q 图

qqplot(qt(ppoints(250), df = 5), x, xlab = "Q-Q plot for t dsn")
qqline(x)

最后，我们可能需要对正态性（或非正态性）进行更正式的检验。R 提供 Shapiro-Wilk 检验

> shapiro.test(long)

         Shapiro-Wilk normality test

data:  long
W = 0.9793, p-value = 0.01052

和 Kolmogorov-Smirnov 检验

> ks.test(long, "pnorm", mean = mean(long), sd = sqrt(var(long)))

         One-sample Kolmogorov-Smirnov test

data:  long
D = 0.0661, p-value = 0.4284
alternative hypothesis: two.sided

（请注意，由于我们从同一样本中估计了正态分布的参数，因此分布理论在此处无效。）

8.3 单样本和双样本检验 ¶

到目前为止，我们已经将单个样本与正态分布进行了比较。更常见的操作是比较两个样本的各个方面。请注意，在 R 中，所有“经典”检验（包括下面使用的检验）都在包 stats 中，该包通常已加载。

考虑 Rice (1995, p.490) 中关于冰的熔化潜热（cal/gm）的以下数据集

Method A: 79.98 80.04 80.02 80.04 80.03 80.03 80.04 79.97
          80.05 80.03 80.02 80.00 80.02
Method B: 80.02 79.94 79.98 79.97 79.97 80.03 79.95 79.97

箱形图提供了两个样本的简单图形比较。

A <- scan()
79.98 80.04 80.02 80.04 80.03 80.03 80.04 79.97
80.05 80.03 80.02 80.00 80.02

B <- scan()
80.02 79.94 79.98 79.97 79.97 80.03 79.95 79.97

boxplot(A, B)

这表明第一组倾向于给出比第二组更高的结果。

要检验两个样本均值的相等性，我们可以使用 未配对 t 检验，方法是

> t.test(A, B)

         Welch Two Sample t-test

data:  A and B
t = 3.2499, df = 12.027, p-value = 0.00694
alternative hypothesis: true difference in means is not equal to 0
95 percent confidence interval:
 0.01385526 0.07018320
sample estimates:
mean of x mean of y
 80.02077  79.97875

如果假设正态分布，则确实表明存在显着差异。默认情况下，R 函数不假设两个样本中方差相等。我们可以使用 F 检验来检验方差是否相等，前提是两个样本来自正态总体。

> var.test(A, B)

         F test to compare two variances

data:  A and B
F = 0.5837, num df = 12, denom df =  7, p-value = 0.3938
alternative hypothesis: true ratio of variances is not equal to 1
95 percent confidence interval:
 0.1251097 2.1052687
sample estimates:
ratio of variances
         0.5837405

这表明没有显着差异的证据，因此我们可以使用假设方差相等的经典 t 检验。

> t.test(A, B, var.equal=TRUE)

         Two Sample t-test

data:  A and B
t = 3.4722, df = 19, p-value = 0.002551
alternative hypothesis: true difference in means is not equal to 0
95 percent confidence interval:
 0.01669058 0.06734788
sample estimates:
mean of x mean of y
 80.02077  79.97875

所有这些测试都假设两个样本的正态性。双样本 Wilcoxon（或 Mann-Whitney）检验仅假设零假设下的公共连续分布。

> wilcox.test(A, B)

         Wilcoxon rank sum test with continuity correction

data:  A and B
W = 89, p-value = 0.007497
alternative hypothesis: true location shift is not equal to 0

Warning message:
Cannot compute exact p-value with ties in: wilcox.test(A, B)

注意警告：每个样本中都有多个平局，这强烈表明这些数据来自离散分布（可能是由于舍入）。

有几种方法可以直观地比较两个样本。我们已经看到了一对箱线图。以下

> plot(ecdf(A), do.points=FALSE, verticals=TRUE, xlim=range(A, B))
> plot(ecdf(B), do.points=FALSE, verticals=TRUE, add=TRUE)

将显示两个经验 CDF，而 qqplot 将执行两个样本的 Q-Q 图。假设公共连续分布，Kolmogorov-Smirnov 检验是两个 ecdf 之间最大垂直距离

> ks.test(A, B)

         Two-sample Kolmogorov-Smirnov test

data:  A and B
D = 0.5962, p-value = 0.05919
alternative hypothesis: two-sided

Warning message:
cannot compute correct p-values with ties in: ks.test(A, B)

9.1 分组表达式 ¶

R 是一种表达式语言，其唯一命令类型是返回结果的函数或表达式。即使是赋值也是一个表达式，其结果是赋值的值，并且可以在任何可以使用表达式的任何地方使用它；特别是，可以进行多个赋值。

命令可以分组在大括号中，{expr_1; …; expr_m}，在这种情况下，组的值是组中最后一个表达式的结果评估。由于这样的组也是一个表达式，因此它可以（例如）本身包含在括号中并用作更大表达式的部分，依此类推。

9.2 控制语句 ¶

• 条件执行：if 语句
• 重复执行：for 循环、repeat 和 while

> if (expr_1) expr_2 else expr_3

> for (name in expr_1) expr_2

> xc <- split(x, ind)
> yc <- split(y, ind)
> for (i in 1:length(yc)) {
    plot(xc[[i]], yc[[i]])
    abline(lsfit(xc[[i]], yc[[i]]))
  }

> repeat expr

> while (condition) expr

10.1 简单示例 ¶

作为一个第一个示例，考虑一个函数来计算两个样本 t 统计量，显示“所有步骤”。当然，这是一个人工示例，因为还有其他更简单的方法来实现相同目的。

函数定义如下

> twosam <- function(y1, y2) {
    n1  <- length(y1); n2  <- length(y2)
    yb1 <- mean(y1);   yb2 <- mean(y2)
    s1  <- var(y1);    s2  <- var(y2)
    s <- ((n1-1)*s1 + (n2-1)*s2)/(n1+n2-2)
    tst <- (yb1 - yb2)/sqrt(s*(1/n1 + 1/n2))
    tst
  }

在此函数定义后，您可以使用如下调用执行两个样本 t 检验

> tstat <- twosam(data$male, data$female); tstat

作为一个第二个示例，考虑一个函数来直接模拟 MATLAB 反斜杠命令，该命令返回向量 y 在矩阵 X 的列空间上的正交投影的系数。（这通常称为回归系数的最小二乘估计。）通常使用 qr() 函数来完成此操作；但是，直接使用它有时有点棘手，并且值得拥有一个简单的函数（例如以下函数）来安全地使用它。

因此，给定一个 n 乘 1 向量 y 和一个 n 乘 p 矩阵 X，则 X \ y 定义为 (X’X)^{-}X’y，其中 (X’X)^{-} 是 X'X 的广义逆。

> bslash <- function(X, y) {
  X <- qr(X)
  qr.coef(X, y)
}

创建此对象后，可以在语句中使用它，例如

> regcoeff <- bslash(Xmat, yvar)

等等。

经典 R 函数 lsfit() 可以很好地完成此工作，还有更多²¹。它反过来以略微违反直觉的方式使用函数 qr() 和 qr.coef() 来完成计算的这一部分。因此，如果经常使用，那么将这一部分单独隔离在一个易于使用的函数中可能具有一定价值。如果是这样，我们可能希望将其设为矩阵二元运算符，以便更方便地使用。

10.2 定义新的二元运算符 ¶

如果我们给 bslash() 函数一个不同的名称，即以下形式之一

%anything%

它可以用作表达式中的二元运算符，而不是函数形式。例如，假设我们选择 ! 作为内部字符。然后，函数定义将以以下形式开始

> "%!%" <- function(X, y) { ... }

（注意引号的使用方式。）然后，该函数可以用作 X %!% y。（反斜杠符号本身不是一个方便的选择，因为它在此上下文中会出现特殊问题。）

矩阵乘法运算符 %*% 和外积矩阵运算符 %o% 是以这种方式定义的其他二元运算符示例。

10.3 命名参数和默认值 ¶

正如 生成常规序列 中首先指出的，如果以“name=object”的形式给出对被调用函数的参数，则可以按任何顺序给出它们。此外，参数序列可以从未命名的位置形式开始，并在位置参数之后指定命名参数。

因此，如果有一个由以下内容定义的函数 fun1

> fun1 <- function(data, data.frame, graph, limit) {
    [function body omitted]
  }

那么可以以多种方式调用该函数，例如

> ans <- fun1(d, df, TRUE, 20)
> ans <- fun1(d, df, graph=TRUE, limit=20)
> ans <- fun1(data=d, limit=20, graph=TRUE, data.frame=df)

都是等效的。

在很多情况下，参数可以赋予通常合适的默认值，在这种情况下，当默认值合适时，可以完全从调用中省略它们。例如，如果将 fun1 定义为

> fun1 <- function(data, data.frame, graph=TRUE, limit=20) { ... }

可以将其调用为

> ans <- fun1(d, df)

这现在等效于上述三个情况，或者作为

> ans <- fun1(d, df, limit=10)

这会更改其中一个默认值。

需要注意的是，默认值可以是任意表达式，甚至涉及同一函数的其他参数；它们不必像我们这里简单的示例那样被限制为常量。

10.4 ‘…’ 参数 ¶

另一个常见要求是允许一个函数将参数设置传递给另一个函数。例如，许多图形函数使用函数 par()，而 plot() 等函数允许用户将图形参数传递给 par() 以控制图形输出。（有关 par() 函数的更多详细信息，请参见永久更改：par() 函数。）这可以通过在函数中包含一个额外的参数（从字面上讲为 ‘…’）来完成，然后可以传递该参数。下面给出了一个概要示例。

fun1 <- function(data, data.frame, graph=TRUE, limit=20, ...) {
  [omitted statements]
  if (graph)
    par(pch="*", ...)
  [more omissions]
}

不太常见的是，函数需要引用 ‘…’ 的组件。表达式 list(...) 会计算所有此类参数，并将它们以命名列表的形式返回，而 ..1、..2 等会一次计算一个参数，其中 ‘..n’ 返回第 n 个未匹配的参数。

10.5 函数内的赋值 ¶

请注意，在函数中执行的任何普通赋值都是局部且临时的，在退出函数后将丢失。因此，赋值 X <- qr(X) 不会影响调用程序中参数的值。

要完全理解控制 R 赋值范围的规则，读者需要熟悉评估框架的概念。这是一个有点高级但并不难的主题，这里不再赘述。

如果在函数中打算进行全局且永久的赋值，则可以使用“超赋值”运算符 <<- 或函数 assign()。有关详细信息，请参阅 help 文档。

10.6 更高级的示例 ¶

• 块设计中的效率因子
• 删除打印数组中的所有名称
• 递归数值积分

> bdeff <- function(blocks, varieties) {
    blocks <- as.factor(blocks)             # minor safety move
    b <- length(levels(blocks))
    varieties <- as.factor(varieties)       # minor safety move
    v <- length(levels(varieties))
    K <- as.vector(table(blocks))           # remove dim attr
    R <- as.vector(table(varieties))        # remove dim attr
    N <- table(blocks, varieties)
    A <- 1/sqrt(K) * N * rep(1/sqrt(R), rep(b, v))
    sv <- svd(A)
    list(eff=1 - sv$d^2, blockcv=sv$u, varietycv=sv$v)
}

> temp <- X
> dimnames(temp) <- list(rep("", nrow(X)), rep("", ncol(X)))
> temp; rm(temp)

no.dimnames <- function(a) {
  ## Remove all dimension names from an array for compact printing.
  d <- list()
  l <- 0
  for(i in dim(a)) {
    d[[l <- l + 1]] <- rep("", i)
  }
  dimnames(a) <- d
  a
}

> no.dimnames(X)

area <- function(f, a, b, eps = 1.0e-06, lim = 10) {
  fun1 <- function(f, a, b, fa, fb, a0, eps, lim, fun) {
    ## function ‘fun1’ is only visible inside ‘area’
    d <- (a + b)/2
    h <- (b - a)/4
    fd <- f(d)
    a1 <- h * (fa + fd)
    a2 <- h * (fd + fb)
    if(abs(a0 - a1 - a2) < eps || lim == 0)
      return(a1 + a2)
    else {
      return(fun(f, a, d, fa, fd, a1, eps, lim - 1, fun) +
             fun(f, d, b, fd, fb, a2, eps, lim - 1, fun))
    }
  }
  fa <- f(a)
  fb <- f(b)
  a0 <- ((fa + fb) * (b - a))/2
  fun1(f, a, b, fa, fb, a0, eps, lim, fun1)
}

10.7 作用域 ¶

本节中的讨论比本文档其他部分的技术性更强。但是，它详细说明了 S-PLUS 和 R 之间的一个主要区别。

函数体中出现的符号可分为三类；形式参数、局部变量和自由变量。函数的形式参数是出现在函数参数列表中的那些。它们的值由将实际函数参数绑定到形式参数的过程确定。局部变量是其值由函数体中表达式的求值确定的那些。不是形式参数或局部变量的变量称为自由变量。如果自由变量被赋值，则它们将变为局部变量。考虑以下函数定义。

f <- function(x) {
  y <- 2*x
  print(x)
  print(y)
  print(z)
}

在此函数中，x 是形式参数，y 是局部变量，z 是自由变量。

在 R 中，首先在创建函数的环境中查找来解析自由变量绑定。这称为词法作用域。首先，我们定义一个名为 cube 的函数。

cube <- function(n) {
  sq <- function() n*n
  n*sq()
}

函数 sq 中的变量 n 不是该函数的参数。因此，它是一个自由变量，并且必须使用作用域规则来确定与它关联的值。在静态作用域 (S-PLUS) 下，该值与名为 n 的全局变量相关联。在词法作用域 (R) 下，它是函数 cube 的参数，因为这是定义函数 sq 时变量 n 的活动绑定。在 R 中求值和在 S-PLUS 中求值之间的区别在于，S-PLUS 查找名为 n 的全局变量，而 R 首先在调用 cube 时创建的环境中查找名为 n 的变量。

## first evaluation in S
S> cube(2)
Error in sq(): Object "n" not found
Dumped
S> n <- 3
S> cube(2)
[1] 18
## then the same function evaluated in R
R> cube(2)
[1] 8

词法作用域还可以用于为函数赋予可变状态。在以下示例中，我们将展示如何使用 R 模拟银行账户。一个有效的银行账户需要有余额或总额、一个用于取款的函数、一个用于存款的函数以及一个用于说明当前余额的函数。我们通过在 account 中创建这三个函数，然后返回包含它们的列表来实现这一点。当调用 account 时，它会采用一个数字参数 total，并返回一个包含这三个函数的列表。由于这些函数是在包含 total 的环境中定义的，因此它们将能够访问其值。

特殊赋值运算符 <<-， 用于更改与 total 关联的值。此运算符会在封闭环境中向后查找包含符号 total 的环境，并且当它找到这样的环境时，它会用右侧的值替换该环境中的值。如果在未找到符号 total 的情况下到达全局或顶级环境，那么将创建该变量并将其分配到那里。对于大多数用户，<<- 会创建一个全局变量，并将右侧的值分配给它²²。只有当在作为另一个函数的值返回的函数中使用了 <<- 时，才会发生此处描述的特殊行为。

open.account <- function(total) {
  list(
    deposit = function(amount) {
      if(amount <= 0)
        stop("Deposits must be positive!\n")
      total <<- total + amount
      cat(amount, "deposited.  Your balance is", total, "\n\n")
    },
    withdraw = function(amount) {
      if(amount > total)
        stop("You don't have that much money!\n")
      total <<- total - amount
      cat(amount, "withdrawn.  Your balance is", total, "\n\n")
    },
    balance = function() {
      cat("Your balance is", total, "\n\n")
    }
  )
}

ross <- open.account(100)
robert <- open.account(200)

ross$withdraw(30)
ross$balance()
robert$balance()

ross$deposit(50)
ross$balance()
ross$withdraw(500)

10.8 自定义环境 ¶

用户可以通过多种不同的方式自定义其环境。有一个站点初始化文件，并且每个目录都可以有自己的特殊初始化文件。最后，可以使用特殊函数 .First 和 .Last。

网站初始化文件的位置取自 R_PROFILE 环境变量的值。如果该变量未设置，则使用 R 主目录 etc 中的文件 Rprofile.site。此文件应包含每次在您的系统下启动 R 时要执行的命令。第二个个人配置文件名为 .Rprofile²³ 可以放置在任何目录中。如果在该目录中调用 R，则会引用该文件。此文件让各个用户可以控制其工作区，并允许在不同的工作目录中使用不同的启动过程。如果在启动目录中找不到 .Rprofile 文件，则 R 会在用户的个人目录中查找 .Rprofile 文件并使用该文件（如果存在）。如果设置了环境变量 R_PROFILE_USER，则会使用它指向的文件，而不是 .Rprofile 文件。

在两个配置文件或 .RData 映像中命名的任何函数 .First() 都有特殊状态。它会在 R 会话开始时自动执行，可用于初始化环境。例如，以下示例中的定义将提示符更改为 $，并设置会话其余部分可以视为理所当然的其他各种有用内容。

因此，执行文件的顺序为 Rprofile.site、用户配置文件、.RData，然后是 .First()。后面文件中的定义将屏蔽前面文件中的定义。

> .First <- function() {
  options(prompt="$ ", continue="+\t")  # $ is the prompt
  options(digits=5, length=999)         # custom numbers and printout
  x11()                                 # for graphics
  par(pch = "+")                        # plotting character
  source(file.path(Sys.getenv("HOME"), "R", "mystuff.R"))
                                        # my personal functions
  library(MASS)                         # attach a package
}

类似地，如果定义了函数 .Last()，则通常会在会话的最后执行该函数。下面给出了一个示例。

> .Last <- function() {
  graphics.off()                        # a small safety measure.
  cat(paste(date(),"\nAdios\n"))        # Is it time for lunch?
}

10.9 类、泛型函数和面向对象 ¶

对象的类决定了它将如何被所谓的泛型函数处理。换句话说，泛型函数对其参数执行特定于参数本身类的任务或操作。如果参数没有任何 class 属性，或者没有针对该泛型函数专门提供的类，则始终提供默认操作。

一个示例可以更清楚地说明。类机制为用户提供了设计和编写特殊用途泛型函数的功能。其他泛型函数包括用于以图形方式显示对象的 plot()、用于汇总各种类型分析的 summary()，以及用于比较统计模型的 anova()。

可以以特定方式处理类的泛型函数的数量可能很大。例如，可以适应类 "data.frame" 对象的函数包括

[     [[<-    any    as.matrix
[<-   mean    plot   summary

可以使用 methods() 函数获取当前完整列表

> methods(class="data.frame")

相反，泛型函数可以处理的类数量也可以非常大。例如，plot() 函数具有默认方法和针对 "data.frame"、"density"、"factor" 等类的对象的变体。可以通过使用 methods() 函数再次获取完整列表

> methods(plot)

对于许多泛型函数，函数主体非常短，例如

> coef
function (object, ...)
UseMethod("coef")

UseMethod 的存在表示这是一个泛型函数。要查看可用的方法，我们可以使用 methods()

> methods(coef)
[1] coef.aov*         coef.Arima*       coef.default*     coef.listof*
[5] coef.nls*         coef.summary.nls*

   Non-visible functions are asterisked

在此示例中，有六种方法，通过键入其名称无法看到任何一种方法。我们可以通过以下任一种方法来读取它们

> getAnywhere("coef.aov")
A single object matching ‘coef.aov’ was found
It was found in the following places
  registered S3 method for coef from namespace stats
  namespace:stats
with value

function (object, ...)
{
    z <- object$coef
    z[!is.na(z)]
}

> getS3method("coef", "aov")
function (object, ...)
{
    z <- object$coef
    z[!is.na(z)]
}

泛型 gen 将调用名为 gen.cl 的函数以获取类 cl，因此不要以这种样式命名函数，除非它们打算成为方法。

建议读者参阅 R 语言定义 以更全面地讨论此机制。

11.1 定义统计模型；公式 ¶

统计模型的模板是具有独立同方差误差的线性回归模型

y_i = sum_{j=0}^p beta_j x_{ij} + e_i,     i = 1, ..., n,

其中 e_i 是 NID(0, sigma^2)。用矩阵形式表示如下

y = X  beta + e

其中 y 是响应向量，X 是 模型矩阵 或 设计矩阵，具有列 x_0, x_1, ..., x_p，即确定变量。通常 x_0 将是一列定义 截距 项的 1。

示例 ¶

在给出正式规范之前，一些示例可能有助于设置图片。

假设 y、x、x0、x1、x2 等是数值变量，X 是一个矩阵，A、B、C 等是因子。下面左侧的公式指定了右侧描述的统计模型。

y ~ x

y ~ 1 + x

这两个公式都隐含了 y 对 x 的相同简单线性回归模型。第一个具有隐式截距项，第二个具有显式截距项。

y ~ 0 + x

y ~ -1 + x

y ~ x - 1

y 对 x 的简单线性回归通过原点（即没有截距项）。

log(y) ~ x1 + x2

对转换变量 log(y) 的多元回归，对 x1 和 x2（具有隐式截距项）。

y ~ poly(x,2)

y ~ 1 + x + I(x^2)

y 对 x 的 2 次多项式回归。第一种形式使用正交多项式，第二种形式使用显式幂作为基础。

y ~ X + poly(x,2)

多元回归 y，其模型矩阵由矩阵 X 以及 x 中的 2 次多项式项组成。

y ~ A

由 A 确定的类别的 y 的单分类方差分析模型。

y ~ A + x

由 A 确定的类别的 y 的单分类协方差分析模型，其中协变量为 x。

y ~ A*B

y ~ A + B + A:B

y ~ B %in% A

y ~ A/B

y 在 A 和 B 上的二因子非加性模型。前两个指定相同的交叉分类，后两个指定相同的嵌套分类。从抽象意义上讲，所有四个都指定相同的模型子空间。

y ~ (A + B + C)^2

y ~ A*B*C - A:B:C

三因子实验，但模型仅包含主效应和二因子交互作用。这两个公式指定相同的模型。

y ~ A * x

y ~ A/x

y ~ A/(1 + x) - 1

y 在 A 的级别内在 x 上的独立简单线性回归模型，具有不同的编码。最后一种形式生成与 A 中的级别一样多的不同截距和斜率的明确估计值。

y ~ A*B + Error(C)

一个具有两个处理因子（A 和 B）的实验，以及由因子 C 确定的误差层。例如，一个裂区实验，其中全区（因此还有子区）由因子 C 确定。

运算符 ~ 用于在 R 中定义一个 模型公式。对于普通线性模型，形式为

response ~ op_1 term_1 op_2 term_2 op_3 term_3 ...

其中

响应

是一个向量或矩阵（或求值为向量或矩阵的表达式），定义响应变量。

op_i

是一个运算符，即 + 或 -，表示在模型中包含或排除一个项（第一个是可选的）。

term_i

要么是

• 一个向量或矩阵表达式，或 1，
• 一个因子，或
• 一个 公式表达式，其中因子、向量或矩阵通过 公式运算符 连接。

在所有情况下，每个项都定义了一组要添加到模型矩阵或从中删除的列。一个 1 代表一个截距列，并且默认情况下包含在模型矩阵中，除非明确删除。

这些 公式运算符 的效果类似于 Glim 和 Genstat 等程序使用的 Wilkinson 和 Rogers 符号。一个不可避免的更改是运算符 ‘.’ 变为 ‘:’，因为句点是 R 中有效的名称字符。

符号总结如下（基于 Chambers & Hastie，1992 年，第 29 页）

Y ~ M

Y 被建模为 M。

M_1 + M_2

包含 M_1 和 M_2。

M_1 - M_2

包含 M_1，省略 M_2 的项。

M_1 : M_2

M_1 和 M_2 的张量积。如果两个项都是因子，则“子类”因子。

M_1 %in% M_2

类似于 M_1:M_2，但编码不同。

M_1 * M_2

M_1 + M_2 + M_1:M_2.

M_1 / M_2

M_1 + M_2 %in% M_1.

M^n

M 中的所有项以及与 n 阶“交互”项

I(M)

隔离 M。在 M 内部，所有运算符都有其常规算术含义，并且该项出现在模型矩阵中。

请注意，在通常括起函数参数的括号内，所有运算符都有其常规算术含义。函数 I() 是一个恒等函数，用于允许使用算术运算符定义模型公式中的项。

特别注意，模型公式指定模型矩阵的列，参数的指定是隐式的。在其他情况下并非如此，例如在指定非线性模型时。

• 对比

options(contrasts = c("contr.treatment", "contr.poly"))

options(contrasts = c("contr.helmert", "contr.poly"))

11.2 线性模型 ¶

用于拟合普通多元模型的基本函数是lm()，并且调用的精简版本如下：

> fitted.model <- lm(formula, data = data.frame)

例如

> fm2 <- lm(y ~ x1 + x2, data = production)

将拟合y在x1和x2上的多元回归模型（具有隐式截距项）。

重要的（但在技术上是可选的）参数data = production指定用于构建模型的任何变量都应首先来自production数据框。 无论数据框production是否已附加到搜索路径上，情况都是如此。

11.3 用于提取模型信息的通用函数 ¶

lm() 的值是一个拟合模型对象；从技术上讲，它是 "lm" 类的结果列表。然后，可以使用面向 "lm" 类的对象的通用函数来显示、提取、绘制拟合模型的信息，依此类推。这些函数包括

add1    deviance   formula      predict  step
alias   drop1      kappa        print    summary
anova   effects    labels       proj     vcov
coef    family     plot         residuals

下面简要介绍最常用的函数。

anova(object_1, object_2) ¶

将子模型与外部模型进行比较，并生成方差分析表。

coef(object) ¶

提取回归系数（矩阵）。

长格式：coefficients(object)。

deviance(object) ¶

残差平方和，如果适用，则加权。

formula(object) ¶

提取模型公式。

plot(object) ¶

生成四个图，显示残差、拟合值和一些诊断信息。

predict(object, newdata=data.frame) ¶

提供的数据框必须具有与原始数据框具有相同标签的变量。该值是与 data.frame 中的决定变量值对应的预测值向量或矩阵。

print(object) ¶

打印对象的简洁版本。最常隐式使用。

residuals(object) ¶

提取（残差的）矩阵，并根据需要加权。

简短格式：resid(object)。

step(object) ¶

通过添加或删除项并保留层次结构来选择合适的模型。返回在逐步搜索中发现的 AIC（赤池信息准则）值最小的模型。

summary(object) ¶

打印回归分析结果的综合摘要。

vcov(对象) ¶

返回已拟合模型对象的各个主要参数的协方差矩阵。

11.4 方差分析和模型比较 ¶

模型拟合函数 aov(公式, data=数据框) 以非常类似于函数 lm() 的方式在最简单的层面上操作，并且 用于提取模型信息的通用函数 表格中列出的大多数通用函数都适用。

需要注意的是，除了 aov() 之外，还可以分析具有多个误差层级的模型，例如分割小区实验或具有块间信息恢复的平衡不完全区组设计。模型公式

response ~ mean.formula + Error(strata.formula)

指定了一个多层级实验，其误差层级由 层级公式 定义。在最简单的情况下，层级公式 只是一个因子，当它定义一个两层级实验时，即在因子的层级之间和内部。

例如，对于所有决定变量因子，类似于

> fm <- aov(yield ~ v + n*p*k + Error(farms/blocks), data=farm.data)

中的模型公式通常用于描述具有均值模型 v + n*p*k 和三个误差层级的实验，即“农场间”、“农场内，区组间”和“区组内”。

• ANOVA 表格

> anova(fitted.model.1, fitted.model.2, ...)

11.5 更新拟合模型 ¶

update() 函数在很大程度上是一个便利函数，它允许拟合一个与之前拟合的模型不同的模型，通常只是增加或删除一些项。它的形式是

> new.model <- update(old.model, new.formula)

在 new.formula 中，由一个句点组成的特殊名称“.”， 只能用于表示“旧模型公式的对应部分”。例如，

> fm05 <- lm(y ~ x1 + x2 + x3 + x4 + x5, data = production)
> fm6  <- update(fm05, . ~ . + x6)
> smf6 <- update(fm6, sqrt(.) ~ .)

将拟合一个五变量多元回归，其中变量（可能）来自数据框 production，拟合一个包含第六个回归变量的附加模型，并拟合一个响应应用了平方根变换的模型的变体。

特别注意，如果在对模型拟合函数的原始调用中指定了 data= 参数，则此信息将通过拟合模型对象传递给 update() 及其关联函数。

名称“.”还可以在其他上下文中使用，但含义略有不同。例如

> fmfull <- lm(y ~ . , data = production)

将拟合一个响应为 y 和回归变量为数据框 production 中所有其他变量的模型。

用于探索模型增量序列的其他函数是 add1()、drop1() 和 step()。 这些名称很好地提示了它们的目的，但有关完整详细信息，请参阅在线帮助。

11.6 广义线性模型 ¶

广义线性建模是线性模型的开发，它以简洁直接的方式适应非正态响应分布和线性变换。广义线性模型可以通过以下一系列假设来描述

• 存在感兴趣的响应 y 和刺激变量 x_1、x_2、…，其值影响响应的分布。
• 刺激变量通过 一个线性函数（仅此一个）影响 y 的分布。此线性函数称为 线性预测器，通常写为

  eta = beta_1 x_1 + beta_2 x_2 + ... + beta_p x_p,
  

  因此，当且仅当 beta_i 为零时，x_i 对 y 的分布没有影响。

• y 的分布形式为

  f_Y(y; mu, phi)
    = exp((A/phi) * (y lambda(mu) - gamma(lambda(mu))) + tau(y, phi))
  

  其中 phi 是 尺度参数（可能已知），并且对于所有观测值都是常数，A 表示先验权重，假设已知但可能随观测值而变化，并且 $\mu$ 是 y 的均值。因此，假设 y 的分布由其均值和可能的尺度参数决定。

• 均值 mu 是线性预测器的平滑可逆函数

  mu = m(eta),    eta = m^{-1}(mu) = ell(mu)
  

  并且此逆函数 ell() 称为 链接函数。

这些假设足够宽松，可以涵盖统计实践中有用的广泛模型，但又足够严格，可以开发出一种统一的估计和推理方法，至少是近似的。读者可以参阅任何当前关于该主题的参考著作以获取完整详细信息，例如 McCullagh & Nelder (1989) 或 Dobson (1990)。

• 族
• glm() 函数

> fitted.model <- glm(formula, family=family.generator, data=data.frame)

> fm <- glm(y ~ x1 + x2, family = gaussian, data = sales)

> fm <- lm(y ~ x1+x2, data=sales)

> kalythos <- data.frame(x = c(20,35,45,55,70), n = rep(50,5),
                         y = c(6,17,26,37,44))

> kalythos$Ymat <- cbind(kalythos$y, kalythos$n - kalythos$y)

> fmp <- glm(Ymat ~ x, family = binomial(link=probit), data = kalythos)
> fml <- glm(Ymat ~ x, family = binomial, data = kalythos)

> summary(fmp)
> summary(fml)

> ld50 <- function(b) -b[1]/b[2]
> ldp <- ld50(coef(fmp)); ldl <- ld50(coef(fml)); c(ldp, ldl)

> fmod <- glm(y ~ A + B + x, family = poisson(link=sqrt),
              data = worm.counts)

> nlfit <- glm(y ~ x1 + x2 - 1,
               family = quasi(link=inverse, variance=constant),
               data = biochem)

11.7 非线性最小二乘法和最大似然模型 ¶

某些形式的非线性模型可以通过广义线性模型 (glm()) 进行拟合。但在大多数情况下，我们必须将非线性曲线拟合问题当作非线性优化问题来处理。R 的非线性优化例程是 optim()、nlm() 和 nlminb()， 我们寻求最小化某些拟合度不足指标的参数值，它们通过迭代尝试各种参数值来实现这一点。例如，与线性回归不同，无法保证该过程会收敛于令人满意的估计值。所有方法都需要关于要尝试的参数值的初始猜测，并且收敛可能极大地取决于起始值的质量。

• 最小二乘法
• 最大似然

> x <- c(0.02, 0.02, 0.06, 0.06, 0.11, 0.11, 0.22, 0.22, 0.56, 0.56,
         1.10, 1.10)
> y <- c(76, 47, 97, 107, 123, 139, 159, 152, 191, 201, 207, 200)

> fn <- function(p) sum((y - (p[1] * x)/(p[2] + x))^2)

> plot(x, y)
> xfit <- seq(.02, 1.1, .05)
> yfit <- 200 * xfit/(0.1 + xfit)
> lines(spline(xfit, yfit))

> out <- nlm(fn, p = c(200, 0.1), hessian = TRUE)

> sqrt(diag(2*out$minimum/(length(y) - 2) * solve(out$hessian)))

> plot(x, y)
> xfit <- seq(.02, 1.1, .05)
> yfit <- 212.68384222 * xfit/(0.06412146 + xfit)
> lines(spline(xfit, yfit))

> df <- data.frame(x=x, y=y)
> fit <- nls(y ~ SSmicmen(x, Vm, K), df)
> fit
Nonlinear regression model
  model:  y ~ SSmicmen(x, Vm, K)
   data:  df
          Vm            K
212.68370711   0.06412123
 residual sum-of-squares:  1195.449
> summary(fit)

Formula: y ~ SSmicmen(x, Vm, K)

Parameters:
    Estimate Std. Error t value Pr(>|t|)
Vm 2.127e+02  6.947e+00  30.615 3.24e-11
K  6.412e-02  8.281e-03   7.743 1.57e-05

Residual standard error: 10.93 on 10 degrees of freedom

Correlation of Parameter Estimates:
      Vm
K 0.7651

> x <- c(1.6907, 1.7242, 1.7552, 1.7842, 1.8113,
         1.8369, 1.8610, 1.8839)
> y <- c( 6, 13, 18, 28, 52, 53, 61, 60)
> n <- c(59, 60, 62, 56, 63, 59, 62, 60)

> fn <- function(p)
   sum( - (y*(p[1]+p[2]*x) - n*log(1+exp(p[1]+p[2]*x))
           + log(choose(n, y)) ))

> out <- nlm(fn, p = c(-50,20), hessian = TRUE)

> sqrt(diag(solve(out$hessian)))

11.8 一些非标准模型 ¶

我们用简要介绍 R 中可用于特殊回归和数据分析问题的其他一些工具来结束本章。

• 混合模型。推荐的 nlme 包提供了函数 lme() 和 nlme() ，用于线性混合效应模型和非线性混合效应模型，即某些系数对应于随机效应的线性和非线性回归。这些函数大量使用公式来指定模型。
• 局部逼近回归。 loess() 函数通过使用局部加权回归来拟合非参数回归。此类回归对于突出杂乱数据中的趋势或对数据进行简化以深入了解大型数据集非常有用。

  函数 loess 在标准包 stats 中，与投影追踪回归的代码一起使用。

• 稳健回归。 有几个函数可用于拟合回归模型，以抵抗数据中极端异常值的影响。推荐包 MASS 中的函数 lqs 为高抗性拟合提供了最先进的算法。在包中提供了不太抗性但统计上更有效的方法，例如包 MASS 中的函数 rlm 。
• 加性模型。 此技术旨在从确定变量的平滑加性函数（通常每个确定变量一个）构建回归函数。包 acepack 中的函数 avas 和 ace 以及包 mda 中的函数 bruto 和 mars 提供了 R 中用户贡献包中这些技术的示例。扩展是 广义加性模型，在用户贡献包 gam 和 mgcv 中实现。
• 基于树的模型。 与为预测或解释寻求明确的全局线性模型不同，基于树的模型试图在确定变量的关键点递归地对数据进行二分，以便最终将数据划分为组，这些组在内部尽可能同质，在组之间尽可能异质。结果通常会导致其他数据分析方法无法产生的见解。

  模型再次以普通线性模型形式指定。模型拟合函数是 tree()， 但许多其他通用函数（如 plot() 和 text()）非常适合以图形方式显示基于树的模型拟合的结果。

  树模型可通过用户贡献包 rpart 和 tree 在 R 中获得。

12.1 高级绘图命令 ¶

高级绘图函数旨在生成作为函数参数传递的数据的完整绘图。在适当的情况下，会自动生成坐标轴、标签和标题（除非您另有要求）。高级绘图命令始终会启动一个新绘图，必要时会擦除当前绘图。

• plot() 函数
• 显示多元数据
• 显示图形
• 高级绘图函数的参数

> pairs(X)

> coplot(a ~ b | c)

> coplot(a ~ b | c + d)

12.2 低级绘图命令 ¶

有时，高级绘图函数无法生成您想要的绘图类型。在这种情况下，可以使用低级绘图命令向当前绘图添加额外信息（例如点、线或文本）。

一些更有用的低级绘图函数是

points(x, y) ¶

lines(x, y)

向当前绘图添加点或连接线。plot() 的 type= 参数也可以传递给这些函数（并且对于 points() 默认为 "p"，对于 lines() 默认为 "l"）。

text(x, y, labels, …) ¶

在由 x, y 给出的点处向绘图添加文本。通常，labels 是一个整数或字符向量，在这种情况下，labels[i] 绘制在点 (x[i], y[i]) 处。默认值为 1:length(x)。

注意：此函数通常在以下序列中使用

> plot(x, y, type="n"); text(x, y, names)

图形参数 type="n" 会禁止点，但会设置轴，而 text() 函数会提供特殊字符，如字符向量 names 为点指定的特殊字符。

abline(a, b) ¶

abline(h=y)

abline(v=x)

abline(lm.obj)

向当前绘图添加一条斜率为 b、截距为 a 的线。h=y 可用于指定水平线穿过绘图的 y 坐标，v=x 同理用于指定垂直线的 x 坐标。此外，lm.obj 可以是长度为 2 的 coefficients 组件的列表（例如模型拟合函数的结果），按顺序将其视为截距和斜率。

polygon(x, y, …) ¶

绘制由 (x, y) 中的有序顶点定义的多边形，并（可选）用阴影线填充它，或者如果图形设备允许填充图形，则填充它。

legend(x, y, legend, …) ¶

在指定位置向当前绘图添加图例。绘图字符、线型、颜色等通过字符向量 legend 中的标签进行识别。还必须给出至少一个其他参数 v（一个与 legend 长度相同的向量），其中包含绘图单元的相应值，如下所示

legend( , fill=v)

填充框的颜色

legend( , col=v)

绘制点或线的颜色

legend( , lty=v)

线条样式

legend( , lwd=v)

线条宽度

legend( , pch=v)

绘制字符（字符向量）

title(main, sub) ¶

在当前绘图顶部添加大字体标题 main，并在底部添加小字体副标题 sub（可选）。

axis(side, …) ¶

在当前绘图中添加一个轴，轴位于第一个参数指定的侧边（从底部顺时针计数，为 1 到 4）。其他参数控制轴在绘图中或旁边的位置，以及刻度位置和标签。在使用 axes=FALSE 参数调用 plot() 之后，此功能可用于添加自定义轴。

低级绘图函数通常需要一些定位信息（例如，x 和 y 坐标）来确定新绘图元素的位置。坐标以用户坐标给出，由先前的顶级图形命令定义，并根据提供的数据进行选择。

在需要 x 和 y 参数的地方，也可以只提供一个参数，该参数是一个列表，其中包含名为 x 和 y 的元素。类似地，具有两列的矩阵也是有效的输入。通过这种方式，可以使用诸如 locator()（见下文）之类的函数来交互式地指定绘图中的位置。

• 数学注释
• Hershey 矢量字体

> text(x, y, expression(paste(bgroup("(", atop(n, x), ")"), p^x, q^{n-x})))

> help(plotmath)
> example(plotmath)
> demo(plotmath)

> help(Hershey)
> demo(Hershey)
> help(Japanese)
> demo(Japanese)

12.3 与图形交互 ¶

R 还提供了一些函数，允许用户使用鼠标从绘图中提取或向绘图中添加信息。其中最简单的是 locator() 函数

locator(n, type) ¶

等待用户使用鼠标左键选择当前绘图上的位置。这将持续到选择 n（默认 512）个点，或按下另一个鼠标按钮。 type 参数允许在所选点处绘图，并且与高级图形命令的效果相同；默认是不绘图。 locator() 返回所选点的坐标，作为具有两个分量 x 和 y 的列表。

locator() 通常不带参数调用。当难以预先计算图形应该放置的位置时，它对于交互式选择诸如图例或标签等图形元素的位置特别有用。例如，要在远离点的附近放置一些信息性文本，可以使用以下命令

> text(locator(1), "Outlier", adj=0)

（如果当前设备（如 postscript）不支持交互式指向，则将忽略 locator()。）

identify(x, y, labels) ¶

允许用户通过绘制 labels 的相应分量（或如果 labels 不存在，则绘制点的索引号）来突出显示 x 和 y 定义的任何点（使用鼠标左键）。在按下另一个按钮时返回所选点的索引。

有时我们希望识别绘图上的特定点，而不是它们的位置。例如，我们可能希望用户从图形显示中选择一些感兴趣的观察结果，然后以某种方式处理该观察结果。给定两个数字向量 x 和 y 中的若干(x, y) 坐标，我们可以按如下方式使用 identify() 函数

> plot(x, y)
> identify(x, y)

identify() 函数本身不执行绘图，而只是允许用户移动鼠标指针并在某个点附近单击鼠标左键。如果鼠标指针附近有某个点，它将用其索引号（即它在 x/y 向量中的位置）标记在附近。或者，你可以使用一些信息字符串（例如案例名称）作为高亮，方法是将 labels 参数用于 identify()，或使用 plot = FALSE 参数完全禁用标记。当该进程终止（见上文）时，identify() 返回所选点的索引；你可以使用这些索引从原始向量 x 和 y 中提取所选点。

12.4 使用图形参数 ¶

在创建图形时，特别是出于演示或发布目的，R 的默认设置并不总是能完全产生所需内容。但是，你可以使用图形参数来自定义显示的几乎每个方面。R 维护了一个包含大量图形参数的列表，这些参数控制着线条样式、颜色、图形排列和文本对齐等许多内容。每个图形参数都有一个名称（例如“col”，它控制颜色）和一个值（例如颜色编号）。

为每个活动设备维护一个单独的图形参数列表，并且每个设备在初始化时都有一组默认参数。图形参数可以通过两种方式设置：永久设置，影响访问当前设备的所有图形函数；或临时设置，仅影响单个图形函数调用。

• 永久更改：par() 函数
• 临时更改：图形函数的参数

> oldpar <- par(col=4, lty=2)
  ... plotting commands ...
> par(oldpar)

> oldpar <- par(no.readonly=TRUE)
  ... plotting commands ...
> par(oldpar)

> plot(x, y, pch="+")

12.5 图形参数列表 ¶

以下部分详细介绍了许多常用的图形参数。par() 函数的 R 帮助文档提供了一个更简洁的摘要；这作为一种更详细的替代方案提供。

图形参数将以以下形式呈现

name=value

参数效果的描述。 name 是参数的名称，即在调用 par() 或图形函数时使用的参数名称。 value 是设置参数时可能使用的典型值。

请注意，axes 不是图形参数，而是几个 plot 方法的参数：请参阅 xaxt 和 yaxt。

• 图形元素
• 坐标轴和刻度线
• 图形边距
• 多图形环境

下一篇：多图环境，上一篇：轴和刻度标记，向上：图形参数列表   [目录][索引]

12.5.3 图形边距 ¶

R 中的单个绘图称为 figure，由一个 绘图区域 组成，该区域周围有边距（可能包含轴标签、标题等），并且（通常）由轴本身限定。

一个典型的图形是

控制图形布局的图形参数包括

mai=c(1, 0.5, 0.5, 0)

分别以英寸为单位测量的底部、左侧、顶部和右侧边距的宽度。

mar=c(4, 2, 2, 1)

类似于 mai，但测量单位是文本行。

mar 和 mai 是等效的，因为设置其中一个会更改另一个的值。为此参数选择的默认值通常过大；很少需要右侧边距，如果未使用标题，则也不需要顶部边距。底部和左侧边距必须足够大，以容纳轴和刻度标签。此外，默认值的选择不考虑设备表面的大小：例如，将 postscript() 驱动程序与 height=4 参数一起使用，将导致一个绘图，除非明确设置 mar 或 mai，否则该绘图大约有 50% 的边距。当使用多幅图形时（见下文），边距会减小，但当许多图形共享同一页面时，这可能不够。

---

上一篇：图形边距，向上：图形参数列表   [目录][索引]

12.5.4 多个图形环境 ¶

R 允许您在单页上创建 n 乘 m 个图形的阵列。每个图形都有自己的边距，并且图形阵列可以选择被 外边距 包围，如下面的图形所示。

与多个图形相关的图形参数如下

mfcol=c(3, 2)

mfrow=c(2, 4)

设置多个图形阵列的大小。第一个值是行数；第二个值是列数。这两个参数之间的唯一区别在于设置 mfcol 会按列填充图形；mfrow 按行填充。

图中的布局可以通过设置 mfrow=c(3,2) 创建；该图形显示在绘制了四个图后的页面。

设置其中任何一个都可以减小符号和文本的基本大小（由 par("cex") 和设备的点大小控制）。在恰好有两行两列的布局中，基本大小减小了 0.83 倍：如果行或列有三个或更多，则减小因子为 0.66。

mfg=c(2, 2, 3, 2)

在多个图形环境中当前图形的位置。前两个数字是当前图形的行和列；后两个数字是多个图形阵列中的行数和列数。设置此参数可在阵列中的图形之间跳转。您甚至可以使用与同一页面上大小不等的图形的 真实 值不同的值作为后两个数字。

fig=c(4, 9, 1, 4)/10

当前图形在页面上的位置。值分别是页面左、右、下和上边缘的位置，以从左下角测量的页面百分比表示。示例值将用于页面右下角的图形。设置此参数可在页面内任意放置图形。如果您想将图形添加到当前页面，也请使用 new=TRUE（与 S 不同）。

oma=c(2, 0, 3, 0)

omi=c(0, 0, 0.8, 0)

外边距的大小。与 mar 和 mai 类似，第一个测量文本行，第二个测量英寸，从下边距开始，顺时针进行。

外边距对于页面标题等特别有用。可以使用 mtext() 函数将文本添加到外边距，其参数 outer=TRUE。但是，默认情况下没有外边距，因此必须使用 oma 或 omi 显式创建。

可以使用 split.screen() 和 layout() 函数以及 grid 和 lattice 包生成更复杂的多个图形排列。

---

12.6 设备驱动程序 ¶

R 可以在几乎任何类型的显示器或打印设备上生成图形（质量等级不同）。但在开始之前，R 需要知道它处理的是哪种类型的设备。这可以通过启动设备驱动程序来完成。设备驱动程序的目的是将 R 中的图形指令（例如“绘制一条线”）转换为特定设备可以理解的形式。

通过调用设备驱动程序函数来启动设备驱动程序。每个设备驱动程序都有一个这样的函数：键入 help(Devices) 以获取它们的完整列表。例如，发出命令

> postscript()

将导致所有未来的图形输出以 PostScript 格式发送到打印机。一些常用的设备驱动程序是

X11() ¶

用于类 Unix 系统上的 X11 窗口系统

windows() ¶

用于 Windows

quartz() ¶

用于 macOS

postscript() ¶

用于在 PostScript 打印机上打印或创建 PostScript 图形文件。

pdf() ¶

生成 PDF 文件，也可以将其包含在 PDF 文件中。

png() ¶

生成位图 PNG 文件。（并非始终可用：请参阅其帮助页面。）

jpeg() ¶

生成位图 JPEG 文件，最适合用于 image 图表。（并非始终可用：请参阅其帮助页面。）

使用完设备后，务必通过发出以下命令终止设备驱动程序

> dev.off()

这可确保设备干净地完成；例如，在硬拷贝设备的情况下，这可确保完成每页并将其发送到打印机。（这将在会话正常结束时自动发生。）

• 排版文档的 PostScript 图表
• 多个图形设备

> postscript("file.ps", horizontal=FALSE, height=5, pointsize=10)

> postscript("plot1.eps", horizontal=FALSE, onefile=FALSE,
             height=8, width=6, pointsize=10)

12.7 动态图形 ¶

R 没有动态或交互图形的内置功能，例如旋转点云或“刷选”（交互式突出显示）点。但是，Swayne、Cook 和 Buja 提供的系统 GGobi 中提供了广泛的动态图形功能，可从以下位置获取：

http://ggobi.org/

并且可以通过包 rggobi 从 R 中访问，该包在 http://ggobi.org/rggobi.html 中进行了描述。

此外，包 rgl 提供了与 3D 图形（例如曲面）交互的方法。

13.1 标准软件包 ¶

标准（或 base）软件包被认为是 R 源代码的一部分。它们包含使 R 能够工作的基本函数，以及本手册中描述的数据集和标准统计和图形函数。它们应在任何 R 安装中自动可用。请参阅 R 常见问题解答 中的 R 软件包，以获取完整列表。

13.2 贡献的软件包和 CRAN ¶

R 有成千上万个由不同作者编写的贡献包。其中一些包实现了专门的统计方法，另一些包提供了对数据或硬件的访问，还有一些包旨在补充教科书。一些（推荐包）随 R 的每个二进制发行版一起分发。大多数包可从 CRAN（https://CRAN.R-project.org/ 及其镜像）和其他存储库（如 Bioconductor (https://www.bioconductor.org/））下载。R 常见问题解答包含 CRAN 包在发布时的列表，但可用包的集合经常变化。

13.3 命名空间 ¶

包有命名空间，它可以做三件事：允许包编写者隐藏仅供内部使用的函数和数据，防止当用户（或其他包编写者）选择与包中名称冲突的名称时函数中断，并提供一种在特定包中引用对象的方法。

例如，t() 是 R 中的转置函数，但用户可以定义自己的名为 t 的函数。命名空间可以防止用户的定义优先，并破坏尝试转置矩阵的每个函数。

有两个运算符可用于命名空间。双冒号运算符 :: 从特定命名空间中选择定义。在上面的示例中，转置函数始终可用作 base::t，因为它是在 base 包中定义的。只有从包中导出的函数才能通过这种方式检索。

三冒号运算符 ::: 可能出现在 R 代码中的几个地方：它就像双冒号运算符，但还可以访问隐藏的对象。用户更有可能使用 getAnywhere() 函数，该函数搜索多个包。

包通常是相互依赖的，加载一个包可能会导致自动加载其他包。上面描述的冒号运算符还将导致自动加载关联的包。当自动加载具有命名空间的包时，它们不会添加到搜索列表中。

14.1 文件和目录 ¶

有许多函数可以操作文件和目录。以下是其中一些常用函数的指针。

要创建（空）文件或目录，请使用 file.create 或 dir.create。（它们是 POSIX 实用程序 touch 和 mkdir 的类似物。）有关 R 会话目录中的临时文件和目录，请参见 tempfile。

可以通过 file.remove 或 unlink 删除文件：后者可以删除目录树。

对于目录列表，请使用 list.files（也可作为 dir）或 list.dirs。这些可以使用正则表达式选择文件：要通过通配符选择，请使用 Sys.glob。

可以通过 file.info 查找有关文件路径的许多类型的信息（例如，它是否是文件或目录）。

有几种方法可以找出文件是否“存在”（文件可以存在于文件系统中，但当前用户不可见）。有函数 file.exists、file.access 和 file_test，其中包含此测试的各种版本：file_test 是 POSIX test 命令的版本，适用于熟悉 shell 脚本的人员。

函数 file.copy 是 POSIX 命令 cp 的 R 类似物。

可以通过 file.choose 交互式地选择文件：Windows 端口具有更通用的函数 choose.files 和 choose.dir，并且 tcltk 包中也有类似的函数：tk_choose.files 和 tk_choose.dir。

函数 file.show 和 file.edit 将以适合 R 端口的方式显示和编辑一个或多个文件，如果正在使用控制台（例如 Windows 上的 RGui 或 macOS 上的 R.app），则使用控制台的功能。

文件系统中对 链接 有一定的支持：请参阅函数 file.link 和 Sys.readlink。

14.2 文件路径 ¶

除了少数例外情况外，R 依赖于底层操作系统函数来处理文件路径。这方面的一些内容允许依赖于操作系统，甚至依赖于操作系统的版本。有关操作系统应如何解释文件路径的 POSIX 标准，许多 R 用户都假定符合 POSIX：但 Windows 并未声称符合该标准，而其他操作系统可能不太完全符合该标准。

以下是使用文件路径时遇到的一些问题。

• POSIX 文件系统区分大小写，因此 foo.png 和 Foo.PNG 是不同的文件。但是，Windows 和 macOS 的默认设置是不区分大小写的，而 FAT 文件系统（通常用于可移动存储）通常不区分大小写（并且所有文件路径都可以映射为小写）。
• 几乎所有 Windows 操作系统服务都支持使用斜杠或反斜杠作为文件路径分隔符，并且 R 将已知的例外转换为 Windows 所需的形式。
• 带有尾部斜杠的文件路径的行为取决于操作系统。此类路径在 Windows 上无效，不应指望它们起作用。POSIX-2008 要求此类路径仅匹配目录，但早期版本允许它们也匹配文件。因此，最好避免使用它们。
• 文件路径中出现多个斜杠（例如 /abc//def）在 POSIX 文件系统中是有效的，并且被视为只有一个斜杠。它们通常被 Windows 操作系统函数接受。但是，前导双斜杠可能具有不同的含义。
• Windows 的 UNC 文件路径（例如 \\server\dir1\dir2\file 和 \\?\UNC\server\dir1\dir2\file）不受支持，但它们可能在某些 R 函数中起作用。POSIX 文件系统被允许特殊地处理前导双斜杠。
• Windows 允许包含驱动器且相对于驱动器上当前目录的文件路径，例如 d:foo/bar 指的是 d:/a/b/c/foo/bar，如果 驱动器 d: 上的 当前目录是 /a/b/c。这些路径应能起作用，但使用绝对路径更安全。

函数 basename 和 dirname 选择文件路径的各个部分：从组件组装文件路径的推荐方法是 file.path。函数 pathexpand 执行“波浪线扩展”，用主目录（当前用户的主目录，可能还有其他用户的主目录）的值进行替换。

在具有链接的文件系统上，单个文件可以通过许多文件路径进行引用。函数 normalizePath 将找到一个规范文件路径。

Windows 有短（“8.3”）和长文件名概念：normalizePath 将返回一个使用长文件名的绝对路径，shortPathName 将返回一个使用短文件名的版本。后者不包含空格，并使用反斜杠作为分隔符，因此有时可用于从 R 导出名称。

文件 权限 是一个相关主题。R 支持所有者/组/所有人的读/写/执行权限的 POSIX 概念，但这可能仅在文件系统上得到部分支持，例如在 Windows 上仅识别只读文件（对于运行 R 会话的帐户）。访问控制列表 (ACL) 用于多个文件系统，但没有商定的标准，R 也没有控制它们的工具。使用 Sys.chmod 更改权限。

14.3 系统命令 ¶

函数 system 和 system2 用于调用系统命令并选择性地收集其输出。 system2 更通用一些，但其主要优势在于使用它可以更轻松地编写跨平台代码。

system 在 Windows 上的行为与其他操作系统不同（因为同名的 API C 调用也是如此）。在其他地方，它调用 shell 来运行命令：R 的 Windows 端口有一个函数 shell 来执行此操作。

要找出操作系统是否包含某个命令，请使用 Sys.which，它尝试以跨平台的方式执行此操作（不幸的是，它不是标准操作系统服务）。

函数 shQuote 会根据当前操作系统对命令所需的文件路径进行引用。

14.4 压缩和存档 ¶

最近版本的 R 具有广泛的工具来读取和写入压缩文件，通常是透明的。在 R 中读取文件在很大程度上是由连接完成的，而 file 函数用于打开与文件（或 URL）的连接，并且能够从文件的“魔术”头识别所使用的压缩。

支持时间最长的压缩类型是 gzip 压缩，它仍然是一个很好的通用折衷方案。也可以读取由早期 Unix compress 实用程序压缩的文件，但这些文件变得越来越少见。另外两种形式的压缩，即 bzip2 和 xz 实用程序的压缩，也可用。这些通常会以较慢的解压缩速度和更慢的压缩速度为代价实现更高的压缩率（取决于文件，高得多）。

xz 和 lzma 压缩之间存在一些混淆（请参阅 https://en.wikipedia.org/wiki/Xz 和 https://en.wikipedia.org/wiki/LZMA）：R 可以读取大多数版本压缩的文件两者。

文件存档是包含文件集合的单个文件，最常见的是“tarball”和 zip 文件，用于分发 R 包。R 可以列出和解包两者（请参阅函数 untar 和 unzip），并创建两者（对于 zip，借助于外部程序）。