R语言数据结构：向量

发表于   |   分类于

简介

向量是R中最常见的数据结构之一，它由一组同类型(character,integer,boolean…)的数据构成。
R中单个的数据，如数字1，字符串’abc’都可以视为长度为1的向量。

创建向量

使用c()创建向量，会将所有数据强制转换为一种数据类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
> c(2,4,6)
[1] 2 4 6

# 数值1强制转换为字符串'1'
> c('a',1)
[1] "a" "1"

# boolean值FALSE强制转换为字符串'FALSE'
> c('a',11==111)
[1] "a"     "FALSE"

# boolean值FALSE强制转换为数值0
> c(1,11==111)
[1] 1 0

创建一个递增序列

1
2
3
4
5
6
7
8
9
10
11
> 1:4
[1] 1 2 3 4

> seq(4)
[1] 1 2 3 4

> seq(1,4,by=1)
[1] 1 2 3 4

> seq(1,4,by=2)
[1] 1 3

提取向量子集

通过位置筛选

R中向量的位置从1开始

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
> a <- 1:5
> a
[1]  1  2  3  4  5
# 第一个元素
> a[1]
[1] 1
# 第一个至第三个元素
> a[1:3]
[1] 1 2 3
# 第一个和第三个元素
> a[c(1,3)]
[1] 1 3
# 排除第一个元素后剩下的元素
> a[-1]
[1]  2  3  4  5
# 排除第一个至第三个元素后剩下的元素
> a[-(1:3)]
[1]  4  5
# 排除第一个和第三个元素后剩下的元素
> a[-c(1,3)]
[1]  2  4  5
# 超出向量长度的部分显示为NA
> a[1:7]
 [1]  1  2  3  4  5 NA NA

通过布尔值筛选

很多向量的函数(is.na,%in%,grepl…)返回结果都是布尔值，所以这些函数的结果都可以用来提取向量的子集。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
> a <- 1:5
> b <- c(TRUE,FALSE,FALSE)
# 先将b循环补齐为1个长度为5(向量a的长度)的向量，即c(TRUE,FALSE,FALSE,TRUE,FALSE)
# 再通过这个补齐的布尔值向量提取a向量的子集
> a[b]
[1] 1 4
# 同样如果布尔值向量长度大于目标向量的长度，超出部分且布尔值为TRUE的显示为NA
> b <- c(TRUE,FALSE,FALSE,TRUE,FALSE,TRUE)
> a[b]
[1]  1  4 NA
> b <- c(TRUE,FALSE,FALSE,TRUE,FALSE,FALSE)
# 所以通过值进行筛选，也是先计算a==2,得到一个布尔值向量
> a[a==2]
[1] 2

向量函数

数据类型转换

基础类型转换

as.character
as.logical
as.numeric
as.factor
as.Date

小数转整数

round:四舍五入
floor:舍掉小数部分,取整
ceiling:舍掉小数部分,加1取整

1
2
3
4
5
6
7
8
> round(1.4)
[1] 1
> round(1.5)
[1] 2
> ceiling(1.4)
[1] 2
> floor(1.6)
[1] 1

日期与字符串

日期处理扩展包：lubridate 

1
2
3
4
5
6
7
8
# 日期转化为字符串
strftime(Sys.Date(),format='%Y-%m')

# 字符串转化为日期
strptime("20/2/06 11:16:16.683", "%d/%m/%y %H:%M:%OS")

# 计算日期(时间)差
difftime(time1,time2,tz,units=c("auto","secs","mins","hours","days", "weeks"))

字符串处理

字符串处理扩展包：stringr

length,nchar

1
2
3
4
5
6
# length计算的是向量的长度，nchar计算的是向量内每个元素的字符个数
> a <- c('a,b,c','d,e')
> length(a)
[1] 2
> nchar(a)
[1] 5 3

tolower，toupper

1
2
3
4
> tolower('AbcD')
[1] "abcd"
> toupper('aBCd')
[1] "ABCD"

paste

1
2
3
4
5
6
7
8
9
10
# 拼接两个向量
> a <- 1:3
> b <- c('a','b','c')
> c <- paste(a,b,sep=',')
> c
[1] "1,a" "2,b" "3,c"
# 拼接向量的每个元素
> c <- paste(b,collapse = ',')
> c
[1] "a,b,c"

strsplit

1
2
3
4
5
6
7
8
9
10
11
# strsplit函数返回的结果是一个列表,fixed = FALSE表示正则匹配，TRUE表示完全匹配
> a <- c('a,b,c','d,e')
> strsplit(a,',|;',fixed = FALSE)
[[1]]
[1] "a" "b" "c"

[[2]]
[1] "d" "e"
# 提取a向量每个元素被分割后的第一个字符
> unlist(lapply(strsplit(a,","),function(x){x <- x[1]}))
[1] "a" "d"

substr

1
2
3
> a <- c('a,b,c','d,e')
> substr(a,1,3)
[1] "a,b" "d,e"

match,%in%

1
2
3
4
5
6
7
8
9
10
11
# match返回位置
> match('c',c('a','b','c','d'))
[1] 3
> match(c('c','a','e'),c('a','b','c','d'))
[1]  3  1 NA
> match(c('c','a','e'),c('a','b','c','d'),nomatch = 0)
[1] 3 1 0

# %in%返回布尔值
> c('c','a','e') %in% c('a','b','c','d')
[1]  TRUE  TRUE FALSE

grep,grepl,sub,gsub

这几个函数都是默认的fixed = FALSE，使用正则匹配

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# grep返回匹配到的位置
> grep('[1-9][a|b]',c('1a','2c','2a','3b','3c'))
[1] 1 3 4

# grepl返回每个向量元素匹配的布尔结果
> grepl('[1-9][a|b]',c('1a','2c','2a','3b','3c'))
[1]  TRUE FALSE  TRUE  TRUE FALSE

# sub仅替换第一个匹配项
> sub('=[1-9]','',c('=1=1','=12','=123'))
[1] "=1" "2"  "23"

# gsub替换所有匹配项
> gsub('=[1-9]','',c('=1=1','=12','=123'))
[1] ""   "2"  "23"

逻辑计算

与(&,&&)，或(|,||),非(!)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# &,|是向量单个元素之间的计算，返回结果仍然是一个布尔值向量
> c(TRUE,TRUE)&c(TRUE,FALSE)
[1]  TRUE FALSE
> c(TRUE,TRUE)|c(TRUE,FALSE)
[1] TRUE TRUE

# &&,||是整个向量之间的计算，返回结果是单个的布尔值
> c(TRUE,TRUE)&&c(TRUE,FALSE)
[1] TRUE
> c(TRUE,TRUE)||c(TRUE,FALSE)
[1] TRUE

# 非，取反
> !TRUE
[1] FALSE

any,all,which

1
2
3
4
5
6
7
8
> b <- c(TRUE,FALSE,TRUE)
> all(b)
[1] FALSE
> any(b)
[1] TRUE
# 提取TRUE的位置
> which(b)
[1] 1 3

ifelse

1
2
> ifelse(1==1,TRUE,FALSE)
[1] TRUE

数学计算

min,max,sum,mean,quantile(百分位数)

That’s all.
Happy writing!