6.数据导入

作者: denghb001 | 来源:发表于2021-12-24 11:03 被阅读0次

数据导入

1.简介

有的时候我们直接使用R包中提供的数据来进行分析，是一个很好的方法，但是我们想使用自己的数据时，就需要将数据读入到R中。我们接下来将了解如何使用readr包在 R 中加载文件，readr包是tidyverse包的核心部分。

1.1先决条件

我们需要加载tidyverse包

library(tidyverse)

2.入门

readr 的大部分函数都是将文件转换为数据框：

read_csv()读取逗号分隔的文件，read_csv2()读取分号分隔的文件（在,用作小数位的国家中常见）， read_tsv()读取制表符分隔的文件，read_delim()读取带有任何分隔符的文件。
read_fwf()读取固定宽度的文件。您可以通过指定其宽度fwf_widths()或fwf_positions()指定字段位置来读取文件。 read_table()读取固定宽度文件，其中列由空格分隔。
read_log()读取 Apache 格式的日志文件

这些函数的用法都相似：我们只要掌握了其中一个的使用方法，其它的函数就能运用自如。接下来我们将主要了解read_csv()。（csv 文件是最常见的数据存储形式之一）

read_csv()的第一个参数是最重要的：它是读取的文件的路径。

heights <- read_csv("data/heights.csv")
#> 
#> ── Column specification ────────────────────────────────────────────────────────
#> cols(
#>   earn = col_double(),
#>   height = col_double(),
#>   sex = col_character(),
#>   ed = col_double(),
#>   age = col_double(),
#>   race = col_character()
#> )

当您运行read_csv()时，它会打印出一个列规范，其中给出了每列的名称和类型。这是 readr 的一个重要组成部分。

您还可以提供内联 csv 文件进行读取：

read_csv("a,b,c
1,2,3
4,5,6")
#> # A tibble: 2 x 3
#>       a     b     c
#>   <dbl> <dbl> <dbl>
#> 1     1     2     3
#> 2     4     5     6

在以上两种情况下，read_csv()列名都使用数据的第一行，这是默认的约定。有时候文件的开头可能不是我们想要的数据，我们可以通过skip = n或者comment = "#"来忽略。

```
read_csv("The first line of metadata
  The second line of metadata
  x,y,z
  1,2,3", skip = 2)
#> # A tibble: 1 x 3
#>       x     y     z
#>   <dbl> <dbl> <dbl>
#> 1     1     2     3

read_csv("# A comment I want to skip
  x,y,z
  1,2,3", comment = "#")
#> # A tibble: 1 x 3
#>       x     y     z
#>   <dbl> <dbl> <dbl>
#> 1     1     2     3
```

有时数据可能没有列名。您可以使用col_names = FALSE来告诉read_csv()不要将第一行视为标题，而是通过X1到Xn顺序默认标记：

```
read_csv("1,2,3\n4,5,6", col_names = FALSE)
#> # A tibble: 2 x 3
#>      X1    X2    X3
#>   <dbl> <dbl> <dbl>
#> 1     1     2     3
#> 2     4     5     6
```

你也可以自定义命名列名称 col_names：

```
read_csv("1,2,3\n4,5,6", col_names = c("x", "y", "z"))
#> # A tibble: 2 x 3
#>       x     y     z
#>   <dbl> <dbl> <dbl>
#> 1     1     2     3
#> 2     4     5     6
```

另一个通常需要调整的选项是na：这指定了用于表示文件中缺失值的一个（或多个）值：

read_csv("a,b,c\n1,2,.", na = ".")
#> # A tibble: 1 x 3
#>       a     b c    
#>   <dbl> <dbl> <lgl>
#> 1     1     2 NA

2.1 与 R中的base包比较

以前我们经常使用read.csv()来读取文件，那为什么我们现在要选择readr包中的read_csv呢？下面就列出了使用readr的优点：

readr包中的函数通常比base中的快得多（~10 倍）。
readr中可以生成小标题，而且不会将字符向量转换为因子、使用行名称或修改列名称。
可重复性更高。

3. 解析向量

在我们深入了解readr如何从磁盘读取文件之前，我们需要先了解解析函数parse_*()。这些函数接受一个字符向量并返回一个更特殊的向量，如逻辑、整数或日期：

str(parse_logical(c("TRUE", "FALSE", "NA")))
#>  logi [1:3] TRUE FALSE NA
str(parse_integer(c("1", "2", "3")))
#>  int [1:3] 1 2 3
str(parse_date(c("2010-01-01", "1979-10-14")))
#>  Date[1:2], format: "2010-01-01" "1979-10-14"

与 tidyverse 中的所有函数一样，这些parse_*()函数是统一的：第一个参数是要解析的字符向量，该na参数指定应将哪些字符串视为缺失：

parse_integer(c("1", "231", ".", "456"), na = ".")
#> [1]   1 231  NA 456

如果解析失败，您将收到警告：

x <- parse_integer(c("123", "345", "abc", "123.45"))
#> Warning: 2 parsing failures.
#> row col               expected actual
#>   3  -- an integer             abc   
#>   4  -- no trailing characters 123.45

并且输出中结果中不显示未解析出的值，通过NA代替：

x
#> [1] 123 345  NA  NA
#> attr(,"problems")
#> # A tibble: 2 x 4
#>     row   col expected               actual
#>   <int> <int> <chr>                  <chr> 
#> 1     3    NA an integer             abc   
#> 2     4    NA no trailing characters 123.45

如果有很多解析失败，可以使用problems()来获取完整集。这将返回一个小标题，然后您可以使用 dplyr 对其进行操作。

problems(x)
#> # A tibble: 2 x 4
#>     row   col expected               actual
#>   <int> <int> <chr>                  <chr> 
#> 1     3    NA an integer             abc   
#> 2     4    NA no trailing characters 123.45

使用解析器主要是确定哪些内容是我们可用的，以及我们你该如何处理不同类型的输入。下面列出了八个特别重要的解析器：

parse_logical()和parse_integer()分别解析逻辑值和整数。
parse_double()是一个严格的数值解析器，parse_number() 是一个灵活的数值解析器。因为世界不同地区书写数字的方式不同，就可能比较复杂。
parse_character()看起来很简单，但有一个复杂因素使它变得非常重要：字符编码。
parse_factor() 创建因子，R 用于表示具有固定值和已知值的分类变量的数据结构。
parse_datetime(), parse_date(), 和parse_time()允许您解析各种日期和时间规范。这些是最复杂的，因为有很多不同的日期书写方式。

下面我们来详细了解这些解析器吧！

3.1 数字

解析一个数字看似很简单，当时需要注意以下三个问题：

世界不同地区的人们写数字的方式不同。例如，一些国家在实数的整数部分和小数部分之间使用.，而其他国家则使用,。
数字被其他字符包围，例如“$1000”或“10%”。
为了便于阅读，数字包含“分组”字符，例如“1,000,000”，并且这些分组字符在世界范围内各不相同。

为了解决第一个问题，readr 有一个“locale”的概念，该对象指定了不同地方的解析参数。解析数字时，最重要的选项是用于小数点的字符。可以通过创建新的语言环境并设置decimal_mark参数来覆盖的默认值.：

parse_double("1.23")
#> [1] 1.23
parse_double("1,23", locale = locale(decimal_mark = ","))
#> [1] 1.23

readr 的默认语言环境以美国为中心（即基本 R 的文档是用美式英语编写的）。另一种方法是尝试猜测操作系统的默认值。这很难做好，这样会使您的代码变得脆弱：即使它在您的计算机上运行，当您通过电子邮件将其发送给另一个国家的同事时，它也可能会失败。

parse_number()用来解决第二个问题：它忽略数字前后的非数字字符。这对于货币和百分比特别有用，但也适用于提取嵌入文本中的数字。

parse_number("$100")
#> [1] 100
parse_number("20%")
#> [1] 20
parse_number("It cost $123.45")
#> [1] 123.45

最后一个问题是通过parse_number()和local语言环境的组合来解决的，因为parse_number()将忽略“grouping_mark”：

# Used in America
parse_number("$123,456,789")
#> [1] 123456789

# Used in many parts of Europe
parse_number("123.456.789", locale = locale(grouping_mark = "."))
#> [1] 123456789

# Used in Switzerland
parse_number("123'456'789", locale = locale(grouping_mark = "'"))
#> [1] 123456789

3.2 字符串

parse_character()看起来虽然很简单——只返回它的输入。然而一个字符串可以用不同的方法表示（如八进制、十六进制）。在 R 中，我们可以使用charToRaw()取字符串的底层表示：

charToRaw("Hadley")
#> [1] 48 61 64 6c 65 79

每个十六进制数代表一个字节的信息：48代表 H，61代表 a，等等。从十六进制数到字符的映射称为编码，在这种情况的编码称为 ASCII。ASCII 在表示英文字符方面做得很好，因为它是美国信息交换标准代码（American Standard Code for Information Interchange）。

对于英语以外的语言，就变得更加复杂。在计算机的早期，有许多非英语字符编码标准，如果要正确解释字符串，您需要知道相应的值和编码。例如，两种常见的编码是 Latin1（又名 ISO-8859-1，用于西欧语言）和 Latin2（又名 ISO-8859-2，用于东欧语言）。在Latin1 中，字节b1是“±”，但在Latin2 中，它是“ą”，为了解决这一问题，国际上采用通用编码格式：UTF-8。UTF-8 几乎可以编码当今人类使用的每个字符，以及许多额外的符号（例如表情符号！）。

readr 在任何地方都使用 UTF-8：它假定您的数据在读取时是 UTF-8 编码的，并且在写入时始终使用UTF-8。这是非常好的默认值，但对于不理解 UTF-8 的旧系统生成的数据时将会出错。如果您遇到这种情况，打印它们时您的字符串会看起来很奇怪。有时可能只有一两个字符会被弄乱或者完全乱码。例如：

x1 <- "El Ni\xf1o was particularly bad this year"
x2 <- "\x82\xb1\x82\xf1\x82\xc9\x82\xbf\x82\xcd"

x1
#> [1] "El Ni\xf1o was particularly bad this year"
x2
#> [1] "\x82\xb1\x82\xf1\x82\u0242\xbf\x82\xcd"

要解决此问题，您需要在parse_character()中指定编码：

parse_character(x1, locale = locale(encoding = "Latin1"))
#> [1] "El Niño was particularly bad this year"
parse_character(x2, locale = locale(encoding = "Shift-JIS"))
#> [1] "こんにちは"

一般我们得到的字符串，并不知道它们是怎么编码的，这个时候该怎么办呢？可以使用 readr 提供guess_encoding()解决。

guess_encoding(charToRaw(x1))
#> # A tibble: 2 x 2
#>   encoding   confidence
#>   <chr>           <dbl>
#> 1 ISO-8859-1       0.46
#> 2 ISO-8859-9       0.23
guess_encoding(charToRaw(x2))
#> # A tibble: 1 x 2
#>   encoding confidence
#>   <chr>         <dbl>
#> 1 KOI8-R         0.42

guess_encoding()的第一个参数可以是文件的路径，也可以是原始向量（如果字符串已经在 R 中，则在这种情况下很有用）。

编码是一个丰富而复杂的话题，如果您想了解更多信息，我建议您阅读http://kunststube.net/encoding/的详细说明。

3.3 因子

R 使用因子来表示具有一组已知可能值的分类变量。parse_factor()给出一个已知向量levels，在出现意外值时生成警告：

fruit <- c("apple", "banana")
parse_factor(c("apple", "banana", "bananana"), levels = fruit)
#> Warning: 1 parsing failure.
#> row col           expected   actual
#>   3  -- value in level set bananana
#> [1] apple  banana <NA>  
#> attr(,"problems")
#> # A tibble: 1 x 4
#>     row   col expected           actual  
#>   <int> <int> <chr>              <chr>   
#> 1     3    NA value in level set bananana
#> Levels: apple banana

3.4 日期、日期时间和时间

您是否可以在没有任何附加参数的情况下，调用需要的日期（从1970-01-01 以来的天数）、日期时间（自 1970-01-01 午夜以来的秒数）或时间（从自午夜以来的秒数）。

parse_datetime()参照的是 ISO8601 日期时间。ISO8601 是一项国际标准，其中日期的组成部分从大到小排列：年、月、日、小时、分钟、秒。
```
parse_datetime("2010-10-01T2010")
#> [1] "2010-10-01 20:10:00 UTC"
# If time is omitted, it will be set to midnight
parse_datetime("20101010")
#> [1] "2010-10-10 UTC"
```
这是最重要的日期/时间标准，如果您经常使用日期和时间，可以参考 https://en.wikipedia.org/wiki/ISO_8601了解更多。
parse_date() 一般格式是2021-01-01或2021/01/01。
```
parse_date("2010-10-01")
#> [1] "2010-10-01"
```
parse_time() 由期望小时、:分钟、可选:秒，以及可选的 am/pm 说明：
```
library(hms)
parse_time("01:10 am")
#> 01:10:00
parse_time("20:10:01")
#> 20:10:01
```
Base R 没有很好的内置时间数据类，可以使用 hms 包中提供的类。

如果这些默认值不适用于您的数据，您可以提供您自己的 date-time 格式，由以下部分组成：

Year
%Y (4 digits).
%y (2 digits); 00-69 -> 2000-2069, 70-99 -> 1970-1999.
Month
%m (2 digits).
%b (abbreviated name, like “Jan”).
%B (full name, “January”).
Day
%d (2 digits).
%e (optional leading space).
Time
%H 0-23 hour.
%I 0-12, must be used with %p.
%p AM/PM indicator.
%M minutes.
%S integer seconds.
%OS real seconds.
%Z 时区(作为名称，例如America/Chicago)。
%z(与UTC的偏移量，例如+0800)。
Non-digits
%. skips one non-digit character.
%* skips any number of non-digits.

找出正确格式的最好方法是在字符向量中创建示例格式，并使用其中一个解析函数进行测试。例如：

parse_date("01/02/15", "%m/%d/%y")
#> [1] "2015-01-02"
parse_date("01/02/15", "%d/%m/%y")
#> [1] "2015-02-01"
parse_date("01/02/15", "%y/%m/%d")
#> [1] "2001-02-15"

如果您使用%b或%B使用非英语月份名称，则需要将lang参数设置为locale(). 请参阅date_names_langs()中的内置语言列表，或者如果您的语言尚未包含在内，请使用date_names()来创建您自己的语言。

parse_date("1 janvier 2015", "%d %B %Y", locale = locale("fr"))
#> [1] "2015-01-01"

4 解析文件

现在已经学会了如何解析单个向量，那么 readr 是如何解析文件的呢？下面我们将学习两个新内容：

readr 如何自动猜测每一列的类型。
如何覆盖默认值。

4.1 方法

readr 使用试探法来确定每列的类型：它读取前 1000 行并使用一些（适度保守的）试探法来确定每列的类型。您可以使用字符向量来模拟这个过程guess_parser()，它会返回最佳的猜测，parse_guess()使用该猜测来解析列：

guess_parser("2010-10-01")
#> [1] "date"
guess_parser("15:01")
#> [1] "time"
guess_parser(c("TRUE", "FALSE"))
#> [1] "logical"
guess_parser(c("1", "5", "9"))
#> [1] "double"
guess_parser(c("12,352,561"))
#> [1] "number"

str(parse_guess("2010-10-10"))
#>  Date[1:1], format: "2010-10-10"

通过尝试以下每种类型，在找到匹配项时停止：

逻辑：仅包含“F”、“T”、“FALSE”或“TRUE”。
整数：仅包含数字字符（和-）。
double: 只包含有效的 doubles（包括像的数字4.5e-5）。
数字：包含带有分组标记的有效双打。
时间：匹配默认值time_format。
日期：匹配默认值date_format。
日期时间：任何 ISO8601 日期。

如果上面这些规则都不适用，则该列将保留为字符串向量。

4.2 问题

这些默认值并不总是适用于较大的文件。有两个基本问题：

前1000行可能是一个特例，猜测的类型并不适用与所有列。例如，前1000行是整数后面的行全是双精度。
该列可能包含许多缺失值。如果前 1000 行仅包含NA，则 readr 会猜测它是一个逻辑向量，而您可能希望将其解析为更具体的内容。

readr 有一个具有挑战性的 CSV文件，它说明了这两个问题：

challenge <- read_csv(readr_example("challenge.csv"))
#> 
#> ── Column specification ────────────────────────────────────────────────────────
#> cols(
#>   x = col_double(),
#>   y = col_logical()
#> )
#> Warning: 1000 parsing failures.
#>  row col           expected     actual                                                           file
#> 1001   y 1/0/T/F/TRUE/FALSE 2015-01-16 '/Users/runner/work/_temp/Library/readr/extdata/challenge.csv'
#> 1002   y 1/0/T/F/TRUE/FALSE 2018-05-18 '/Users/runner/work/_temp/Library/readr/extdata/challenge.csv'
#> 1003   y 1/0/T/F/TRUE/FALSE 2015-09-05 '/Users/runner/work/_temp/Library/readr/extdata/challenge.csv'
#> 1004   y 1/0/T/F/TRUE/FALSE 2012-11-28 '/Users/runner/work/_temp/Library/readr/extdata/challenge.csv'
#> 1005   y 1/0/T/F/TRUE/FALSE 2020-01-13 '/Users/runner/work/_temp/Library/readr/extdata/challenge.csv'
#> .... ... .................. .......... ..............................................................
#> See problems(...) for more details.

（注意使用readr_example()时which() 可以找到包中包含的示例文件的路径）

有两个打印输出：通过查看前 1000 行生成的列规范，以及前五个解析失败。通过使用problems()来详细了解：

problems(challenge)
#> # A tibble: 1,000 x 5
#>     row col   expected        actual   file                                     
#>   <int> <chr> <chr>           <chr>    <chr>                                    
#> 1  1001 y     1/0/T/F/TRUE/F… 2015-01… '/Users/runner/work/_temp/Library/readr/…
#> 2  1002 y     1/0/T/F/TRUE/F… 2018-05… '/Users/runner/work/_temp/Library/readr/…
#> 3  1003 y     1/0/T/F/TRUE/F… 2015-09… '/Users/runner/work/_temp/Library/readr/…
#> 4  1004 y     1/0/T/F/TRUE/F… 2012-11… '/Users/runner/work/_temp/Library/readr/…
#> 5  1005 y     1/0/T/F/TRUE/F… 2020-01… '/Users/runner/work/_temp/Library/readr/…
#> 6  1006 y     1/0/T/F/TRUE/F… 2016-04… '/Users/runner/work/_temp/Library/readr/…
#> # … with 994 more rows

一个好的方法是逐列运行，直到没有问题为止。在这里我们可以看到解析y列有很多问题。如果我们查看最后几行，您会发现它们是存储在字符向量中的日期：

tail(challenge)
#> # A tibble: 6 x 2
#>       x y    
#>   <dbl> <lgl>
#> 1 0.805 NA   
#> 2 0.164 NA   
#> 3 0.472 NA   
#> 4 0.718 NA   
#> 5 0.270 NA   
#> 6 0.608 NA

这表明我们需要改用日期解析器。要修复调用，首先将列规范复制并粘贴到原始调用中：

challenge <- read_csv(
  readr_example("challenge.csv"), 
  col_types = cols(
    x = col_double(),
    y = col_logical()
  )
)

然后可以通过y指定y日期列来修复列的类型：

challenge <- read_csv(
  readr_example("challenge.csv"), 
  col_types = cols(
    x = col_double(),
    y = col_date()
  )
)
tail(challenge)
#> # A tibble: 6 x 2
#>       x y         
#>   <dbl> <date>    
#> 1 0.805 2019-11-21
#> 2 0.164 2018-03-29
#> 3 0.472 2014-08-04
#> 4 0.718 2015-08-16
#> 5 0.270 2020-02-04
#> 6 0.608 2019-01-06

每个parse_xyz()函数都有对应的col_xyz()函数。当数据已经在 R 中的字符向量中时使用parse_xyz()；你在使用col_xyz()的时候，你要告诉readr如何加载数据。

我强烈建议自己提供col_types，从 readr 提供的打印输出中构建。这可确保您拥有一致且可重现的数据导入脚本。如果您依赖默认的猜测那么您的数据可能发生变化。如果您想通过readr 将继续读入它，请使用stop_for_problems(): 如果有任何解析问题，它将抛出错误并停止您的脚本。

4.3 其他方法

还有一些其他的通用方法可以帮助您解析文件：

在前面的示例中，我们只是走运了：如果我们只查看比默认值多一行的行，我们可以一次性正确解析：

challenge2 <- read_csv(readr_example("challenge.csv"), guess_max = 1001)
#> 
#> ── Column specification ────────────────────────────────────────────────────────
#> cols(
#>   x = col_double(),
#>   y = col_date(format = "")
#> )
challenge2
#> # A tibble: 2,000 x 2
#>       x y         
#>   <dbl> <date>    
#> 1   404 NA        
#> 2  4172 NA        
#> 3  3004 NA        
#> 4   787 NA        
#> 5    37 NA        
#> 6  2332 NA        
#> # … with 1,994 more rows

有时，如果您将所有列作为字符向量读取，则更容易诊断问题：

challenge2 <- read_csv(readr_example("challenge.csv"), 
  col_types = cols(.default = col_character())
)

这与type_convert()结合使用特别有用，它将解析启发式应用于数据框中的字符列。

df <- tribble(
  ~x,  ~y,
  "1", "1.21",
  "2", "2.32",
  "3", "4.56"
)
df
#> # A tibble: 3 x 2
#>   x     y    
#>   <chr> <chr>
#> 1 1     1.21 
#> 2 2     2.32 
#> 3 3     4.56

# Note the column types
type_convert(df)
#> 
#> ── Column specification ────────────────────────────────────────────────────────
#> cols(
#>   x = col_double(),
#>   y = col_double()
#> )
#> # A tibble: 3 x 2
#>       x     y
#>   <dbl> <dbl>
#> 1     1  1.21
#> 2     2  2.32
#> 3     3  4.56

如果您正在读取一个非常大的文件，您可能希望设置n_max为一个较小的数字，例如 10,000 或 100,000。
如果您遇到主要的解析问题，有时更容易读取带有read_lines()的行字符向量，甚至是长度为 1 的字符向量read_file()。

5 写入文件

readr 还带有两个用于将数据写回磁盘的函数：write_csv()和write_tsv(). 这两个函数都通过以下方式输出文件：

始终以 UTF-8 编码字符串。
以 ISO8601 格式保存日期和日期时间，以便在其他地方轻松解析。

如果要将 csv 文件导出到 Excel，请使用write_excel_csv()-这会在文件开头写入一个特殊字符（“字节顺序标记”），告诉 Excel 您正在使用 UTF-8 编码。

最重要的参数是x（要保存的数据框）和path（保存它的位置）。您还可以指定缺失值的写入方式na，以及append是否要写入现有文件。

write_csv(challenge, "challenge.csv")

注意保存到csv时类型信息丢失：

challenge
#> # A tibble: 2,000 x 2
#>       x y         
#>   <dbl> <date>    
#> 1   404 NA        
#> 2  4172 NA        
#> 3  3004 NA        
#> 4   787 NA        
#> 5    37 NA        
#> 6  2332 NA        
#> # … with 1,994 more rows
write_csv(challenge, "challenge-2.csv")
read_csv("challenge-2.csv")
#> 
#> ── Column specification ────────────────────────────────────────────────────────
#> cols(
#>   x = col_double(),
#>   y = col_logical()
#> )
#> # A tibble: 2,000 x 2
#>       x y    
#>   <dbl> <lgl>
#> 1   404 NA   
#> 2  4172 NA   
#> 3  3004 NA   
#> 4   787 NA   
#> 5    37 NA   
#> 6  2332 NA   
#> # … with 1,994 more rows

这使得 CSV 缓存临时结果有点不可靠——每次加载时都需要重新创建列规则。有两种选择：

write_rds()和read_rds()是围绕base函数readRDS()和saveRDS()的统一包装。这些以 R 的自定义二进制格式存储数据，称为 RDS：

write_rds(challenge, "challenge.rds")
read_rds("challenge.rds")
#> # A tibble: 2,000 x 2
#>       x y         
#>   <dbl> <date>    
#> 1   404 NA        
#> 2  4172 NA        
#> 3  3004 NA        
#> 4   787 NA        
#> 5    37 NA        
#> 6  2332 NA        
#> # … with 1,994 more rows

Feather 包实现了一种可以跨编程语言共享的快速二进制文件格式：

library(feather)
write_feather(challenge, "challenge.feather")
read_feather("challenge.feather")
#> # A tibble: 2,000 x 2
#>       x      y
#>   <dbl> <date>
#> 1   404   <NA>
#> 2  4172   <NA>
#> 3  3004   <NA>
#> 4   787   <NA>
#> 5    37   <NA>
#> 6  2332   <NA>
#> # ... with 1,994 more rows

Feather 往往比 RDS 更快，并且可以在 R 之外使用。RDS 支持列表。

6 其他类型的数据

要将其他类型的数据导入 R，我们建议从下面列出的 tidyverse 包开始。它们当然不是最好的方式，但它们是一个很好的起点。对于矩形数据：

Have读取 SPSS、Stata 和 SAS 文件。
readxl读取 excel 文件（包括.xls和.xlsx）。
DBI以及特定于数据库的后端（例如 RMySQL、 RSQLite、RPostgreSQL等）允许您针对数据库运行 SQL 查询并返回数据框。

对于分层数据：对 json使用jsonlite（由 Jeroen Ooms），对 XML 使用xml2。Jenny Bryan 在https://jennybc.github.io/purrr-tutorial/ 有非常好的示例。

对于其他文件类型，可以查看R data import/export manual
和rio包。