使用data.table包操作数据
data.table包提供了一个加强版的data.frame，它运行效率极高，而且能够处理适合内存的大数据集，它使用[]实现了一种自然地数据操作语法。使用下面命令进行安装：
install.packages("data.table")
载入包：
library(data.table)
#>
#> 载入程辑包：'data.table'
#> The following objects are masked from 'package:reshape2':
#>
#> dcast, melt
注意，data.table包提供了加强版的dcast()和melt()，它们的功能更强大、性能更高，内存使用也更高效。
创建data.table与创建data.frame类似：
dt = data.table(x = 1:3, y = rnorm(3), z = letters[1:3])
dt
#> x y z
#> 1: 1 0.906 a
#> 2: 2 -0.154 b
#> 3: 3 0.608 c
检查它的结构：
str(dt)
#> Classes 'data.table' and 'data.frame': 3 obs. of 3 variables:
#> $ x: int 1 2 3
#> $ y: num 0.906 -0.154 0.608
#> $ z: chr "a" "b" "c"
#> - attr(*, ".internal.selfref")=<externalptr>
可以看到，dt的类是data.table和data.frame，也就是说data.table继承了data.frame的一些行为，但增强了其他部分。
**data.table的基本语法是dt[i, j, by]，简单说就是使用i选择行，用by分组，然后计算j**。接下来我们看看data.table`继承了什么，增强了什么。
首先，我们仍然载入之前用到的产品数据，不过这里我们使用data.table包提供的fread()函数，它非常高效和智能，默认返回data.table。
product_info = fread("../../R/dataset/product-info.csv")
product_stats = fread("../../R/dataset/product-stats.csv")
product_tests = fread("../../R/dataset/product-tests.csv")
toy_tests = fread("../../R/dataset/product-toy-tests.csv")
如果查看表格信息，你会发现它和data.frame没什么两样：
product_info
#> id name type class released
#> 1: T01 SupCar toy vehicle yes
#> 2: T02 SupPlane toy vehicle no
#> 3: M01 JeepX model vehicle yes
#> 4: M02 AircraftX model vehicle yes
#> 5: M03 Runner model people yes
#> 6: M04 Dancer model people no
再看结构：
str(product_info)
#> Classes 'data.table' and 'data.frame': 6 obs. of 5 variables:
#> $ id : chr "T01" "T02" "M01" "M02" ...
#> $ name : chr "SupCar" "SupPlane" "JeepX" "AircraftX" ...
#> $ type : chr "toy" "toy" "model" "model" ...
#> $ class : chr "vehicle" "vehicle" "vehicle" "vehicle" ...
#> $ released: chr "yes" "no" "yes" "yes" ...
#> - attr(*, ".internal.selfref")=<externalptr>
与data.frame不同，如果只提供一个参数用来构建子集，data.table是选择行而不是列：
product_info[1]
#> id name type class released
#> 1: T01 SupCar toy vehicle yes
product_info[1:3]
#> id name type class released
#> 1: T01 SupCar toy vehicle yes
#> 2: T02 SupPlane toy vehicle no
#> 3: M01 JeepX model vehicle yes
如果提供的是负数，那么将删除指定的行：
product_info[-1]
#> id name type class released
#> 1: T02 SupPlane toy vehicle no
#> 2: M01 JeepX model vehicle yes
#> 3: M02 AircraftX model vehicle yes
#> 4: M03 Runner model people yes
#> 5: M04 Dancer model people no
data.table提供了许多特殊符号，它们是data.table的重要组成。.N是最常用的符号之一，它表示当前分组中，对象的数目（就不用调用nrow函数啦）。在[]使用它指提取最后一行。
product_info[.N]
#> id name type class released
#> 1: M04 Dancer model people no
product_info[c(1, .N)]
#> id name type class released
#> 1: T01 SupCar toy vehicle yes
#> 2: M04 Dancer model people no
在对data.table构建子集时，能够自动根据语义计算表达式，因此可以直接使用列名，像with()和subset()那样。
比如：
product_info[released == "yes"]
#> id name type class released
#> 1: T01 SupCar toy vehicle yes
#> 2: M01 JeepX model vehicle yes
#> 3: M02 AircraftX model vehicle yes
#> 4: M03 Runner model people yes
方括号内的第1个参数是行筛选器，第2个则对筛选后的数据进行适当的计算。
例如提取列：
product_info[released == "yes", id]
#> [1] "T01" "M01" "M02" "M03"
在这里使用"id"结果不同，返回的必然是个data.table。
product_info[released == "yes", "id"]
#> id
#> 1: T01
#> 2: M01
#> 3: M02
#> 4: M03
第二个参数可以是表达式，例如生成一张表，反应每种type和class组合中released取yes的数量：
product_info[released == "yes", table(type, class)]
#> class
#> type people vehicle
#> model 1 2
#> toy 0 1
要注意，给第2个参数提供list()，结果仍然转换为data.table：
product_info[released == "yes", list(id, name)]
#> id name
#> 1: T01 SupCar
#> 2: M01 JeepX
#> 3: M02 AircraftX
#> 4: M03 Runner
我们可以替换原有列，生成新的data.table：
product_info[, list(id, name, released = released == "yes")]
#> id name released
#> 1: T01 SupCar TRUE
#> 2: T02 SupPlane FALSE
#> 3: M01 JeepX TRUE
#> 4: M02 AircraftX TRUE
#> 5: M03 Runner TRUE
#> 6: M04 Dancer FALSE
还可以创建新列：
product_stats[, list(id, material, size, weight, density = size/weight)]
#> id material size weight density
#> 1: T01 Metal 120 10.0 12.00
#> 2: T02 Metal 350 45.0 7.78
#> 3: M01 Plastics 50 NA NA
#> 4: M02 Plastics 85 3.0 28.33
#> 5: M03 Wood 15 NA NA
#> 6: M04 Wood 16 0.6 26.67
为了简化，data.table使用.()作为list()的缩写，这两者等价：
product_info[, .(id, name, type, class)]
#> id name type class
#> 1: T01 SupCar toy vehicle
#> 2: T02 SupPlane toy vehicle
#> 3: M01 JeepX model vehicle
#> 4: M02 AircraftX model vehicle
#> 5: M03 Runner model people
#> 6: M04 Dancer model people
product_info[released == "yes", .(id, name)]
#> id name
#> 1: T01 SupCar
#> 2: M01 JeepX
#> 3: M02 AircraftX
#> 4: M03 Runner
提供排序索引可以对记录排序：
product_stats[order(size, decreasing = TRUE)]
#> id material size weight
#> 1: T02 Metal 350 45.0
#> 2: T01 Metal 120 10.0
#> 3: M02 Plastics 85 3.0
#> 4: M01 Plastics 50 NA
#> 5: M04 Wood 16 0.6
#> 6: M03 Wood 15 NA
前面都是在构建子集后，又创建新的data.table。这样挺麻烦的，因此data.table包提供了对列进行原地赋值的符号:=，例如product_stats开始是这样的：
product_stats
#> id material size weight
#> 1: T01 Metal 120 10.0
#> 2: T02 Metal 350 45.0
#> 3: M01 Plastics 50 NA
#> 4: M02 Plastics 85 3.0
#> 5: M03 Wood 15 NA
#> 6: M04 Wood 16 0.6
使用:=直接在上面数据框创建新列：
product_stats[, density := size / weight]
虽然没有任何返回，但数据已经被修改了：
product_stats
#> id material size weight density
#> 1: T01 Metal 120 10.0 12.00
#> 2: T02 Metal 350 45.0 7.78
#> 3: M01 Plastics 50 NA NA
#> 4: M02 Plastics 85 3.0 28.33
#> 5: M03 Wood 15 NA NA
#> 6: M04 Wood 16 0.6 26.67
使用:=替换已有的列：
product_info[, released := released == "yes"]
product_info
#> id name type class released
#> 1: T01 SupCar toy vehicle TRUE
#> 2: T02 SupPlane toy vehicle FALSE
#> 3: M01 JeepX model vehicle TRUE
#> 4: M02 AircraftX model vehicle TRUE
#> 5: M03 Runner model people TRUE
#> 6: M04 Dancer model people FALSE
使用键获取值
索引支持是data.table另一个独特功能，即我们可以创建键（key），使用键获取记录及其高效。
例如，使用setkey()将id设置为product_info中的一个键：
setkey(product_info, id)
同样的，函数无任何返回，但我们已经为原始数据设置了键，而且原来的数据看起来也没变化：
product_info
#> id name type class released
#> 1: M01 JeepX model vehicle TRUE
#> 2: M02 AircraftX model vehicle TRUE
#> 3: M03 Runner model people TRUE
#> 4: M04 Dancer model people FALSE
#> 5: T01 SupCar toy vehicle TRUE
#> 6: T02 SupPlane toy vehicle FALSE
但键已生成：
key(product_info)
#> [1] "id"
现在我们可以用它来获取数据了，比如提供一个id值：
product_info["M01"]
#> id name type class released
#> 1: M01 JeepX model vehicle TRUE
也可以使用setkeyv()来设置键，但它只接受字符向量：
setkeyv(product_stats, "id")
当key是一个动态变化的向量时，这个函数会非常好用。
product_stats["M02"]
#> id material size weight density
#> 1: M02 Plastics 85 3 28.3
如果两个表格有相同的键，我们可以轻松把他们连接到一起：
product_info[product_stats]
#> id name type class released material size weight density
#> 1: M01 JeepX model vehicle TRUE Plastics 50 NA NA
#> 2: M02 AircraftX model vehicle TRUE Plastics 85 3.0 28.33
#> 3: M03 Runner model people TRUE Wood 15 NA NA
#> 4: M04 Dancer model people FALSE Wood 16 0.6 26.67
#> 5: T01 SupCar toy vehicle TRUE Metal 120 10.0 12.00
#> 6: T02 SupPlane toy vehicle FALSE Metal 350 45.0 7.78
data.table的键可以不止一个。例如使用id和date定位toy_tests中的记录：
setkey(toy_tests, id, date)
现在提供key中的两个元素就可以获取记录了
toy_tests[.("T01", 20160201)]
#> id date sample quality durability
#> 1: T01 20160201 100 9 9
如果提供第一个元素，会返回匹配的多个值：
toy_tests["T01"]
#> id date sample quality durability
#> 1: T01 20160201 100 9 9
#> 2: T01 20160302 150 10 9
#> 3: T01 20160405 180 9 10
#> 4: T01 20160502 140 9 9
key不能错序，因此不能单独提供第2个元素以及反序排列。
toy_tests[20160201]
#> id date sample quality durability
#> 1: <NA> NA NA NA NA
toy_tests[.(20160202,"T01")]
#> Error in bmerge(i, x, leftcols, rightcols, io, xo, roll, rollends, nomatch, : x.'id' is a character column being joined to i.'V1' which is type 'double'. Character columns must join to factor or character columns.
对数据进行分组汇总
by是data.table中另一个重要参数（即方括号内的第3个参数），它可以将数据按照by值进行分组，并对分组计算第2个参数。
接下来，我们学习如何通过by以简便的方式实现数据的分组汇总。
最简单的用法是计算每组的记录条数：
product_info[, .N, by = released]
#> released N
#> 1: TRUE 4
#> 2: FALSE 2
分组的变量可以不止一个，例如由type和class确定一个分组：
product_info[, .N, by = .(type, class)]
#> type class N
#> 1: model vehicle 2
#> 2: model people 2
#> 3: toy vehicle 2
可以对每个分组进行统计计算，这里计算防水和非防水产品的质量得分均值：
product_tests[, mean(quality, na.rm = TRUE), by = .(waterproof)]
#> waterproof V1
#> 1: no 10.00
#> 2: yes 5.75
可以看到结果存储在V1列中，我们可以手动指定列名：
product_tests[, .(mean_quality = mean(quality, na.rm = TRUE)), by = .(waterproof)]
#> waterproof mean_quality
#> 1: no 10.00
#> 2: yes 5.75
注意操作需要�放在list中进行（.()）。
我们可以将多个[]按顺序连接起来，形成工作流（类似管道%>%）。
下面的例子中，首先使用通用键id将product_info和product_tests连接起来，然后筛选已发布的产品，再按type和class进行分组，最后计算每组的quality和durability的均值。
type_class_test0 = product_info[product_tests][released == TRUE,
.(mean_quality = mean(quality, na.rm=TRUE),
mean_durability = mean(durability, na.rm=TRUE)),
by = .(type, class)]
type_class_test0
#> type class mean_quality mean_durability
#> 1: toy vehicle NaN 10.0
#> 2: model vehicle 6 4.5
#> 3: model people 5 NaN
在返回的data.table中，by所对应的组合中的值是唯一的，虽然实现了目标，但结果中没有设置键：
key(type_class_test0)
#> NULL
这种情况下，我们可以使用keyby来确保结果的data.table自动将keyby对应的分组向量设置为键。一般data.table会保持原来的顺序返回，有时候我们想要设定排序，keyby也可以实现，所以是一举两得：
type_class_test = product_info[product_tests][released == TRUE,
.(mean_quality = mean(quality, na.rm = TRUE),
mean_durability = mean(durability, na.rm = TRUE)),
keyby = .(type, class)]
type_class_test
#> type class mean_quality mean_durability
#> 1: model people 5 NaN
#> 2: model vehicle 6 4.5
#> 3: toy vehicle NaN 10.0
key(type_class_test)
#> [1] "type" "class"
下面可以直接用键来获取值：
type_class_test[.("model", "vehicle"), mean_quality]
#> [1] 6
对大数据集使用键进行搜索，能够比迭代使用逻辑比较快得多，因为键搜索利用了二进制搜索，而迭代在不必要的计算上浪费了时间。
下面举例说明，首先创建有1000万行的数据，其中一列是索引列id，其他两列是随机数：
n = 10000000
test1 = data.frame(id = 1:n, x = rnorm(n), y = rnorm(n))
现在查找id为876543的行，看要花多少时间：
system.time(row <- test1[test1$id == 876543, ])
#> 用户 系统 流逝
#> 0.132 0.018 0.150
作为对比，我们使用data.table来完成这个任务，使用setDT()将数据框转换为data.table，该函数可以原地转换，不需要复制，并可以设定键。
setDT(test1, key = "id")
class(test1)
#> [1] "data.table" "data.frame"
现在我们搜索相同的元素：
system.time(row <- test1[.(876543)])
#> 用户 系统 流逝
#> 0.001 0.000 0.000
结果一致，但data.table用的时间要少得多。
重塑data.table
data.table扩展包为data.table对象提供了更强更快得dcast()和melt()函数。
例如将toy_tests的每个产品质量得分按照年和月进行对齐
toy_tests[, ym := substr(date, 1, 6)]
toy_quality = dcast(toy_tests, ym ~ id, value.var = "quality")
toy_quality
#> ym T01 T02
#> 1: 201602 9 7
#> 2: 201603 10 8
#> 3: 201604 9 9
#> 4: 201605 9 10
data.table::dcast()提供了更强大的多变量支持：
toy_tests2 = data.table::dcast(toy_tests, ym ~ id, value.var = c("quality", "durability"))
toy_tests2
#> ym quality_T01 quality_T02 durability_T01 durability_T02
#> 1: 201602 9 7 9 9
#> 2: 201603 10 8 9 8
#> 3: 201604 9 9 10 8
#> 4: 201605 9 10 9 9
看到没，data.table可以自动将id值与质量分类连接起来。
此时ym是键：
key(toy_tests2)
#> [1] "ym"
我们可以利用它提取数据：
toy_tests2["201602"]
#> ym quality_T01 quality_T02 durability_T01 durability_T02
#> 1: 201602 9 7 9 9
使用原地设置函数
我们知道R存在复制修改机制，这在进行大数据计算时开销很大，data.table提供了一系列支持语义的set函数，它们可以原地修改data.table，因此避免不必要的复制。
仍以product_stats为例，我们可以使用setDF()函数不要任何复制就可以将data.table变成data.frame。
product_stats
#> id material size weight density
#> 1: M01 Plastics 50 NA NA
#> 2: M02 Plastics 85 3.0 28.33
#> 3: M03 Wood 15 NA NA
#> 4: M04 Wood 16 0.6 26.67
#> 5: T01 Metal 120 10.0 12.00
#> 6: T02 Metal 350 45.0 7.78
setDF(product_stats)
class(product_stats)
#> [1] "data.frame"
setDT()可以将任意的data.frame转换为data.table，并设置键。
setDT(product_stats, key = "id")
class(product_stats)
#> [1] "data.table" "data.frame"
使用setnames()可以对列重命名：
setnames(product_stats, "size", "volume")
product_stats
#> id material volume weight density
#> 1: M01 Plastics 50 NA NA
#> 2: M02 Plastics 85 3.0 28.33
#> 3: M03 Wood 15 NA NA
#> 4: M04 Wood 16 0.6 26.67
#> 5: T01 Metal 120 10.0 12.00
#> 6: T02 Metal 350 45.0 7.78
如果给行添加索引，使用：
product_stats[, i := .I]
product_stats
#> id material volume weight density i
#> 1: M01 Plastics 50 NA NA 1
#> 2: M02 Plastics 85 3.0 28.33 2
#> 3: M03 Wood 15 NA NA 3
#> 4: M04 Wood 16 0.6 26.67 4
#> 5: T01 Metal 120 10.0 12.00 5
#> 6: T02 Metal 350 45.0 7.78 6
为方便，索引一般在第1列，所以我们要修改列的顺序：
setcolorder(product_stats, c("i", "id", "material", "weight", "volume", "density"))
product_stats
#> i id material weight volume density
#> 1: 1 M01 Plastics NA 50 NA
#> 2: 2 M02 Plastics 3.0 85 28.33
#> 3: 3 M03 Wood NA 15 NA
#> 4: 4 M04 Wood 0.6 16 26.67
#> 5: 5 T01 Metal 10.0 120 12.00
#> 6: 6 T02 Metal 45.0 350 7.78
data.table的动态作用域
我们不仅可以直接使用列，也可以提前定义注入.N、.I和.SD来指代数据中的重要部分。
为演示，我们先创建新的data.table，命名为market_data，其中date列是连续的。
market_data = data.table(date = as.Date("2015-05-01") + 0:299)
head(market_data)
#> date
#> 1: 2015-05-01
#> 2: 2015-05-02
#> 3: 2015-05-03
#> 4: 2015-05-04
#> 5: 2015-05-05
#> 6: 2015-05-06
向调用函数一样，我们给data.table添加数据列：
set.seed(123)
market_data[, `:=`(
price = round(30 * cumprod(1 + rnorm(300, 0.001, 0.05)), 2),
volume = rbinom(300, 5000, 0.8)
)]
注意这里的price和volumn都是服从正态分布的随机数：
head(market_data)
#> date price volume
#> 1: 2015-05-01 29.2 4021
#> 2: 2015-05-02 28.9 4000
#> 3: 2015-05-03 31.2 4033
#> 4: 2015-05-04 31.3 4036
#> 5: 2015-05-05 31.5 3995
#> 6: 2015-05-06 34.3 3955
我们以图形的方式展示数据：
plot(price ~ date, data = market_data,
type = "l",
main = "Market data")
数据准备好后，我们看看动态作用域如何让事情变得简单。
看下时间范围：
market_data[, range(date)]
#> [1] "2015-05-01" "2016-02-24"
将数据整合缩减为月度数据：
monthly = market_data[,
.(open = price[[1]], high = max(price),
low = min(price), close = price[[.N]]),
keyby = .(year = year(date), month = month(date))]
head(monthly)
#> year month open high low close
#> 1: 2015 5 29.2 37.7 26.1 28.4
#> 2: 2015 6 28.1 37.6 28.1 37.2
#> 3: 2015 7 36.3 41.0 32.1 41.0
#> 4: 2015 8 41.5 50.0 30.9 30.9
#> 5: 2015 9 30.5 34.5 22.9 27.0
#> 6: 2015 10 25.7 33.2 24.6 29.3
计算过程为：先根据by表达式将原始数据分割，分割后的每个部分都是原始数据的一个子集，并且原始数据和子集都是data.table。然后在每个子集data.table的语义中计算j表达式。
下面代码没有按组聚合数据，而是画了每年的价格图：
oldpar = par(mfrow = c(1, 2))
market_data[, {
plot(price ~ date, type = "l",
main = sprintf("Market data (%d)", year))
}, by = .(year = year(date))]
par(oldpar)
这里我们没有为plot()设定data参数，图像也成功绘制，这是因为该操作是在data.table的语义中进行的。
此外,j表达式还可以用于构建模型的代码，下面是一个批量拟合线性模型的例子。这里使用diamonds数据集。
data("diamonds", package = "ggplot2")
setDT(diamonds)
head(diamonds)
#> carat cut color clarity depth table price x y z
#> 1: 0.23 Ideal E SI2 61.5 55 326 3.95 3.98 2.43
#> 2: 0.21 Premium E SI1 59.8 61 326 3.89 3.84 2.31
#> 3: 0.23 Good E VS1 56.9 65 327 4.05 4.07 2.31
#> 4: 0.29 Premium I VS2 62.4 58 334 4.20 4.23 2.63
#> 5: 0.31 Good J SI2 63.3 58 335 4.34 4.35 2.75
#> 6: 0.24 Very Good J VVS2 62.8 57 336 3.94 3.96 2.48
该数据集包含超过5万条钻石信息的记录，每条记录了钻石的10个属性，现在我们队cut列中的每种切割类型都你拟合一个线性回归模型，由此观察每种切割类型中carat与depth是如何反映log(price)的信息。
diamonds[, {
m = lm(log(price) ~ carat + depth)
as.list(coef(m))
}, keyby = .(cut)]
#> cut (Intercept) carat depth
#> 1: Fair 7.73 1.26 -0.01498
#> 2: Good 7.08 1.97 -0.01460
#> 3: Very Good 6.29 2.09 -0.00289
#> 4: Premium 5.93 1.85 0.00594
#> 5: Ideal 8.50 2.13 -0.03808
动态作用域允许我们组合使用data.table内部或外部预定义的符号。举例，我们定义一个函数，计算market_data中由用户定义的列的年度均值：
average = function(column){
market_data[, .(average = mean(.SD[[column]])),
by = .(year = year(date))]
}
这里我们使用.SD[[x]]提取x列的值，这跟通过名字从列表中提取成分或元素相同。
下面计算每年的平均价格：
average("price")
#> year average
#> 1: 2015 32.3
#> 2: 2016 32.4
每年平均数量：
average("volume")
#> year average
#> 1: 2015 4000
#> 2: 2016 4003
我们可以利用此包专门的语法创造一个列数动态变化的组合，并且组合中的列是由动态变化的名称决定的。
这里我们假设添加额外的3列数据，每一列都是原始价格加了随机噪声生成的。不用重复调用market_date[, price1 := ...]，而是使用market_data[, (columns) := list(...)]来动态设定列，其中columns是一个包含列名的字符向量，list(...)是每个列对应的值：
price_cols = paste0("price", 1:3)
market_data[, (price_cols) := lapply(1:3,
function(i) round(price + rnorm(.N, 0, 5), 2))]
head(market_data)
#> date price volume price1 price2 price3
#> 1: 2015-05-01 29.2 4021 30.6 27.4 33.2
#> 2: 2015-05-02 28.9 4000 29.7 20.4 36.0
#> 3: 2015-05-03 31.2 4033 34.3 26.9 27.2
#> 4: 2015-05-04 31.3 4036 29.3 29.0 28.0
#> 5: 2015-05-05 31.5 3995 36.0 32.1 34.8
#> 6: 2015-05-06 34.3 3955 30.1 31.0 35.2
另一方面，如果表格有很多列，并且需要对它们的子集进行一些计算，也可以用类似的语法来解决。
举例，我们现在需要对每个价格列调用na.locf()以去掉缺失值，先获取所有的价格列：
cols = colnames(market_data)
price_cols = cols[grep("^price", cols)]
price_cols
#> [1] "price" "price1" "price2" "price3"
然后我们用类似的语法，并添加一个参数.SDcols = price_cols，这是为了让.SD中的列只是我们想要的那些价格列。
market_data[, (price_cols) := lapply(.SD, zoo::na.locf), .SDcols = price_cols]
head(market_data)
#> date price volume price1 price2 price3
#> 1: 2015-05-01 29.2 4021 30.6 27.4 33.2
#> 2: 2015-05-02 28.9 4000 29.7 20.4 36.0
#> 3: 2015-05-03 31.2 4033 34.3 26.9 27.2
#> 4: 2015-05-04 31.3 4036 29.3 29.0 28.0
#> 5: 2015-05-05 31.5 3995 36.0 32.1 34.8
#> 6: 2015-05-06 34.3 3955 30.1 31.0 35.2
最后，更多操作请前往https://github.com/Rdatatable/data.table/wiki查看完整功能列表。
data.table包功能快速学习见文章https://www.jianshu.com/p/ed499763a3a9
