R语言ETL工程系列：检索（select）

作者：黄天元，复旦大学博士在读，目前研究涉及文本挖掘、社交网络分析和机器学习等。希望与大家分享学习经验，推广并加深R语言在业界的应用。

邮箱：[email protected]

前言

本章介绍如何从表中检索一个或多个数据列。

首先我们加载需要使用的包。其中我们需要的航班数据flights数据集需要在nycflights13中加载：

1library(tidyverse)
2library(nycflights13)

select函数

select是最常用的ETL函数之一，用途就是从表格中选取需要的列。
要使用这个函数，要搞清楚两个问题：1.从哪里获取数据？2.从数据里面提取什么？所以需要给出至少两个信息：1.表格名称；2.列名称。

检索单个列

我们从最简单的语句开始：

1flights %>%
2  select(year)

 1## # A tibble: 336,776 x 1
 2##     year
 3##    <int>
 4##  1  2013
 5##  2  2013
 6##  3  2013
 7##  4  2013
 8##  5  2013
 9##  6  2013
10##  7  2013
11##  8  2013
12##  9  2013
13## 10  2013
14## # ... with 336,766 more rows

上面的语句表示：从flights表格中提取了名为year的列。相应的SQL语句如下：

1<SQL> SELECT `year`
2FROM `flights`

提示：尽管SQL不区分大小写，但是统一使用大写来写SQL语句有利于提高可读性。另外，很多SQL语句要求最后要加分号（;），否则会报错。

检索多个列

检索多个列与检索单列相似，需要给出多个列名称，而且列名称之间需要用逗号（,）隔开。需要注意的是，最后的列名称后面不能加逗号，否则会报错。

1flights %>%
2  select(year,month,day)

 1## # A tibble: 336,776 x 3
 2##     year month   day
 3##    <int> <int> <int>
 4##  1  2013     1     1
 5##  2  2013     1     1
 6##  3  2013     1     1
 7##  4  2013     1     1
 8##  5  2013     1     1
 9##  6  2013     1     1
10##  7  2013     1     1
11##  8  2013     1     1
12##  9  2013     1     1
13## 10  2013     1     1
14## # ... with 336,766 more rows

相应SQL语句如下：

1<SQL> SELECT `year`, `month`, `day`
2FROM `flights`

检索所有列

R中只要输入表格名称，默认就是包含了表格所有列，因此提取所有列非常简单：

1flights

 1## # A tibble: 336,776 x 19
 2##     year month   day dep_time sched_dep_time dep_delay arr_time
 3##    <int> <int> <int>    <int>          <int>     <dbl>    <int>
 4##  1  2013     1     1      517            515         2      830
 5##  2  2013     1     1      533            529         4      850
 6##  3  2013     1     1      542            540         2      923
 7##  4  2013     1     1      544            545        -1     1004
 8##  5  2013     1     1      554            600        -6      812
 9##  6  2013     1     1      554            558        -4      740
10##  7  2013     1     1      555            600        -5      913
11##  8  2013     1     1      557            600        -3      709
12##  9  2013     1     1      557            600        -3      838
13## 10  2013     1     1      558            600        -2      753
14## # ... with 336,766 more rows, and 12 more variables: sched_arr_time <int>,
15## #   arr_delay <dbl>, carrier <chr>, flight <int>, tailnum <chr>,
16## #   origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>, hour <dbl>,
17## #   minute <dbl>, time_hour <dttm>

SQL代码：

1<SQL> SELECT *
2FROM `flights`

根据列名称对列进行检索

有的时候我们的表格具有很多列，而列名称是具有一定的命名规则的，我们可以根据这些规则来选择特定的列。比如在flights表格中，我们先看一下flights有哪些列名称：

1flights %>% names()

1##  [1] "year"           "month"          "day"            "dep_time"      
2##  [5] "sched_dep_time" "dep_delay"      "arr_time"       "sched_arr_time"
3##  [9] "arr_delay"      "carrier"        "flight"         "tailnum"       
4## [13] "origin"         "dest"           "air_time"       "distance"      
5## [17] "hour"           "minute"         "time_hour"

这样我们就知道flights都有哪些列，现在我们想要检索以“time”结尾的列，可以这样操作：

1flights %>%
2  select(ends_with("time"))

 1## # A tibble: 336,776 x 5
 2##    dep_time sched_dep_time arr_time sched_arr_time air_time
 3##       <int>          <int>    <int>          <int>    <dbl>
 4##  1      517            515      830            819      227
 5##  2      533            529      850            830      227
 6##  3      542            540      923            850      160
 7##  4      544            545     1004           1022      183
 8##  5      554            600      812            837      116
 9##  6      554            558      740            728      150
10##  7      555            600      913            854      158
11##  8      557            600      709            723       53
12##  9      557            600      838            846      140
13## 10      558            600      753            745      138
14## # ... with 336,766 more rows

这样一来我们就选择了所有与时间相关的变量。如果要选择以一定的字符串起始的列，可以使用starts_with，比如：

1flights %>%
2  select(starts_with("dep"))

 1## # A tibble: 336,776 x 2
 2##    dep_time dep_delay
 3##       <int>     <dbl>
 4##  1      517         2
 5##  2      533         4
 6##  3      542         2
 7##  4      544        -1
 8##  5      554        -6
 9##  6      554        -4
10##  7      555        -5
11##  8      557        -3
12##  9      557        -3
13## 10      558        -2
14## # ... with 336,766 more rows

关于选择列的条件还有很多，它们是tidyselect包中的函数，比如contains可以选择列名称中包含某一特定字符串的列，详情可以用?vars_select来查询你需要的功能。

检索独特的值

有时候我们只想知道出现的值的不同种类，不需要每次出现都表示出来，这个时候我们可以使用distinct函数，下面我们举个例子。
我们想要知道数据中包含了哪些月份的数据，但是单纯选择月份这一字段是做不到的。

1flights %>%
2  select(month)

 1## # A tibble: 336,776 x 1
 2##    month
 3##    <int>
 4##  1     1
 5##  2     1
 6##  3     1
 7##  4     1
 8##  5     1
 9##  6     1
10##  7     1
11##  8     1
12##  9     1
13## 10     1
14## # ... with 336,766 more rows

我们需要使用distinct函数，让month列中重复出现的值不会第二次出现：

1flights %>%
2  select(month) %>%
3  distinct()

 1## # A tibble: 12 x 1
 2##    month
 3##    <int>
 4##  1     1
 5##  2    10
 6##  3    11
 7##  4    12
 8##  5     2
 9##  6     3
10##  7     4
11##  8     5
12##  9     6
13## 10     7
14## 11     8
15## 12     9

SQL代码：

1<SQL> SELECT DISTINCT *
2FROM (SELECT `month`
3FROM `flights`)

只显示若干行

前面的例子中其实我们也可以知道，flights这个数据表一共有336,776行，也就是说，我们无法在屏幕中就浏览全数据，我们只能截取一部分查看。
比较常见的方法，是查看前几行，或者最后几行。但是事实上，只要我们可以根据需要查看任意行（使用切片函数slice）。

查看前6行：

1flights %>%
2  head()

 1## # A tibble: 6 x 19
 2##    year month   day dep_time sched_dep_time dep_delay arr_time
 3##   <int> <int> <int>    <int>          <int>     <dbl>    <int>
 4## 1  2013     1     1      517            515         2      830
 5## 2  2013     1     1      533            529         4      850
 6## 3  2013     1     1      542            540         2      923
 7## 4  2013     1     1      544            545        -1     1004
 8## 5  2013     1     1      554            600        -6      812
 9## 6  2013     1     1      554            558        -4      740
10## # ... with 12 more variables: sched_arr_time <int>, arr_delay <dbl>,
11## #   carrier <chr>, flight <int>, tailnum <chr>, origin <chr>, dest <chr>,
12## #   air_time <dbl>, distance <dbl>, hour <dbl>, minute <dbl>,
13## #   time_hour <dttm>

查看后6行：

1flights %>%
2  tail()

 1## # A tibble: 6 x 19
 2##    year month   day dep_time sched_dep_time dep_delay arr_time
 3##   <int> <int> <int>    <int>          <int>     <dbl>    <int>
 4## 1  2013     9    30       NA           1842        NA       NA
 5## 2  2013     9    30       NA           1455        NA       NA
 6## 3  2013     9    30       NA           2200        NA       NA
 7## 4  2013     9    30       NA           1210        NA       NA
 8## 5  2013     9    30       NA           1159        NA       NA
 9## 6  2013     9    30       NA            840        NA       NA
10## # ... with 12 more variables: sched_arr_time <int>, arr_delay <dbl>,
11## #   carrier <chr>, flight <int>, tailnum <chr>, origin <chr>, dest <chr>,
12## #   air_time <dbl>, distance <dbl>, hour <dbl>, minute <dbl>,
13## #   time_hour <dttm>

查看第100行到第103行：

1flights %>%
2  slice(100:103)

 1## # A tibble: 4 x 19
 2##    year month   day dep_time sched_dep_time dep_delay arr_time
 3##   <int> <int> <int>    <int>          <int>     <dbl>    <int>
 4## 1  2013     1     1      752            759        -7      955
 5## 2  2013     1     1      753            755        -2     1056
 6## 3  2013     1     1      754            759        -5     1039
 7## 4  2013     1     1      754            755        -1     1103
 8## # ... with 12 more variables: sched_arr_time <int>, arr_delay <dbl>,
 9## #   carrier <chr>, flight <int>, tailnum <chr>, origin <chr>, dest <chr>,
10## #   air_time <dbl>, distance <dbl>, hour <dbl>, minute <dbl>,
11## #   time_hour <dttm>

这里只展示取前6行的代码的SQL代码：

1<SQL> SELECT *
2FROM `flights`
3LIMIT 6

使用注释

任何编程语言都需要有注释，注释能够方便别人读懂你的代码。即使你不打算把代码分享给别人，注释也有助于自己在往后的工作中，重新使用自己已经写过的代码。
R语言中，注释一般采用井号（#），即#后面的内容就是需要注释的部分，我们举个例子。

1flights %>%      #这是我们的表格名称flights
2  select(year)   #这是我们要取的列year

 1## # A tibble: 336,776 x 1
 2##     year
 3##    <int>
 4##  1  2013
 5##  2  2013
 6##  3  2013
 7##  4  2013
 8##  5  2013
 9##  6  2013
10##  7  2013
11##  8  2013
12##  9  2013
13## 10  2013
14## # ... with 336,766 more rows

#上面的井号后面的都是注释，不会被执行

提示：尽管本系列的重点不是SQL，但是这里还是提及一下SQL中的注释格式。SQL中，与R语言井号（#）对等的注释代码是“–”（两个减号，又称连字符）。例子如下：

1<SQL> SELECT DISTINCT *
2FROM (SELECT `month`     --不用执行我，我只是注释
3FROM `flights`)

小结

本章主要内容就是，如何选择列：选择一列，选择多列，选择列中独特的值，只显示其中的若干行。最后，我们还介绍了如何在R语言中对代码进行注释，加强代码的可读性，从而提高代码的重复利用性。老实说，这些内容都比较简单，不过被使用频次是最多的，必须要牢牢掌握，随时使用。

往期精彩：

1. R语言ETL工程系列：总论
   

2. R语言ETL工程系列：R语言基础设置
   

3. R语言ETL工程系列：读写（read/write）
   

4. R语言文本特征工程：词袋模型
   

公众号后台回复关键字即可学习

回复 爬虫             爬虫三大案例实战  
回复 Python        1小时破冰入门

回复 数据挖掘      R语言入门及数据挖掘
回复 人工智能      三个月入门人工智能
回复 数据分析师   数据分析师成长之路 
回复 机器学习      机器学习的商业应用
回复 数据科学      数据科学实战
回复 常用算法      常用数据挖掘算法