R 数据导入/导出 ¶

1.1 导入 ¶

导入 R 的最简单的数据形式是简单的文本文件，对于小型或中型问题，这通常是可以接受的。从文本文件导入的主要函数是 scan，它也是 类似电子表格的数据 中讨论的大多数更方便函数的基础。

然而，所有统计顾问都熟悉客户提供一个包含数据的存储器（以前是软盘或 CD-R），数据以某种专有二进制格式存储，例如“Excel 电子表格”或“SPSS 文件”。通常最简单的方法是使用源应用程序将数据导出为文本文件（统计顾问会在他们的计算机上保存最常用的应用程序副本以备不时之需）。但是，这并不总是可行，从其他统计系统导入讨论了从 R 直接访问此类文件有哪些可用工具。对于 Excel 电子表格，可用的方法总结在读取 Excel 电子表格中。

在少数情况下，数据以二进制形式存储以实现紧凑性和快速访问。我们多次看到的一个应用是图像数据，它通常以内存中表示的字节流的形式存储，可能前面有一个标题。此类数据格式在二进制文件和二进制连接中讨论。

对于更大的数据库，通常使用数据库管理系统 (DBMS) 来处理数据。同样可以选择使用 DBMS 提取一个普通文件，但对于许多此类 DBMS，提取操作可以直接从 R 包中完成：参见关系数据库。通过网络连接导入数据在网络接口中讨论。

• 编码

text.Rd: UTF-8 Unicode English text
text2.dat: ISO-8859 English text
text3.dat: Little-endian UTF-16 Unicode English character data,
   with CRLF line terminators
intro.dat: UTF-8 Unicode text
intro.dat: UTF-8 Unicode (with BOM) text

1.2 导出到文本文件 ¶

从 R 导出结果通常是一项不太有争议的任务，但仍然存在一些陷阱。会有一个目标应用程序，并且文本文件通常是最方便的交换媒介。（如果需要二进制文件，请参阅 二进制文件。）

函数 cat 是导出数据的函数的基础。它接受一个 file 参数，而 append 参数允许通过对 cat 的连续调用来写入文本文件。更好的是，特别是如果要多次执行此操作，可以打开一个用于写入或追加的 file 连接，并将 cat 写入该连接，然后 close 它。

最常见的任务是将矩阵或数据框写入文件，作为数字的矩形网格，可能带有行和列标签。这可以通过 write.table 和 write 函数来完成。函数 write 只会以指定的列数写入矩阵或向量（并转置矩阵）。函数 write.table 更方便，它会写入数据框（或可以强制转换为数据框的对象），并带有行和列标签。

将数据框写入文本文件时，需要考虑一些问题。

1. 精度

   这些函数对实数/复数的大多数转换都是以全精度进行的，但由 write 进行的转换受 options(digits) 的当前设置控制。为了获得更多控制，请对数据框使用 format，可能需要逐列进行。

2. 标题行

   R 倾向于让标题行没有行名的条目，因此文件看起来像

                   dist    climb   time
   Greenmantle     2.5     650     16.083
      ...
   

   其他一些系统需要一个（可能是空的）行名条目，这是 write.table 在指定参数 col.names = NA 时将提供的。Excel 就是这样的系统之一。

3. 分隔符

   在文件中使用的常见字段分隔符是逗号，因为在英语国家，逗号不太可能出现在任何字段中。此类文件被称为 CSV（逗号分隔值）文件，包装函数 write.csv 提供了适当的默认值。在某些地区，逗号用作小数点（在 write.table 中通过 dec = "," 设置），而 CSV 文件使用分号作为字段分隔符：使用 write.csv2 获取适当的默认值。有一个用于 CSV 文件的 IETF 标准（它规定使用逗号和 CRLF 行结尾，为此使用 eol = "\r\n"），RFC4180（参见 https://www.rfc-editor.org/rfc/rfc4180），但在实践中更重要的是文件是否可以被其目标应用程序读取。

   使用分号或制表符 (sep = "\t") 可能是最安全的选项。

4. 缺失值

   默认情况下，缺失值输出为 NA，但这可以通过参数 na 更改。请注意，NaN 被 write.table 视为 NA，但 cat 或 write 不会。

5. 引用字符串

   默认情况下，字符串会被引用（包括行名和列名）。参数 quote 控制是否引用字符和因子变量：某些程序（例如 Mondrian (https://en.wikipedia.org/wiki/Mondrian_(software))）不接受带引号的字符串。

   如果字符串包含嵌入的引号，则需要小心。三种有用的形式是

   > df <- data.frame(a = I("a \" quote"))
   > write.table(df)
   "a"
   "1" "a \" quote"
   > write.table(df, qmethod = "double")
   "a"
   "1" "a "" quote"
   > write.table(df, quote = FALSE, sep = ",")
   a
   1,a " quote
   

   第二种形式是电子表格常用的转义形式。

6. 编码

   文本文件不包含关于其编码的元数据，因此对于非-ASCII 数据，文件需要针对要读取它的应用程序进行定位。所有这些函数都可以写入连接，这允许为文件指定编码，并且write.table有一个fileEncoding参数来简化此操作。

   困难的部分是知道要使用什么文件编码。对于在 Windows 上使用，最好使用 Windows 所谓的“Unicode”²，即"UTF-16LE"。使用 UTF-8 是制作可移植文件的良好方法，这些文件不会轻易与任何其他编码混淆，但即使 macOS 应用程序（其中 UTF-8 是系统编码）也可能无法识别它们，而 Windows 应用程序最不可能识别它们。显然，Excel:mac 2004/8 预计.csv文件使用"macroman"编码（早期版本的 Mac OS 中使用的编码）。

包 MASS 中的函数 write.matrix 提供了一个专门的接口用于写入矩阵，可以选择以块的形式写入它们，从而减少内存使用量。

可以使用 sink 将标准 R 输出重定向到文件，从而捕获（可能隐式）print 语句的输出。这通常不是最有效的方法，并且可能需要增加 options(width) 设置。

包 foreign 中的函数 write.foreign 使用 write.table 生成文本文件，并写入一个代码文件，该文件将读取此文本文件到另一个统计软件包中。目前支持导出到 SAS、SPSS 和 Stata。

1.3 XML ¶

从文本文件读取数据时，用户有责任了解并指定用于创建该文件的约定，例如注释字符、是否存在标题行、值分隔符、缺失值的表示（等等），如导出到文本文件中所述。一种可以用来描述内容和内容结构的标记语言可以使文件自描述，这样就不需要向读取数据的软件提供这些详细信息。

可扩展标记语言（更常见的是简称为XML）可用于提供这种结构，不仅适用于标准数据集，还适用于更复杂的数据结构。 XML 正在变得非常流行，并正在成为通用数据标记和交换的标准。 它正在被不同的社区用来描述地理数据，例如地图、图形显示、数学等等。

XML 提供了一种指定文件编码的方式，例如

<?xml version="1.0" encoding="UTF-8"?>

虽然它并不强制要求。

XML 包提供了在 R 中读取和写入 XML 文档的一般功能。 CRAN 上的 StatDataML 包是建立在 XML 之上的一个示例。 libxml2 C 库的另一个接口由 xml2 包提供。

yaml 是另一种用于结构化文本数据的系统，重点是人类可读性：它由 yaml 包支持。

2.1 read.table 的变体 ¶

函数 read.table 是读取矩形数据网格最方便的方法。由于可能性很多，还有其他几个函数调用 read.table 但更改了一组默认参数。

注意，read.table 是读取非常大的数值矩阵的低效方法：请参见下面的 scan。

需要考虑的一些问题是

1. 编码

   如果文件包含非 ASCII 字符字段，请确保它以正确的编码读取。这主要是针对在 UTF-8 环境中读取 Latin-1 文件的问题，可以通过以下方式解决：

   read.table("file.dat", fileEncoding="latin1")
   

   请注意，这将在任何可以表示 Latin-1 字符串的环境中工作，但并非所有希腊语/俄语/中文/日语……环境。

2. 标题行

   我们建议您明确指定 header 参数，按照惯例，标题行只包含列的条目，而不包含行标签，因此比其余行少一个字段。（如果 R 看到这一点，它会设置 header = TRUE。）如果遇到一个文件，该文件包含一个（可能为空）用于行标签的标题字段，可以通过以下方式读取它：

   read.table("file.dat", header = TRUE, row.names = 1)
   

   列名可以通过 col.names 明确给出；明确的名称会覆盖标题行（如果有）。

3. 分隔符

   通常，查看文件将确定要使用的字段分隔符，但在使用空格分隔的文件中，可能需要在默认的 sep = ""（使用任何空格（空格、制表符或换行符）作为分隔符）之间进行选择，sep = " " 和 sep = "\t"。请注意，分隔符的选择会影响引号字符串的输入。

   如果您有一个包含空字段的制表符分隔文件，请务必使用 sep = "\t"。

4. 引用

   默认情况下，字符字符串可以用 ‘"’ 或 ‘'’ 引号括起来，在每种情况下，直到匹配的引号为止的所有字符都将被视为字符字符串的一部分。有效的引号字符集（可能为空）由 quote 参数控制。对于 sep = "\n"，默认值将更改为 quote = ""。

   如果没有指定分隔符字符，则可以在引号字符串中通过在引号之前立即加上 ‘\’ 来转义引号，C 语言风格。

   如果指定了分隔符字符，则可以在引号字符串中通过将引号加倍来转义引号，这在电子表格中很常见。例如

   'One string isn''t two',"one more"
   

   可以被

   read.table("testfile", sep = ",")
   

   读取。这在默认分隔符下不起作用。

5. 缺失值

   默认情况下，假设文件包含字符字符串 NA 来表示缺失值，但这可以通过 na.strings 参数更改，该参数是一个包含一个或多个缺失值字符表示的向量。

   数值列中的空字段也被视为缺失值。

   在数值列中，接受 NaN、Inf 和 -Inf 值。

6. 未填充的行

   从电子表格导出的文件通常会省略所有尾随的空字段（及其分隔符）。要读取此类文件，请设置 fill = TRUE。

7. 字符字段中的空格

   如果指定了分隔符，则字符字段中的前导和尾随空格将被视为字段的一部分。要删除空格，请使用参数 strip.white = TRUE。

8. 空行

   默认情况下，read.table 会忽略空行。这可以通过设置 blank.lines.skip = FALSE 来更改，这只有在与 fill = TRUE 结合使用时才有用，也许是为了使用空行来指示常规布局中的缺失情况。

9. 变量的类

   除非采取任何特殊措施，否则 read.table 会将所有列读取为字符向量，然后尝试为数据框中的每个变量选择合适的类。它依次尝试 logical、integer、numeric 和 complex，如果任何条目不缺失且无法转换，则继续进行。³ 如果所有这些都失败，则该变量将转换为因子。

   参数 colClasses 和 as.is 提供了更大的控制。指定 as.is = TRUE 将抑制将字符向量转换为因子（仅此而已）。使用 colClasses 允许为输入中的每一列设置所需的类：它将更快且使用更少的内存。

   请注意，colClasses 和 as.is 是针对 每列指定的，而不是针对 每变量指定的，因此包括行名列（如果有）。

10. 注释

    默认情况下，read.table 使用 ‘#’ 作为注释字符，如果遇到此字符（除了在引号字符串中），则忽略该行的其余部分。仅包含空格和注释的行将被视为空行。

    如果已知数据文件中没有注释，则使用 comment.char = "" 更安全（并且可能更快）。

11. 转义

    许多操作系统都有在文本文件中使用反斜杠作为转义字符的约定，但 Windows 没有（并在路径名中使用反斜杠）。在 R 中，是否将此类约定应用于数据文件是可选的。

    read.table 和 scan 都有一个逻辑参数 allowEscapes。默认情况下，此参数为 false，并且反斜杠仅在（如上所述的情况下）转义引号时被解释为转义字符。如果将其设置为 true，则会解释 C 样式转义，即控制字符 \a, \b, \f, \n, \r, \t, \v 以及八进制和十六进制表示形式，例如 \040 和 \0x2A。任何其他转义字符都将被视为自身，包括反斜杠。请注意，Unicode 转义（例如 \uxxxx）永远不会被解释。

12. 编码

    这可以通过 fileEncoding 参数指定，例如

    fileEncoding = "UCS-2LE"    # Windows ‘Unicode’ files
    fileEncoding = "UTF-8"
    

    如果您（正确地）知道文件的编码，这几乎总是有效的。但是，我们知道一个例外，即带有 BOM 的 UTF-8 文件。有些人声称 UTF-8 文件永远不应该有 BOM，但一些软件（显然包括 Excel:mac）使用它们，并且许多类 Unix 操作系统不接受它们。因此，面对一个 file 报告为

    intro.dat: UTF-8 Unicode (with BOM) text
    

    的文件，它可以在 Windows 上通过

    read.table("intro.dat", fileEncoding = "UTF-8")
    

    读取，但在类 Unix 系统上可能需要

    read.table("intro.dat", fileEncoding = "UTF-8-BOM")
    

    (在 UTF-8 本地环境中，即使不指定编码，这也很可能有效。)

便捷函数 read.csv 和 read.delim 为 read.table 提供了适用于从英语地区电子表格中导出的 CSV 和制表符分隔文件参数。变体 read.csv2 和 read.delim2 适用于那些使用逗号作为小数点，并且（对于 read.csv2）使用分号分隔字段的地区。

如果 read.table 的选项指定不正确，错误消息通常会以以下形式出现：

Error in scan(file = file, what = what, sep = sep, : 
        line 1 did not have 5 elements

或

Error in read.table("files.dat", header = TRUE) : 
        more columns than column names

这可能提供足够的信息来找到问题，但辅助函数 count.fields 可以用来进一步调查。

读取大型数据网格时，效率可能很重要。指定 comment.char = ""、colClasses 作为每列的原子向量类型之一（逻辑、整数、数值、复数、字符或可能是原始类型），以及给出 nrows（要读取的行数，稍微高估比完全不指定要好）。请参阅后面部分的示例。

2.2 固定宽度格式文件 ¶

有时数据文件没有字段分隔符，但字段位于预先指定的列中。这在打孔卡时代非常普遍，现在有时仍然用于节省文件空间。

函数 read.fwf 提供了一种简单的方法来读取此类文件，指定一个字段宽度向量。该函数将文件作为整行读入内存，拆分结果字符字符串，写入一个临时制表符分隔文件，然后调用 read.table。这对于小文件来说已经足够了，但对于更复杂的文件，我们建议使用 perl 等语言的工具来预处理文件。

函数 read.fortran 是一个类似的函数，用于固定格式文件，使用 Fortran 风格的列规范。

2.3 数据交换格式 (DIF) ¶

有时用于类似电子表格数据的旧格式是 DIF，即数据交换格式。

函数 read.DIF 提供了一种简单的方法来读取此类文件。它接受类似于 read.table 的参数，用于为每列分配类型。

在 Windows 上，电子表格程序通常将复制到剪贴板的电子表格数据存储为此格式；read.DIF("clipboard") 可以直接从那里读取它。它在处理包含空单元格的电子表格方面比 read.table("clipboard") 更健壮。

2.4 直接使用 scan ¶

read.table 和 read.fwf 都使用 scan 读取文件，然后处理 scan 的结果。它们非常方便，但有时直接使用 scan 更好。

函数 scan 有很多参数，我们已经在 read.table 下介绍了大多数参数。最关键的参数是 what，它指定从文件中读取的变量模式列表。如果列表已命名，则名称将用于返回列表的组件。模式可以是数字、字符或复数，通常由示例指定，例如 0、"" 或 0i。例如

cat("2 3 5 7", "11 13 17 19", file="ex.dat", sep="\n")
scan(file="ex.dat", what=list(x=0, y="", z=0), flush=TRUE)

返回一个包含三个组件的列表，并丢弃文件中的第四列。

有一个函数 readLines，如果只想将整行读入 R 以供进一步处理，它会更方便。

scan 的一个常见用途是读取大型矩阵。假设文件 matrix.dat 只包含 200 x 2000 矩阵的数字。然后我们可以使用

A <- matrix(scan("matrix.dat", n = 200*2000), 200, 2000, byrow = TRUE)

在一个测试中，这花费了 1 秒（在 Linux 下，在同一台机器上的 Windows 下花费了 3 秒），而

A <- as.matrix(read.table("matrix.dat"))

花费了 10 秒（以及更多内存），并且

A <- as.matrix(read.table("matrix.dat", header = FALSE, nrows = 200,
                          comment.char = "", colClasses = "numeric"))

花费了 7 秒。差异几乎完全归因于读取 2000 个单独的短列的开销：如果它们的长度为 2000，scan 花费了 9 秒，而 read.table 花费了 18 秒（如果使用有效的方式，特别是指定 colClasses）和 125 秒（如果使用天真方式）。

请注意，计时可能取决于读取的类型和数据。考虑读取一百万个不同的整数

writeLines(as.character((1+1e6):2e6), "ints.dat")
xi <- scan("ints.dat", what=integer(0), n=1e6)   # 0.77s
xn <- scan("ints.dat", what=numeric(0), n=1e6)   # 0.93s
xc <- scan("ints.dat", what=character(0), n=1e6) # 0.85s
xf <- as.factor(xc)                              # 2.2s
DF <- read.table("ints.dat")                     # 4.5s

以及一小部分代码的百万个示例

code <- c("LMH", "SJC", "CHCH", "SPC", "SOM")
writeLines(sample(code, 1e6, replace=TRUE), "code.dat")
y <- scan("code.dat", what=character(0), n=1e6)  # 0.44s
yf <- as.factor(y)                               # 0.21s
DF <- read.table("code.dat")                     # 4.9s
DF <- read.table("code.dat", nrows=1e6)          # 3.6s

请注意，这些计时高度依赖于操作系统（Windows 中的基本读取速度至少是 Linux 速度的两倍）以及垃圾回收器的精确状态。

2.5 重新塑造数据 ¶

有时电子表格数据采用紧凑格式，其中包含每个受试者的协变量，然后是该受试者的所有观察结果。R 的建模函数需要将观察结果放在单个列中。考虑以下来自重复 MRI 脑部测量样本的数据

 Status   Age    V1     V2     V3    V4
      P 23646 45190  50333  55166 56271
     CC 26174 35535  38227  37911 41184
     CC 27723 25691  25712  26144 26398
     CC 27193 30949  29693  29754 30772
     CC 24370 50542  51966  54341 54273
     CC 28359 58591  58803  59435 61292
     CC 25136 45801  45389  47197 47126

有两个协变量，每个受试者最多有四个测量值。数据从 Excel 导出为文件 mr.csv。

我们可以使用 stack 来帮助操作这些数据以获得单个响应。

zz <- read.csv("mr.csv", strip.white = TRUE)
zzz <- cbind(zz[gl(nrow(zz), 1, 4*nrow(zz)), 1:2], stack(zz[, 3:6]))

结果为

      Status   Age values ind
X1         P 23646  45190  V1
X2        CC 26174  35535  V1
X3        CC 27723  25691  V1
X4        CC 27193  30949  V1
X5        CC 24370  50542  V1
X6        CC 28359  58591  V1
X7        CC 25136  45801  V1
X11        P 23646  50333  V2
...

函数 unstack 则执行相反的操作，可能对导出数据很有用。

另一种方法是使用函数 reshape，方法如下：

> reshape(zz, idvar="id",timevar="var",
  varying=list(c("V1","V2","V3","V4")),direction="long")
    Status   Age var    V1 id
1.1      P 23646   1 45190  1
2.1     CC 26174   1 35535  2
3.1     CC 27723   1 25691  3
4.1     CC 27193   1 30949  4
5.1     CC 24370   1 50542  5
6.1     CC 28359   1 58591  6
7.1     CC 25136   1 45801  7
1.2      P 23646   2 50333  1
2.2     CC 26174   2 38227  2
...

函数 reshape 的语法比 stack 更复杂，但可用于“长”形式数据，其中包含多个列（本例中只有一列）。使用 direction="wide"，reshape 还可以执行相反的转换。

有些人更喜欢包 reshape、reshape2 和 plyr 中的工具。

2.6 扁平列联表 ¶

以数组形式显示高维列联表通常很不方便。在分类数据分析中，此类信息通常以带边框的二维数组形式表示，其中前导行和列指定与单元格计数相对应的因子水平组合。这些行和列通常是“参差不齐”的，因为标签仅在更改时显示，并遵循明显的约定，即从上到下读取行，从左到右读取列。在 R 中，可以使用 ftable 创建此类“扁平”列联表， 该函数创建 "ftable" 类的对象，并具有相应的打印方法。

举个简单的例子，考虑 R 标准数据集 UCBAdmissions，它是一个三维列联表，结果是将 1973 年加州大学伯克利分校六个最大系的研究生申请者分类，按录取情况和性别分类。

> data(UCBAdmissions)
> ftable(UCBAdmissions)
                Dept   A   B   C   D   E   F
Admit    Gender                             
Admitted Male        512 353 120 138  53  22
         Female       89  17 202 131  94  24
Rejected Male        313 207 205 279 138 351
         Female       19   8 391 244 299 317

打印的表示形式显然比将数据显示为三维数组更有用。

还有一个函数 read.ftable 用于从文件中读取扁平化的列联表。 它有额外的参数来处理关于行和列变量名称和级别如何表示的变体。 read.ftable 的帮助页面有一些有用的示例。可以使用 as.table 将扁平化的表格转换为标准的数组形式的列联表。

请注意，扁平化的表格的特点是它们的行（以及可能还有列）标签的“参差不齐”显示。如果给出了行变量级别的完整网格，则应该使用 read.table 读取数据，并使用 xtabs 从中创建列联表。

3.1 EpiInfo、Minitab、S-PLUS、SAS、SPSS、Stata、Systat ¶

推荐的包 foreign 提供了从这些统计系统生成的 文件导入功能，以及导出到 Stata 的功能。在某些情况下，这些函数可能比 read.table 需要更少的内存。 write.foreign（参见 导出到文本文件）提供了一个导出机制，目前支持 SAS、SPSS 和 Stata。

EpiInfo 5 和 6 版本将数据存储在自描述的固定宽度文本格式中。 read.epiinfo 将从这些 .REC 文件中读取数据到 R 数据框中。EpiData 也以这种格式生成数据。

函数 read.mtp 导入 “Minitab 可移植工作表”。这将工作表的组件作为 R 列表返回。

函数 read.xport 读取 SAS 传输 (XPORT) 格式的文件，并返回一个数据框列表。如果您的系统上安装了 SAS，则可以使用函数 read.ssd 创建并运行一个 SAS 脚本，该脚本将 SAS 永久数据集 (.ssd 或 .sas7bdat) 保存为传输格式。然后它调用 read.xport 来读取结果文件。（包 Hmisc 有一个类似的函数 sas.get，也运行 SAS。）对于那些没有访问 SAS 但在 Windows 上运行的用户，可以使用 SAS 系统查看器（免费下载）打开 SAS 数据集并将其导出为例如 .csv 格式。

函数 read.S 可以读取由 S-PLUS 3.x、4.x 或 2000 在 (32 位) Unix 或 Windows 上生成的二进制对象（并且可以在不同的操作系统上读取它们）。它能够读取许多但不是所有 S 对象：特别是它可以读取向量、矩阵和数据框以及包含这些对象的列表。

函数 data.restore 读取 S-PLUS 数据转储（由 data.dump 创建），具有相同的限制（除了可以读取来自 Alpha 平台的转储）。应该可以读取由 S-PLUS 5.x 及更高版本使用 data.dump(oldStyle=T) 写入的数据转储。

如果您有权访问 S-PLUS，通常更可靠的是在 S-PLUS 中 dump 对象，并在 R 中 source 转储文件。对于 S-PLUS 5.x 及更高版本，您可能需要使用 dump(..., oldStyle=T)，并且为了读取非常大的对象，最好将转储文件用作批处理脚本，而不是使用 source 函数。

函数 read.spss 可以读取由 SPSS 中的 “save” 和 “export” 命令创建的文件。它返回一个列表，其中包含保存的数据集中每个变量的一个组件。 SPSS 变量的值标签可以选择性地转换为 R 因子。

SPSS 数据录入是一个用于创建数据录入表单的应用程序。默认情况下，它创建的数据文件包含 read.spss 无法处理的额外格式信息，但可以将数据导出为普通 SPSS 格式。

一些第三方应用程序声称以 “SPSS 格式” 生成数据，但格式有所不同：read.spss 可能能够或可能无法处理这些数据。

Stata .dta 文件是一种二进制文件格式。函数 read.dta 和 write.dta 可以读取和写入 Stata 5 到 12 版本的文件。Stata 变量的值标签可以选择性地转换为（和从）R 因子。对于 Stata 13 及更高版本，请参见 CRAN 包 readstata13 和 haven。

read.systat 读取那些 Systat SAVE 文件，这些文件是矩形数据文件 (mtype = 1)，在小端机器（例如来自 Windows）上写入。这些文件扩展名为 .sys 或（最近）.syd。

3.2 Octave ¶

Octave 是一个数值线性代数系统 (https://octave.org/)，包 foreign 中的函数 read.octave 可以读取使用 Octave 命令 save -ascii 创建的 Octave 文本数据格式文件，支持大多数常见的变量类型，包括标准原子类型（实数和复数标量、矩阵和 N 维数组、字符串、范围和布尔标量和矩阵）和递归类型（结构体、单元格和列表）。

4.1 为什么要使用数据库？ ¶

R 处理的数据类型存在限制。由于 R 操作的所有数据都驻留在内存中，并且在执行函数期间可以创建数据的多个副本，因此 R 不适合处理极其庞大的数据集。大小超过（几百）兆字节的数据对象会导致 R 耗尽内存，尤其是在 32 位操作系统上。

R 不容易支持对数据的并发访问。也就是说，如果多个用户访问（可能更新）相同的数据，则一个用户所做的更改将不会对其他用户可见。

R 支持数据的持久性，您可以从一个会话中保存数据对象或整个工作表并在后续会话中恢复它，但存储数据的格式是特定于 R 的，并且不容易被其他系统操作。

数据库管理系统 (DBMS)，特别是关系型数据库管理系统 (RDBMS)，旨在出色地完成所有这些任务。 它们的优势在于

1. 提供对大型数据库中选定部分的快速访问。
2. 提供强大的方法来汇总和交叉制表数据库中的列。
3. 以比电子表格和 R 数据框的矩形网格模型更组织的方式存储数据。
4. 来自运行在多个主机上的多个客户端的并发访问，同时对数据访问实施安全约束。
5. 能够充当各种客户端的服务器。

DBMS 可能用于的统计应用程序类型包括提取 10% 的数据样本，交叉制表数据以生成多维列联表，以及从数据库中逐组提取数据以进行单独分析。

越来越多的操作系统本身出于这些原因使用 DBMS，因此现在很可能您的（非 Windows）操作系统上已经安装了 DBMS。 Akonadi 用于 KDE4 存储个人信息。 包括 Mail 和 Address Book 在内的多个 macOS 应用程序使用 SQLite。

4.2 RDBMS 概述 ¶

传统上，存在大型（且昂贵）的商业 RDBMS（Informix；Oracle；Sybase；IBM 的 DB2；Microsoft SQL Server 在 Windows 上）以及学术和小型系统数据库（如 MySQL⁴、PostgreSQL、Microsoft Access 等），前者以对数据安全功能的更大重视为标志。 这条界线正在变得模糊，MySQL 和 PostgreSQL 拥有越来越多的高端功能，并且商业 DBMS 提供了免费的“express”版本。

还有其他常用的数据源，包括电子表格、非关系型数据库甚至文本文件（可能已压缩）。 开放数据库连接 (ODBC) 是使用所有这些数据源的标准。 它起源于 Windows（参见 https://docs.microsoft.com/en-us/sql/odbc/microsoft-open-database-connectivity-odbc），但也已在 Linux/Unix/macOS 上实现。

本章后面介绍的所有软件包都为客户端/服务器数据库提供客户端。数据库可以驻留在同一台机器上，也可以（更常见的是）远程驻留。有一个ISO标准（实际上有几个：SQL92 是 ISO/IEC 9075，也称为 ANSI X3.135-1992，以及正在使用的 SQL99）用于称为 SQL（结构化查询语言，有时发音为“sequel”：参见 Bowman et al. 1996 和 Kline 和 Kline 2001）的接口语言，这些 DBMS 在不同程度上支持该语言。

• SQL 查询
• 数据类型

SELECT State, Murder FROM USArrests WHERE Rape > 30 ORDER BY Murder

SELECT t.sch, c.meanses, t.sex, t.achieve
  FROM student as t, school as c WHERE t.sch = c.id

SELECT sex, COUNT(*) FROM student GROUP BY sex

SELECT sch, AVG(sestat) FROM student GROUP BY sch LIMIT 10

4.3 R 接口包 ¶

在 CRAN 上有几个包可以帮助 R 与数据库管理系统进行通信。它们提供了不同级别的抽象。一些包提供了将整个数据框复制到数据库和从数据库复制出来的方式。所有包都具有通过 SQL 查询在数据库中选择数据并以数据框的形式或分段（通常是按行分组）检索结果的功能。

除了 RODBC 之外，所有包都与一个数据库管理系统绑定，但有一个关于统一的“前端”包 DBI (https://developer.r-project.org/db/) 的提议，它与一个“后端”结合使用，其中最成熟的是 RMySQL。同样在 CRAN 上还有后端 ROracle、RPostgreSQL 和 RSQLite（它与捆绑的数据库管理系统 SQLite 协同工作，https://www.sqlite.org/index.html) 以及 RJDBC（它使用 Java，可以连接到任何具有 JDBC 驱动程序的数据库管理系统）。

PL/R (https://github.com/postgres-plr/plr) 是一个将 R 嵌入 PostgreSQL 的项目。

包 RMongo 为 ‘MongoDB’ (https://en.wikipedia.org/wiki/MongoDB) 数据库提供了一个 R 接口，该接口使用 JavaScript 而不是 SQL 进行查询。包 mongolite 是另一个使用 mongodb 的 C 驱动程序的客户端。

• 使用 DBI 的包
• 包 RODBC

> library(RMySQL) # will load DBI as well
## open a connection to a MySQL database
> con <- dbConnect(dbDriver("MySQL"), dbname = "test")
## list the tables in the database
> dbListTables(con)
## load a data frame into the database, deleting any existing copy
> data(USArrests)
> dbWriteTable(con, "arrests", USArrests, overwrite = TRUE)
TRUE
> dbListTables(con)
[1] "arrests"
## get the whole table
> dbReadTable(con, "arrests")
               Murder Assault UrbanPop Rape
Alabama          13.2     236       58 21.2
Alaska           10.0     263       48 44.5
Arizona           8.1     294       80 31.0
Arkansas          8.8     190       50 19.5
...
## Select from the loaded table
> dbGetQuery(con, paste("select row_names, Murder from arrests",
                        "where Rape > 30 order by Murder"))
   row_names Murder
1   Colorado    7.9
2    Arizona    8.1
3 California    9.0
4     Alaska   10.0
5 New Mexico   11.4
6   Michigan   12.1
7     Nevada   12.2
8    Florida   15.4
> dbRemoveTable(con, "arrests")
> dbDisconnect(con)

> library(RODBC)
## tell it to map names to l/case
> channel <- odbcConnect("testdb", uid="ripley", case="tolower")
## load a data frame into the database
> data(USArrests)
> sqlSave(channel, USArrests, rownames = "state", addPK = TRUE)
> rm(USArrests)
## list the tables in the database
> sqlTables(channel)
  TABLE_QUALIFIER TABLE_OWNER TABLE_NAME TABLE_TYPE REMARKS
1                              usarrests      TABLE        
## list it
> sqlFetch(channel, "USArrests", rownames = "state")
               murder assault urbanpop rape
Alabama          13.2     236       58 21.2
Alaska           10.0     263       48 44.5
    ...
## an SQL query, originally on one line
> sqlQuery(channel, "select state, murder from USArrests
           where rape > 30 order by murder")
       state murder
1 Colorado      7.9
2 Arizona       8.1
3 California    9.0
4 Alaska       10.0
5 New Mexico   11.4
6 Michigan     12.1
7 Nevada       12.2
8 Florida      15.4
## remove the table
> sqlDrop(channel, "USArrests")
## close the connection
> odbcClose(channel)

> library(RODBC)
> channel <- odbcConnectExcel("bdr.xls")
## list the spreadsheets
> sqlTables(channel)
  TABLE_CAT TABLE_SCHEM        TABLE_NAME   TABLE_TYPE REMARKS
1 C:\\bdr            NA           Sheet1$ SYSTEM TABLE      NA
2 C:\\bdr            NA           Sheet2$ SYSTEM TABLE      NA
3 C:\\bdr            NA           Sheet3$ SYSTEM TABLE      NA
4 C:\\bdr            NA Sheet1$Print_Area        TABLE      NA
## retrieve the contents of sheet 1, by either of
> sh1 <- sqlFetch(channel, "Sheet1")
> sh1 <- sqlQuery(channel, "select * from [Sheet1$]")

5.1 二进制数据格式 ¶

包 h5，Bioconductor 的 rhdf5，RNetCDF 和 ncdf4 在 CRAN 上提供了对 NASA 的 HDF5（分层数据格式，参见 https://www.hdfgroup.org/HDF5/）和 UCAR 的 netCDF 数据文件（网络通用数据格式，参见 https://www.unidata.ucar.edu/software/netcdf/）的接口。

这两个都是以数组为导向的方式存储科学数据的系统，包括描述、标签、格式、单位等。HDF5 还允许 组数组，R 接口将列表映射到 HDF5 组，并可以写入数字和字符向量以及矩阵。

NetCDF 的版本 4 格式（令人困惑的是，在 netCDF 4.1.1 及更高版本中实现，但在 4.0.1 中没有实现）包括使用各种 HDF5 格式。这由包 ncdf4 处理，而 RNetCDF 处理版本 3 文件。

支持这些格式的软件的可用性在一定程度上受平台限制，尤其是在 Windows 上。

5.2 dBase 文件 (DBF) ¶

dBase 是 Ashton-Tate 编写的 DOS 程序，后来被 Borland 收购，它具有一个流行的二进制平面文件格式，文件扩展名为 .dbf。它已被“Xbase”系列数据库采用，涵盖 dBase、Clipper、FoxPro 及其 Windows 等效项 Visual dBase、Visual Objects 和 Visual FoxPro（参见 https://www.clicketyclick.dk/databases/xbase/format/）。dBase 文件包含一个标题，然后是一系列字段，因此最类似于 R 数据框。数据本身以文本格式存储，可以包含字符、逻辑和数字字段，以及更高版本中的其他类型（例如，参见 https://www.loc.gov/preservation/digital/formats/fdd/fdd000325.shtml 和 https://www.clicketyclick.dk/databases/xbase/format/index.html）。

函数 read.dbf 和 write.dbf 提供了在所有 R 平台上读取和写入基本 DBF 文件的方法。对于 Windows 用户，包 RODBC 中的 odbcConnectDbase 提供了更全面的功能来读取 DBF 文件 通过 Microsoft 的 dBase ODBC 驱动程序（Visual FoxPro 驱动程序也可以通过 odbcDriverConnect 使用）。

7.1 连接类型 ¶

最熟悉的连接类型将是文件，文件连接由函数 file 创建。文件连接可以（如果操作系统允许特定文件）以文本或二进制模式打开以进行读取、写入或追加。实际上，文件可以同时打开以进行读取和写入，R 为读取和写入保留单独的文件位置。

请注意，默认情况下，连接在创建时不会打开。规则是，使用连接的函数应该在连接未打开的情况下打开连接（需要），并在使用后关闭连接（如果打开了连接）。简而言之，将连接保留在您找到它的状态。存在通用的函数 open 和 close，它们具有显式打开和关闭连接的方法。

使用 gzip 算法压缩的文件可以通过 gzfile 函数创建的连接使用，而使用 bzip2 压缩的文件可以通过 bzfile 函数使用。

Unix 程序员习惯于处理特殊文件 stdin、stdout 和 stderr。这些在 R 中以 终端连接 的形式存在。它们可以是普通文件，但也可以指代来自 GUI 控制台的输入和输出。（即使使用标准 Unix R 接口，stdin 也指代来自 readline 的提交行，而不是文件。）

三个终端连接始终处于打开状态，无法打开或关闭。 stdout 和 stderr 通常分别用于正常输出和错误消息。它们通常会发送到同一个地方，但正常输出可以通过调用 sink 重定向，而错误输出则发送到 stderr，除非通过 sink, type="message") 重定向。请仔细注意这里使用的语言：连接无法重定向，但输出可以发送到其他连接。

文本连接 是另一种输入来源。它们允许将 R 字符向量读取为从文本文件读取行。文本连接通过调用 textConnection 创建并打开，该函数在创建时将字符向量的当前内容复制到内部缓冲区。

文本连接还可以用于将 R 输出捕获到字符向量中。 textConnection 可以被要求创建一个新的字符对象或追加到现有的字符对象，这两种情况都在用户的工作空间中。连接通过调用 textConnection 打开，并且始终可以在 R 对象中获得输出到连接的完整行。关闭连接会将任何剩余的输出写入字符向量的最后一个元素。

管道 是一种特殊类型的文件，它连接到另一个进程，管道连接由 pipe 函数创建。打开一个用于写入的管道连接（追加到管道没有意义）会运行一个操作系统命令，并将它的标准输入连接到 R 随后写入该连接的内容。相反，打开一个用于输入的管道连接会运行一个操作系统命令，并使其标准输出可供 R 从该连接输入。

可以使用 url 函数读取类型为 ‘http://’、‘https://’、‘ftp://’ 和 ‘file://’ 的 URL。为了方便起见，file 也会接受这些作为文件规范并调用 url。

套接字也可以通过 socketConnection 函数用作连接，该函数在支持 Berkeley 风格套接字的平台（大多数 Unix 系统、Linux 和 Windows）上可用。套接字可以写入或读取，并且可以使用客户端和服务器套接字。

7.2 输出到连接 ¶

我们已经描述了函数 cat、write、write.table 和 sink 作为写入文件，如果参数 append = TRUE，则可能追加到文件，这正是它们在 R 版本 1.2.0 之前所做的。

当前的行为是等效的，但实际上发生的是，当 file 参数是字符字符串时，会打开一个文件连接（用于写入或追加），并在函数调用结束时关闭。如果我们想要重复写入同一个文件，更有效的方法是显式声明和打开连接，并将连接对象传递给对输出函数的每次调用。这也使得写入管道成为可能，这在早期通过语法 file = "|cmd"（仍然可以使用）以有限的方式实现。

有一个函数 writeLines 用于将完整的文本行写入连接。

一些简单的例子是

zz <- file("ex.data", "w")  # open an output file connection
cat("TITLE extra line", "2 3 5 7", "", "11 13 17", 
    file = zz, sep = "\n")
cat("One more line\n", file = zz)
close(zz)

## convert decimal point to comma in output, using a pipe (Unix)
## both R strings and (probably) the shell need \ doubled
zz <- pipe(paste("sed s/\\\\./,/ >", "outfile"), "w")
cat(format(round(rnorm(100), 4)), sep = "\n", file = zz)
close(zz)
## now look at the output file:
file.show("outfile", delete.file = TRUE)

## capture R output: use examples from help(lm)
zz <- textConnection("ex.lm.out", "w")
sink(zz)
example(lm, prompt.echo = "> ")
sink()
close(zz)
## now ‘ex.lm.out’ contains the output for futher processing.
## Look at it by, e.g.,
cat(ex.lm.out, sep = "\n")

7.3 从连接中输入 ¶

从连接中读取的基本函数是 scan 和 readLines。这些函数接受一个字符字符串参数，并在函数调用期间打开一个文件连接，但显式打开文件连接允许以不同的格式顺序读取文件。

其他调用 scan 的函数也可以使用连接，特别是 read.table。

一些简单的例子是

## read in file created in last examples
readLines("ex.data")
unlink("ex.data")

## read listing of current directory (Unix)
readLines(pipe("ls -1"))

# remove trailing commas from an input file.
# Suppose we are given a file ‘data’ containing
450, 390, 467, 654,  30, 542, 334, 432, 421,
357, 497, 493, 550, 549, 467, 575, 578, 342,
446, 547, 534, 495, 979, 479
# Then read this by
scan(pipe("sed -e s/,$// data"), sep=",")

为了方便起见，如果 file 参数指定了 FTP、HTTP 或 HTTPS URL，则通过 url 打开 URL 以供读取。还可以通过 ‘file://foo.bar’ 指定文件。

• 回退

> zz <- textConnection(LETTERS)
> readLines(zz, 2)
[1] "A" "B"
> scan(zz, "", 4)
Read 4 items
[1] "C" "D" "E" "F"
> pushBack(c("aa", "bb"), zz)
> scan(zz, "", 4)
Read 4 items
[1] "aa" "bb" "G"  "H" 
> close(zz)

7.4 列出和操作连接 ¶

可以通过 showConnections() 找到用户当前打开的所有连接的摘要，可以通过 showConnections(all = TRUE) 找到所有连接的摘要，包括已关闭的连接和终端连接。

通用函数 seek 可用于读取和（在某些连接上）重置当前的读写位置。不幸的是，它依赖于操作系统设施，这些设施可能不可靠（例如，在 Windows 下使用文本文件）。函数 isSeekable 报告 seek 是否可以更改其参数给出的连接上的位置。

函数 truncate 可用于在当前位置截断以写入方式打开的文件。它仅适用于 file 连接，并且并非在所有平台上都实现。

7.5 二进制连接 ¶

函数 readBin 和 writeBin 用于读取和写入二进制连接。通过在模式规范中附加 "b" 来以二进制模式打开连接，即使用模式 "rb" 进行读取，使用模式 "wb" 或 "ab"（在适当的情况下）进行写入。这些函数具有以下参数

readBin(con, what, n = 1, size = NA, endian = .Platform$endian) 
writeBin(object, con, size = NA, endian = .Platform$endian) 

在每种情况下，con 都是一个连接，如果需要，它将在调用期间打开，如果给出了一个字符字符串，则假定它指定一个文件名。

描述写入操作相对简单，因此我们先从这里开始。 object 应该是一个原子向量对象，即一个模式为 numeric、integer、logical、character、complex 或 raw 的向量，且不包含属性。默认情况下，它将以字节流的形式写入文件，与内存中的表示方式完全一致。

readBin 从文件中读取字节流，并根据 what 指定的模式将其解释为向量。这可以是适当模式的对象（例如 what=integer()），也可以是描述模式的字符字符串（前一段中给出的五个模式之一，或 "double" 或 "int"）。参数 n 指定从连接中读取的向量元素的最大数量：如果可用元素较少，则将返回更短的向量。参数 signed 允许将 1 字节和 2 字节整数读取为有符号整数（默认值）或无符号整数。

其余两个参数用于写入或读取数据以与另一个程序或另一个平台进行交换。默认情况下，二进制数据将直接从内存传输到连接或 反之。如果数据要传输到架构不同的机器，则此方法将无法满足要求，但在几乎所有 R 平台之间，唯一需要的更改是字节顺序。常见的 PC（基于 ‘ix86’ 和 ‘x86_64’ 的机器）、Compaq Alpha 和 Vaxen 是 小端，而 Sun Sparc、mc680x0 系列、IBM R6000、SGI 和大多数其他机器是 大端。（网络字节顺序（如 XDR（eXternal Data Representation）中使用的）是大端。）要传输到或从其他程序传输，我们可能需要做更多操作，例如读取 16 位整数或写入单精度实数。这可以通过使用 size 参数来完成，该参数（通常）允许整数和逻辑值的大小为 1、2、4、8，以及实数的大小为 4、8，以及可能为 12 或 16。以不同大小进行传输可能会导致精度损失，并且不应尝试对包含 NA 的向量进行此操作。

字符字符串以 C 格式读取和写入，即作为以零字节结尾的字节串。函数 readChar 和 writeChar 提供了更大的灵活性。

• 特殊值

8.1 从套接字读取 ¶

基础 R 包含一些用于通过 BSD 套接字进行通信的工具，这些工具在支持套接字的系统上可用（包括常见的 Linux、Unix 和 Windows 上的 R 端口）。使用套接字的一个潜在问题是，这些工具通常出于安全原因或为了强制使用 Web 缓存而被阻止，因此这些函数在内联网上可能比在外部更有用。对于新项目，建议使用套接字连接。

早期的低级接口由函数 make.socket、read.socket、write.socket 和 close.socket 提供。

8.2 使用 download.file ¶

函数 download.file 用于通过 FTP 或 HTTP（包括 HTTPS）从 Web 资源读取文件并将其写入文件。通常可以避免这种情况，因为诸如 read.table 和 scan 之类的函数可以直接从 URL 读取，方法是显式使用 url 打开连接，或者隐式使用它，方法是将 URL 作为 file 参数提供。