R语言数据处理强悍包dplyr&reshape2&tidyr

R语言数据处理 dplyr&reshape2&tidyr 包详解

dplyr：轻松地处理data.frame, data.table以及多种数据库为基础的数据，实现选择、变换、分组等
plry：轻松地在vector, list, data.frame之间做分组变换，实现拆分、变换、合并的操作
reshpae2：横向、纵向做数据变换
非特别标注，默认为dplyr包

准备工作
tbl_df(iris) ：数据类型转化

将数据转化为tbl类型，更易于查看

glimpse(iris)：tbl数据的信息密集概括

View(iris)：以电子表格的样式显示数据集

%>% ：管道函数，将左边对象的第一个参数传递到右边的函数中

summary()：数据统计摘要；区别对待不同类型的数据变量- (1)数值型：相关极值等信息；(2)名义型/有序型：显示的是各水平的频数值

重组数据
改变数据集的布局

布局转换 - reshpae2 （数据透视）
melt(data, id.vars, measure.vars, factorsAsStrings = TRUE)：以id.vars为基准，转为长格式形式
melt(data, id=c(""), measure=c("") )
id=c("","") 或 id.vars=c() 以该变量为 [基准] 进行重构；其他的列均摞起来

measure=c("") 或 measure.vars=c() ：组合进id列的变量；若measure缺失，表示所有字段

varaiable.name ，表示将 各个变量的列名 放在这个列下面；

value.name，表示对应观测值的具体数值

na.rm = FALSE,

factorsAsStrings = TRUE,将因子转化为字符串

names(airquality) <- tolower(names(airquality))
View(airquality)
airquality_1 <- head(airquality,3)
aqm <- melt(airquality_1, id=c(“month”,“day”)) # 以该变量为 [基准] 进行重构；其他的列均 [摞起来]

melt(airquality_1, id=c(“month”,“day”)) # measure缺失时，默认选择所有的列
month day variable value
1 5 1 ozone 41.0
2 5 2 ozone 36.0
3 5 3 ozone 12.0
4 5 1 solar.r 190.0
5 5 2 solar.r 118.0
6 5 3 solar.r 149.0
7 5 1 wind 7.4
8 5 2 wind 8.0
9 5 3 wind 12.6
10 5 1 temp 67.0
11 5 2 temp 72.0
12 5 3 temp 74.0

melt(airquality_1, id.vars =c(“month”,“day”), measure=c(“wind”,“temp”))
month day variable value
1 5 1 wind 7.4
2 5 2 wind 8.0
3 5 3 wind 12.6
4 5 1 temp 67.0
5 5 2 temp 72.0
6 5 3 temp 74.0

dcast(data, formula, fun.aggregate = NULL)：以formula中的rowvar为基准列，重铸为宽格式 [excel统计表单的格式]；若加上FUN，则为 [数据透视表] 的格式
dcast(data, ID~variable, mean)
dcast的功能相当于 group_by + summarise 的功能

formula , rowvar1+rowvar2 ~ colvar1+colvar2的格式；

rowvar ：以此为基准的id列；
colvar ：需要重构的变量列；将该变量中的元素 [分类] 映射到 [列] 上去
运行后的结果：出现的变量，原本为变量的列名，融合后是不参与计算的；参与的是对应的value列
**若整个formula表达是中，均没有出现 variable列，默认即对其他所有的列默认做 [统计计数length] **

除非指定具体的FUN函数

fun.aggregate（聚合函数）：直接列出聚合函数的名称；默认为计数 [length]

margins = NULL；向量形式的变量名字；

若为TRUE，则计算所有的合计
margins= “colname” / “rowname” 即表达式中出现的变量名
subset = NULL；针对特定的变量类别做重铸；但需要加载plyr包去接收函数

选择 行中分类值 或者 variable列中的分类 “length” 进行重铸
subset = .(variable==“length”) 或者 subset = .(month == 5 )
subset = .(time < 10 & chick < 20)
fill = NULL； 填充NA的值

drop = TRUE；对缺失值的处理；drop or Not

names(airquality) <- tolower(names(airquality))
View(airquality)
aqm <- melt(airquality, id=c(“month”, “day”), na.rm=TRUE) # 除了month和day两列，其他列摞起来，为了等长，m和d列循环对齐

dcast(aqm, day + variable ~ month) # 保持day和variable不变，按month中的元素 [分类] 映射到列上去(若month有5、6两个月，则分别有2列)
dcast(aqm, variable + day ~ month) # 换一下顺序，重复的variable连在一起，对应不一样的day，这样的方式排列
dcast(aqm, day ~ variable + month) # 只保留day列
dcast(aqm, day+month ~ variable) # 还原为原本的样子

表达式中均未出现variable列，即默认把其他列的每一行看做一个整体进行计算-#

dcast(aqm, day ~ month) # 当整个formula表达是中，均没有出现 variable列，即对其他所有的列默认做长度计算length
day 5 6
1 1 4 3 # 表示day为1，month为5时，共有4个变量
2 2 4 3
3 3 4 3
4 4 4 3

dcast(aqm, day ~ month, mean) # 对所有没有出现的变量做函数mean
day 5 6
1 1 76.35000 124.20000
2 2 58.50000 123.56667
3 3 61.90000 108.36667
4 4 101.12500 93.06667

-------加入计算：等价于group_by + summarise------------------------------#

正常情况下含variable

dcast(aqm , month~variable)
Aggregation function missing: defaulting to length # 默认为计数
month ozone solar.r wind temp
1 5 26 27 31 31
2 6 9 29 29 29

dcast(aqm , month~variable, mean)
month ozone solar.r wind temp
1 5 23.61538 181.2963 11.62258 65.54839
2 6 29.44444 191.9655 10.34483 78.96552

------加入合计：margins-------------------

dcast(aqm , month~variable,sum, margins = T)
month ozone solar.r wind temp (all)
1 5 614 4895 360.3 2032 7901.3
2 6 265 5567 300.0 2290 8422.0
3 (all) 879 10462 660.3 4322 16323.3

dcast(aqm , month~variable,sum, margins = “month”)

--------加入子集的选取subset-------------------

library(plyr) # needed to access . function
dcast(aqm, variable ~ month, mean, subset = .(variable == “ozone”))
dcast(aqm, variable ~ month, mean, subset = .(month == 5))

names(ChickWeight) <- tolower(names(ChickWeight))
chick_m <- melt(ChickWeight, id=2:4, na.rm=TRUE)
dcast(chick_m, chick ~ time, mean, subset = .(time < 10 & chick < 20)) # 多条件选取
dcast 和 acast区别
dcast(aqm, variable + month ~ day)
acast(aqm, variable + month ~ day) # acast和dcast的功能基本上相同，只是dcast会把 [分组信息] 作为一列或几列显示，而acast会将其作为行名
acast(aqm, day ~ month, mean) # 保留的列作为合并在一起作为列名（少了day列，不建议使用）
acast(aqm, variable ~ month ~ day) # acast 多出来的功能，生成一个三维数组，按照day的值分成31个矩阵

t(x) ：转置
mtcars <- mtacrs[, c(12,1:11) ] ：列重新排序

排序
arrange(mtcars, desc(mpg),var) ：根据变量进行排序
arrange(flights, desc(dep_delay - arr_delay))：对计算的数据进行计算
默认为升序，aes

返回行/列名 - Basic
colnames(object)：返回所有列的名称
names(object)
rownames(object)：返回所有行的名称 [二维以上的任何对象]
row.names(object)

重命名列变量
rename(tbl, y=year)：将变量名year变更为y
rename(data, newname=oldname) # 新的列名在前
select(df2tbl, x1 = x, y1 = y)：选择变量时，重命名；x1为新的列名
fix(object)：可以同时改变格式 numeric / character 【Basic】

data_frame(a=1:3, b=3:5)：将向量合并为数据框

合并 & 分割 - Tidyr
separate(data, col, into, sep="[¹]+", remove=TRUE, convert=FALSE, extra=“warm”, fill=“warm”)：将一列分隔为几列
data：

col ：待分隔的列

into=c("","")：新的列名

sep：分隔符；

若为字符串，作为正则表达式进行匹配（默认）
若为数值型，则根据位置进行匹配（-1代表最后一位）
remove =TRUE，移除原来的待分隔的列

convert=FALSE， 若为TRUE，则进行格式转换

separate_rows(data, …, sep="", convert=FASLE)：把一列分隔为若干行

unite(data, col, …, sep="_", remove=TRUE)：把几列合并为一列
… : 指定需要合并的列名

col="" :合并后新增的列名

unite(table, century, year, col=“year”, sep="")

重编码&排名 - 参见 [创建新变量]

合并数据集
合并联接 - Join
等价于SQL中的join联接

inner_join(a, b，by=“x1”) ：内联接 合并数据，仅保留匹配的数据
left_join(a, b, by=“x1”) ：以a表为基准表，加入与a表中x1列匹配的数据集b的记录
right_join(a, b, by=“x1”) ：以b表为基准表，加入与b表中x1列匹配的数据集b的记录
outer_join(a,b, by=“x1”)：保留所有数据，所有行
by = NUll（默认）；表示为 自联接，自动选取 [相同的列] 作为索引

by=c(‘col1’, ‘col2’)：两个表中相同名称列的匹配
by=c(‘col1’ = ‘col2’) ：两个表中不同名称列之间的匹配
copy=False(默认)； 若为True, 当a与b不为同一张表，会自动创建一个y的表

集处理 - 行
intersect(y, z)：均出现在数据集y和z中的记录行
union(y, z)：出现在y或者z中的记录，自动删除重复的值
setdiff(y, z)：仅出现在数据集y 而不在z中的记录行

合并与筛选
仅返回匹配列的记录

semi_join(a, b, by=“x1”)： 数据集a中能与b匹配的记录，以a表中"x1"列的值为索引
anti_join(a, b, by=“x1”) ：数据集a中能与b不能匹配的记录，以a表中"x1"列的值为索引

插入行/列
bind_rows(y, z) ：插入新行；把数据集 z 作为新的行添加到y中
bind_cols(y, z)： 添加新列；把数据集 z 作为新的行添加到y中（注意：数据按所在位置匹配）

数据选取
子集观测值 - 行
filter(tbl_df, cond & cond) ：根据逻辑条件选取，使用 &或者| 来进行设置
filter(hflights_df, Month == 1, DayofMonth == 1)
filter(tbl_df, x %in% c(“a”,“b”)) ：表示x中包含"a"或者"b"的值，返回为逻辑为真
filter(iris,Species!=“setosa”) / filter(iris,!Species %in% c(“setosa”))：排除某些行 !
filter() %>% select(., var)：选中子集中的特定列
对于多条件的选择，需要完整条件的，然后使用集合运算符将条件拼接起来。

& 、|

==、 >=、<>、!=

%in%

sample_frac(iris, 0.5, replace=False)：按比例进行随机选取
sample_n(iris, 10, replace=True) ：按数量进行随机选取

replace = False(默认)，表示是否替换

slice(mtcars, n:n)： 通过行数的位置进行选取， 等价于data[n:n, ]

top_n(mtcars, 1, desc(carb) )：选取并排列前n条记录；相当于先按某变量进行排序，然后选择前n条记录。

top_n(tbl_df, n [,wt])
若为分组数据，则按组排序

wt，用于进行排序的变量，可选；若不指定，默认为最后一个变量

-n，从底部开始选择n个数据

子集变量 - 列
Selection drops variables that are not in the selection while renaming retains them

select(mtcars, hp) ：通过列名或帮助函数选取列变量
select(tbl_df, mpg:hp)：；选取在mpg和hp之间的连续多个变量 （包含mpg&hp；用:连接
select(tbl_df, -var) / select(tbl_df, -(var1:var4))：通过-来排除某个变量列
select(tbl, xxx )：通过帮助函数进行选择
starts_with(“x”)：列名中以元素x为首的列
ends_with(“x”)：列名中以元素x结尾的列
contains(“x”)：包含元素x的列
matches(".t")：符合指定匹配正则表达式的列
one_of(c("mpg,“hp”) )：名字在指定组中的列，等价于 select(tbl, mpg, hp)
everything()：所有列，一般调整数据集中变量顺序时使用
select(df2tbl,y,everything()) #将变量y放到最前
num_range(“x”, 1:5)：选取名为x1、x2、x3、x4、x5的列
select_if()：选取不同条件的列
hflights %>% select_if(is.factor)：选取hflights数据中为因子的列 / is.numeric
hflights %>% select_if(function(col) is.numeric(col) && mean(col) > 3.5)：选取hflights数据中某一变量列 ？？

唯一值
distinct(iris)：删除重复记录
distinct(hflights_df, Month, .keep_all = TRUE)

.keep_all = TRUE,指保留除Month以外的其它列的内容。默认的情况是不保存其他列的。

指各个变量列均相同的记录

unique(x)：只对向量可用；或对各行中各变量完全相同的行取一行
!duplicated(x)： 返回逻辑值；若完全相同则为TRUE，可对data.frame使用
x[!duplicated(x)] ：选取不重复值的值
返回data中所有不相同的值，然后在进行行选取data[x, ]

删除各行中变量完全相同的值 = unique(x)

data <- data[!duplicated(data), ] --# 返回各列所有相同的值 data[duplicated(test),]

删除某变量中相同的值

data <- data[!duplicated(test[, “var”]), ]

删除某两个变量完全相同的行

data <- data[!duplicated(test[, c(“var1”,“var2”)], ]

创建新变量
根据是否删除原列进行区分

计算并添加新列
若要将多个单元格中的值合并，用stringr包中的str_c()

运用$直接创建mtcars$new <- sqtr(mtcars$carb)
mutate(tbl_df, var3=var1+var2, var4=var3+…)：优势在于可对刚添加的列进行变换
mutate_each(iris, funs(min_rank), [var1,var2])：对每一列运行窗口函数
mutate_all()：对每一列运行窗口函数
mutate_at()：对指定的列运行窗口函数
mutate_if()：对指定类型的列运行窗口函数
窗口函数:

min_rank # 排序，并列时，其他序号延号

dense_rank #无缝排序

row_number # 排序。并列时将并列数在前的序号在前

percent_rank # 把数据在[0,1]中重组，并排序

lead # 把除第一个值以外的所有元素提前，最后一位为NA

lag # 把除最后一位以外的所有数据延后，第一个元素为NA

between() # 数据在a、b之间

ntile # 把数据分为n分

cute_dist # 累计分布

cummean # 累积mean函数

cumsum # 累积sum函数

cusmax # 累积max函数

cusmin # 累积min函数

cumall # 累积all函数

cumany # 累积any函数

cumprod # 累计prod函数

pmax # 针对元素的max函数；返回输入中最大的值，并将其长度自动扩大到输入中长度最大的那个向量

pmin # 针对元素的min函数

​

计算并删除其他列
transmute(df, var3=var1+var2)：该函数扩展新变量的同时，将删除原始变量 ；常伴有na.rm=T
na.rm= True 计算时排除NA值

mutate(head(airquality),Temp=Temp - 32)
Ozone Solar.R Wind Temp Month Day
1 41 190 7.4 35 5 1
2 36 118 8.0 40 5 2
3 12 149 12.6 42 5 3
4 18 313 11.5 30 5 4
5 NA NA 14.3 24 5 5
6 28 NA 14.9 34 5 6

transmute(head(airquality),Temp=Temp - 32)
Temp
1 35
2 40
3 42
4 30
5 24
6 34

排名
row_number()：对于相同的值，位置在前的排名在前。
min_rank()：对于相同的值，均显示排名较前的值。
dense_rank()：对于相同的值，类似于min_rank()，均显示排名较小的值；但与后一位之间没有间隔；
percent_rank()：将排名缩放为[0,1]之间的值
cume_dist()：累计的分布函数
ntile(x,n)：将x划分为n个组块

x <- c(5, 1, 3, 2, 2, NA)
row_number(x)
[1] 5 1 4 2 3 NA

min_rank(x) # 相同的值，排名较前的值
[1] 5 1 4 2 2 NA

dense_rank(x) # 相同的值，排名较前的值，但与后一位没有间隔
[1] 4 1 3 2 2 NA

percent_rank(x)
[1] 1.00 0.00 0.75 0.25 0.25 NA

cume_dist(x)
[1] 1.0 0.2 0.8 0.6 0.6 NA

ntile(x, 2)
[1] 2 1 2 1 1 NA

重编码
if_else() & case_when() 适合进行重编码，但缺少对象的输入，可结合within()

因为recode是**面向 [向量] **的函数

常规编码 - within / $
within(x, {}) ：对x中的对象做运算
within：能对原始数据进行修改
with()：不能对原始数据进行修改，创建的变量只能在花括号之内有效（即使进行赋值也是如此）

aq<-with(head(airquality), {

• lOzone <- log(Ozone)
• Month <- factor(month.abb[Month])
• cTemp <- round((Temp - 32) * 5/9, 1)
• S.cT <- Solar.R / cTemp
• rm(Day, Temp)
• #head(aq)
• })

aq
NULL # 显示为NULL，即aq不存在

aq<-within(head(airquality), { # Notice that multiple vars can be changed

• lOzone <- log(Ozone)
• Month <- factor(month.abb[Month])
• cTemp <- round((Temp - 32) * 5/9, 1) # From Fahrenheit to Celsius
• S.cT <- Solar.R / cTemp # using the newly created variable
• rm(Day, Temp)
• })

aq
Ozone Solar.R Wind Month S.cT cTemp lOzone
1 41 190 7.4 May 9.793814 19.4 3.713572
2 36 118 8.0 May 5.315315 22.2 3.583519
3 12 149 12.6 May 6.394850 23.3 2.484907
4 18 313 11.5 May 18.742515 16.7 2.890372
5 NA NA 14.3 May NA 13.3 NA
6 28 NA 14.9 May NA 18.9 3.332205

**Recode(var, recodes, as.factor.result, as.numeric.result=TRUE, levels) **：car包中的Recode函数，用法与car包中的recode函数相同；无需通过指定car包来运行；
var：字符型、数值型、因子型 向量

recodes：字符串格式的重编码方式；即编码内容需用 引号" "包括起来，多个条件之间用分号;分隔

单个变量：“0=NA”
一组向量：“c(7,8,9)=‘high’”
一组序列变量：“7:9=‘C’”
未匹配的值： “else=NA”
字符串变量："‘a’=‘b’ " 若编码的内容为字符串格式，需要用引号括起来；而最外面的引号也是必不可少的
as.factor.result = T/F；当输入的var为因子格式时，默认为TRUE,否则默认为FALSE

as.numeric.result=T/F；当输入的var为数值格式时，默认为TRUE,否则默认为FALSE

levels：可选的，默认为原本的顺序

recode(.x, a= ‘apple’, .default = NULL, .missing = NULL)：保持原有的顺序水平；
recode_factor(.x, …, .default = NULL, .missing = NULL, .ordered = FALSE)：
.x : 进行处理的向量
对于数值型向量，你可以基于位置替换它
对于字符串，你可以基于字符串的名称来替换它
指定替换的变量为字符串 a = ‘apple’ : a为对象中要变更的值；'apple’为变更后的值
.default=NULL: 对未匹配的值不做变更；
.default=NA_character_ ：用NA替换未匹配的值
.default= ‘others’ : 可以指定替换的值
.default = level(x) ：支持对默认的顺序进行因子化
指定替换的变量为数值 2 =20 或 20L
若对象x为向量is.vector() ，若不加L，则对于未匹配的值默认用NA替换；加L，对其他未匹配的值不做变更； ？？？
.missing = NULL(默认) ：对缺失值NA不做处理，默认为NA；
.missing = “missing”：指定具体的值对NA进行替换
若不指定替换的变量，默认按照位置顺序进行重编码；但对未匹配的值默认用NA替换

.order=FALSE(默认)：若为TRUE，则创建有序的因子

当输入的向量是可比较的，它的因子会被重新定义为默认的

指定替换的变量 - 字符串

x <- sample(c(“a”, “b”, “c”), 10, replace = TRUE)
x
[1] “a” “a” “b” “b” “a” “b” “a” “a” “a” “c”

recode(x, a = “Apple”)
[1] “Apple” “Apple” “b” “b” “Apple” “b” “Apple” “Apple” “Apple” “c”

recode(x, a = “Apple”, .default = NA_character_)
[1] “Apple” “Apple” NA NA “Apple” NA “Apple” “Apple” “Apple” NA

指定替换的变量 - 数值型

x <- c(1:5)
recode(x, ‘2’= 20L, ‘4’ = 40L) # 加上L之后，对未匹配的值不做变更
[1] 1 20 3 40 5

recode(x, ‘2’= 20, ‘4’ = 40)
[1] NA 20 NA 40 NA

若不指定替换的变量，默认按照顺序进行重编码

recode(x, “a”, “b”, “c”) # 但对未匹配的值默认用NA替换
[1] “a” “b” “c” NA NA NA

#--------recode_factor------------------------------------------#

recode_factor(factor(letters[1:3]), b = “z”, c = “y”) # 当输入的向量是可比较的，它的因子会被重新定义为默认的
[1] a z y
Levels: z y a

条件编码
if_else(cond, true_value, false_value, missing=NULL)：对于逻辑值的重编码
cond : 条件

missing = NULL(默认)； 若对缺失值替换为某个值，需指定 “x”

常规重编码

leadership<-within(leadership,{
agecat<-NA
agecat[age>75] <- “Elder”
agecat[age>=55 & age<=75] <- “Middle aged”
agecat[age<55]<-“young”
})

y$new<-i{f}_{e}lse(y$new<=1, 10, y$new)

搭配within使用

within(y,{
carb <- if_else(carb<=2,20,carb)
})

case_when(cond ~ “”, TRUE ~ “”)：多条件的重编码
类同于SQL的case when；多条件之间按顺序进行执行。
~ ：表示赋值

TRUE ：类同于 Else的功能

配合list() 与 !!!，将语句进行拼接，然后执行

x <- 1:10
case_when(
x %% 3 == 0 ~ “fizz buzz”,
x %% 5 == 0 ~ “fizz”,
x %% 7 == 0 ~ “buzz”,
TRUE ~ as.character(x)
)

创建一个新变量

starwars %>%
select(name:mass, gender, species) %>%
mutate(
type = case_when(
height > 200 | mass > 200 ~ “large”,
species == “Droid” ~ “robot”,
TRUE ~ “other”
)
)

配合list() 与 !!!，将语句进行拼接，然后执行

patterns <- list( # 先将语句拼接
TRUE ~ as.character(x),
x %% 5 == 0 ~ “fizz”,
x %% 7 == 0 ~ “buzz”,
x %% 35 == 0 ~ “fizz buzz”
)
case_when(!!! patterns) # 用 !!! 执行

缺失值
检查与判断
is.na(x)：逻辑判断
colSums(is.na(x))：求该列缺失值的数量
mean(is.na(x))：求该列缺失值的比例
is.nan(x)：判断不可能值
is.infinite(x) ：判断无穷值

移除
na.rm=T：在计算之前将缺失值移除，可用在函数内部
na.omit(x)： 移除所有含缺失值所在的行 [删除整行]

用来存储没有缺失值的数据

newdata <- na.omit(mydata)

缺失值重编码
na_if(x, y)：把对象x中的y替换为NA

x <- c(1, -1, 0, 10)
[1] 1 -1 0 10

na_if(x,0)
[1] 1 -1 NA 10
coalesce(x,y)：把对象x中的NA替换为y
x, y ：均为向量

把x中的NA替换为y

x <- sample(c(1:5, NA, NA, NA)); x
[1] 5 3 NA 4 2 NA 1 NA
coalesce(x, 0L)
[1] 5 3 0 4 2 0 1 0

将NA匹配为对应位置的值 （y, z 两者长度必须相同）

y <- c(1, 2, NA, NA, 5)
z <- c(NA, NA, 3, 4, 5)
coalesce(y, z)
[1] 1 2 3 4 5

配合list() 与 !!!，将语句进行拼接，然后执行

vecs <- list(
c(1, 2, NA, NA, 5),
c(NA, NA, 3, 4, 5)
)
coalesce(!!! vecs)

其他
pmin/pmax(…, na.rm=FALSE)：返回输入中最小/最大值的向量组合，并将其长度自动扩大到输入中长度最大的那个向量
min/max()：只返回单一长度的值

pmax(5:1,10)
[1] 10 10 10 10 10

概述函数 - summairse
summarise(iris, avg=mean(Sepal.Length)) ：对数据进行概述，并创建新的子集 （将数据概括为单行数值）
summarise_all(.tbl, .funs, …)：对每一列运行概述概述
summarise_each(iris, funs(mean)) ：对每一列运行概述函数
summarise_at(.tbl, .vars, .funs, …, .cols=NULL)：对指定的列运行概述函数
summarise_at(mtcars, vars(hp,mpg), mean, …, .cols=NULL)
vars() : 表示需要进行概述的列

.funs的用法

直接在函数中写明需要运行的函数 summarise(., vars(), mean)
结合funs写出调用的函数 summarise(., vars(), funs(mean))
summarise_if(.tbl, .predicate, .funs)：对指令类型的列运行概述函数
funs的用法

summarise_all(df1[,-1],funs(mean,sum)) # 若出现两个及以上的函数，列名中自动添加后缀
summarise_all(df1[,-1],funs(sum(.*2))) # 所有数据用.表示
summarise_all(df1[,-1],funs(medi=median)) # 指定得到的列后缀名
summarise_all(df1[,-1],funs(“in”=median)) # 或者加引号 (因为in在R中表示其他含义)
mutate_all(df1[,-1],funs(.^2))

min / max / mean / median / sd / var / sum / IQR (向量的四分位距离)

n （向量中元素的个数）/ n_distinct （不同元素的个数）

first / last / nth （向量的第n个值）

name1 <- c(“Bob”,“Mary”,“Jane”,“Kim”)
weight <- c(60,65,45,55)
height <- c(170,165,140,135)
weta <- 1:4
df1 <- data.frame(name1,weight,height,weta);df1

需指定要进行计算的列

summarise(df1,avg_weight=mean(weight),avg_height=mean(height))

对选出来的 [每一列] 都进行计算

summarise_all(select(df1,-1), mean)

配合vars函数，一次选择多列

summarise_at(df1,vars(weight,height,weta),mean)
summarise_at(df1,vars(weight:weta),mean)
u <- c(“weight”,“height”)
summarise_at(df1,vars(one_of(u)),mean) # 可以接字符串向量
summarise_at(df1,u,mean) # 也可以直接接字符串向量
summarise_at(df1,u,mean,trim=1) # mean的参数可以接在后面

summarise_at(df1,vars(contains(“eig”)),mean) # 匹配含有的
summarise_at(df1,vars(matches(".t.")),mean) # 使用正则表达式
summarise_at(df1,vars(starts_with(“w”)),mean) # 匹配以此为开头的
summarise_at(df1,vars(ends_with(“ht”)),mean) # 匹配以此为结尾的
summarise_at(df1[,-1],vars(everything()),mean) # 选择所有列

检验出所有是数值的列，全部求均值

summarise_if(df1,is.numeric,mean)

count(iris, Species [, wt=Sepal.Length]) ：计算变量中每一个特定值的行数/频率/求和 （带或不带权重）

若出现wt，表示进行 [求和] ；

wt="" 可选；若缺失，则计算频率

count(iris, Species) # 分组计算Species列中各类别的频量；类似于基本函数包中的table函数

wt="",若指定某一列，则会通过计算非缺失值的总和来比对权重(weighted)；

wt = var2 ， 表示按var中的类别来分组，计算var2中未缺失值的对应的 [求和]

count(iris, Species, wt=Sepal.Length) # 即按Species分组后，求对应Sepal.Length中的值的总和
–等价于 iris %>% group_by(., Species) %>% summarize(., sum(Sepal.Length))

sort = False

计数
length(x)：返回一组向量（包括列表）或因子的长度

返回对象的个数 或者 某个列的的观测值行数

length(object/data$col)

返回非空置的行数

length(na.omit(object/data$col))

返回对象的唯一值的行数

length(unique(data$col/object)) # 等价于 n_distinct()
nrow() / ncol()：总行数/总列数
n()：返回观测行的行数，不能单独使用（可被用于 summarise()、mutate()、filter() ）
n_distinct(x, na.rm=FALSE)：返回不重复的行数
sum(!is.na())：计算非空值的行数

分布
mean(x, na.rm=FALSE) ：返回均值；
mean(!is.na()) ：非空值的均值
median(x, na.rm=FASLE)：返回中位数
sum(x, na.rm=FALSE)：返回求和
range(object)：值域
colSums(x) / rowSums(x)：各列/行求和
colMeans(x) / rowMeans(x)：各列/行求均值

位置与序列
first(x)/last(x)：最前/后的值
nth(x, n)：从开始数的第n个值
quantile(x, probs=seq(0, 1, 0.25), na.rm=FALSE)：显示x中处于[0,0.25,0.5,0.75,1]的值
probs = seq(0,1, 0.25) 或者 = c(0.25,0.5) ：指定要显示的所处位置的值

min/max(x, na.rm=FALSE)：返回最大/最小值

趋势
IQR()：四分位距离
var()：方差
sd()：标准差
mad()：绝对均方差

数字处理
options(digits=7) ：默认有效位数为7位
trunc(x)：取整 trunc(3.531) [1] 3
floor(x)：向下取整
ceiling(x)：向上取整
sigif(x, digits=n)：指定最小值的有效位数
abs(x)：绝对值
x %% y ：求余数
x^n：幂次方
exp(x)：指数
ln(x) / log(x, y)：对数
sqrt(x)：平方根

分组
group_by(.data, …, add=FALSE)：根据Species进行分组
group_by(mtacrs, cyl,vs )
… ： 表示用于分组的列名；

add= FALSE(默认)

FALSE，表示会覆盖原来的分组，相当于对源数据重新分组；
若为TRUE,则不覆盖，相当于在原来的基础上在进行分组；

先对mtcars按cyl 进行分组

by_cyl <- mtcars %>% groupby(cyl)

--------add=FALSE (默认)-------------------------#

by_cyl %>% group_by(vs, am) %>% # add默认为FALSE，即对 mtcars进行 vs,am 两个变量进行分组；
summarise_at(.,vars(new),funs(mean) )

A tibble: 4 x 3

Groups: vs [?]

 vs    am      new

1 0 0 1.737751
2 0 1 2.115355
3 1 0 1.404061
4 1 1 1.177520

与如上等价

group_by(mtcars, vs,am) %>% summarise_at(.,vars(new),funs(mean) )

A tibble: 4 x 3

Groups: vs [?]

 vs    am      new

1 0 0 1.737751
2 0 1 2.115355
3 1 0 1.404061
4 1 1 1.177520

--------add=TRUE ----------------------#

by_cyl %>% group_by(vs, am, add=TRUE) %>%

• summarise_at(.,vars(new),funs(mean) )

A tibble: 7 x 4

Groups: cyl, vs [?] # 分组变量有3个

cyl    vs    am      new

1 4 0 1 1.414214
2 4 1 0 1.276142
3 4 1 1 1.177520
4 6 0 1 2.149830
5 6 1 0 1.500000
6 8 0 0 1.737751
7 8 0 1 2.414214

group_by(mtcars, cyl,vs,am) %>% summarise_at(.,vars(new),funs(mean) )

A tibble: 7 x 4

Groups: cyl, vs [?] # 分组变量有3个

cyl    vs    am      new    

1 4 0 1 1.414214
2 4 1 0 1.276142
3 4 1 1 1.177520
4 6 0 1 2.149830
5 6 1 0 1.500000
6 8 0 0 1.737751
7 8 0 1 2.414214
ungroup(iris)：移除数据框的分组信息
group_by_all()：
group_by_at(.tbl, .vars, .funs = list(), …, .add = FALSE)：
group_by_at(df, vars(accept,weight)) %>% summarise(., var=mean(height),count=n())
group_by_at() 与 group_by 的区别，仅在与at中将分组的变量用 vars() 包含起来，利于查看

group_by_if()：
iris %>% group_by(., Species) %>% summarize(., sum(Sepal.Length))：对每一个分组分别进行概述计算
iris %>% group_by(., Species) %>% mutate(., …)：按组计算新变量

分组&概述函数

plyr - 分隔-操作-合并
用来切割、计算、合并数据的包

在一个函数内同时解决spilt-apply-combine的三个步骤

Spilt：把要处理的数据分割成小的片段
Apply：对每个小片段进行操作
Combine:把片段重新组合
aplyr(.data, .margins, .fun, …, .progress = “none”)*
dplyr(.data, .variables, .fun, …, .progress = “none”)*
lplyr(.data, .fun, …, .progress = “none”)*
首字母代表输入的待处理的数据格式，第二个字母-输出的数据格式；

ddply(.data, .variables, .fun = NULL, …, .progress = “none”, .inform = FALSE, .drop = TRUE, .parallel = FALSE, .paropts = NULL)：以ddplyr为例
ddply()函数会自动的将分割后的每一小部分的计算结果汇总，以data.frame的格式保存。

.data, 要操作的原始数据集

.variables, 是按照某个/几个变量，对数据集 [分割]; 比如按照year对数据集分割，可以写成.(year)的形式

.fun, 具体执行操作的函数，对分割后的 [每一个子数据集，调用该函数]

控制流
重复和循环
for结构 ：for (var in seq) statement
循环执行某语句statement，直到某个变量var的值不在包含在序列seq中为止
for (i in 1:10) print(“hello”)
while结构 ：while (cond) statment
必须确保cond中的条件语句能【被改变】（即它在某个时刻不在为真），否则循环将永不停止

条件执行
if-else结构：if (cond) statement 或者 for (cond) statement1 else statement2
if (!is.factor(grade)) gerade <- as.factor(grade) else print(“Grade already is a factor”)
ifelse结构：ifelse(cond, statement1, statement2)
ifelse(sorce>0.5, print(“Passed”), print(“Failed”))
outcome <- ifelse(socre>0.5, “Passed”, “Failed”)
switch结构：根据一个表达式的值选择语句执行switch(expr,…)
feelings <- c(“sad”, “afraid”)
for (i in feelings)
print(
switch(i,
happy = “I am glad you are happpy”, # 用逗号分隔
afraid = “There is nothing to fear”,
sad = “Cheer Up”,
angry = “Calm down now”
)
)

expr之后的…是expr的可能取值，后接等号（=），表示执行的行为

switch语句中，不同条件末尾要有 [逗号]

若expr为文本形式，输入时需加 [引号]

逻辑判断
which()： 返回为真的逻辑对象，允许对数组array使用

自编函数
结构
myfunction <- function(arg1, arg2, …){
statements
return(object)
}

数据拆分
pretty(x, n) ：将连续型变量x分给为n个区间；
cut(x, n,[order_result=TRUE])：将连续型变量x分割成有n个水平的因子

---

1. :alnum: ↩︎