R语言向量下标操作

向量下标即元素在向量中的位置，在实践中我们可以利用下标(元素的位置)来找出自己想要的数。

利用runif函数生成包含10个正整数的向量x。

				?

									options(digits = 1)

									set.seed(1234)

									x <- runif(10,min = 1,max = 20)

									x

									 [1]  3 13 13 13 17 13  1  5 14 11

正整数下标

我们可以输入正整数作为下标来找出对应位置的元素。

在[]内输入下标。

				?

									#向量x的第一位置的元素

									x[1]

									[1] 3

									#向量x的第2位置的元素

									x[2]

									[1] 13

									x[0]

									numeric(0)

与其他编程语言不一样(下标从0开始算起)，R的下标是从1开始算起。

在R语言中向量输入0下标返回numeric(0)。

如果在其他语言，如python中输入下标0,则返回向量中第一个位置的元素

负整数下标

如果为负整数则表示删除这个位置的元素,并返回余下的元素。

				?

									x

									 [1]  3 13 13 13 17 13  1  5 14 11

									#删除第一位的元素

									x[-1]

									[1] 13 13 13 17 13  1  5 14 11

倒数位置选取元素

如果是以倒数位置选取元素。倒数第一位置借助length函数表示下标,倒数第二三等等依次递减。

				?

									set.seed(1234)

									x <- runif(10,min = 1,max = 20)

									x

									 [1]  3 13 13 13 17 13  1  5 14 11

									# 倒数第一位元素

									x[length(x)]

									[1] 11

									# 倒数第二位元素

									x[length(x)-1]

									[1] 14

下标赋值

可以根据下标位置来进行赋值

				?

									x

									 [1]  3 13 13 13 17 13  1  5 14 11

									#将第一位置赋值为8

									x[1] <- 8

									x

									 [1]  8 13 13 13 17 13  1  5 14 11

下标超界

下标超界即向量x的长度为n,它的最大下标即是n,如果超过n，则超界。

在R中向量下标超界则返回NA空白值。如果对这个下标位置赋值，则生成对应位置的元素

				?

									length(x)

									[1] 10

									x[11]

									NA

									x[11] <- 15

									x

									 [1]  3 13 13 13 17 13  1  5 14 11 15

逻辑下标

可以以逻辑表达式作为下标，返回对应的元素。

				?

									set.seed(1234)

									x <- runif(10,min = 1,max = 20)

									x

									 [1]  3 13 13 13 17 13  1  5 14 11

									#找出数值大于10的元素

									x[x > 10]

									[1] 13 13 13 17 13 14 11

which函数、seq函数

which函数找出对应元素的下标

				?

									x

									 [1]  3 13 13 13 17 13  1  5 14 11

									#找出取值大于13的元素的位置下标

									which(x>13)

									[1] 5 6 9

seq函数也可以返回下标

				?

									seq(along=x)[x>13]

									[1] 5 6 9

									seq_along(x)[x>13]

									[1] 5 6 9

									seq(along.with=x)[x>13]

									[1] 5 6 9

可以在for循环中用seq_along(x)代替1:length(x)

				?

									for (i in seq_along(x)) {

									     print(x[i])

									 }

									for (i in 1:length(x)) {

									     print(x[i])

									 }

which.min与which.max可以分别找出向量中最小值与最大值的下标位置

				?

									x

									 [1]  3 13 13 13 17 13  1  5 14 11

									which.min(x)

									[1] 7

									which.max(x)

									[1] 5

返回NA的下标

				?

									a <- c(NA,1,NA,23,45,NA)

									which(is.na(a))

									[1] 1 3 6

补充：R语言中的向量使用合集

看代码吧~

				?

									#---r中向量相关的操作

									#----数字型向量

									#赋值

									x<-c(1,2,3)

									assign("x",c(1,2,3))

									y<-c(x,2,x)

									# > y

									# [1] 1 2 3 2 1 2 3

									#向量的运算

									x<-c(1,2,3);y<-c(2,3,4)

									v1<-2*x+x*y+1

									# > v1

									# [1]  5 11 19

									v2<-2*x+x*y+c(1,1,1)

									v1==v2

									# > v1==v2  两者效果相同，自己体会

									# [1] TRUE TRUE TRUE

									x^2

									# > x^2

									# [1] 1 4 9

									#函数运算，比如log,sqrt,sin等

									x<-c(1,2,3)

									sqrt(x)

									# > sqrt(x)

									# [1] 1.000000 1.414214 1.732051

									#与向量相关的其他函数min、max、range、which.min、which.max、sum、prod、length、sort、mean、var

									x<-c(3,2,1)

									# > min(x)

									# [1] 1

									# > max(x)

									# [1] 3

									# > which.max(x)

									# [1] 1

									# > which.min(x)

									# [1] 3

									# > sum(x)

									# [1] 6

									# > prod(x)

									# [1] 6

									# > length(x)

									# [1] 3

									# > sort(x)

									# [1] 1 2 3

									# > mean(x)

									# [1] 2

									# > var(x)

									# [1] 1

									#等差数列一般采用a:b的形式

									# > 1:15 代表从1到15的数列，每次加1

									# [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15

									# > 1:4.5 a为整数，b为实数，表示a到b的整数部分，每次加1

									# [1] 1 2 3 4

									# > 1.5:5  a为实数，b为整数，表示从a开始累加到b，每次加1

									# [1] 1.5 2.5 3.5 4.5

									# > 2*(1:5)

									# [1]  2  4  6  8 10

									# > 2*1:5  向量优先级大于运算符号

									# [1]  2  4  6  8 10

									# > 1:5-1

									# [1] 0 1 2 3 4

									#重复函数 rep(x,times=)

									x<-c(1,2,3)

									s<-rep(x,times=2)

									# > s

									# [1] 1 2 3 1 2 3

									#逻辑向量，在向量赋值处使用逻辑表达式

									x<-c(1,2,3,4,5)

									l<-x>3

									# > l

									# [1] FALSE FALSE FALSE  TRUE  TRUE

									#其它的逻辑向量运算还有< <= == !=等

									#all和any用于返回向量中的值是否全部大于3的逻辑值，any返回向量x中是否有值大于3

									all(x>3)

									any(x>3)

									#逻辑向量的赋值,可以使用F和T对false和true进行简写

									l<-c(TRUE,FALSE,F,T)

									#向量中的缺失数据、赋值、检查

									z<-c(-1,1:3,NA)

									z

									# [1] -1  1  2  3 NA

									is.na(z)

									z[is.na(z)]<-0

									# > z

									# [1] -1  1  2  3  0

									#结合z的下标进行复杂运算

									z

									# [1] -1  1  2  3  0

									#结合z的下标进行复杂运算

									 (z+1)[!is.na(z)&z>0]

									# [1] 2 3 4 

									#-----字符型向量

									#涉及赋值、paste连接

									X<-c("My","Job")

									paste("My","Job")  #表示将两个字符链接，默认使用空格进行分隔开

									# [1] "My Job"

									paste("X",1:6,sep = "")

									# [1] "X1" "X2" "X3" "X4" "X5" "X6"

									#可以使用定义下标值的方法来定义分段函数

									#比如分段函数 y=1-x  x<0 y=1+x x>=0

									y[x<0]<-1-x[x<0]

									y[x>=0]<-1+x[x>=0] 

									#下标的正整数运算

									v<-10:20

									v[c(1,2,3,4)]

									c("a","b","c")[rep(c(2,1,3),times=3)]

									#下标的负整数运算

									v[-(1:5)]

									#表示去除代号为哪些的值

									#取字符向量的某些下标值

									#在定义向量的时候可以加上列名

									ages<-c(Li=23,chen=30)

									#向量名称可以后加

									ages=c(23,40,50)

									names(ages)<-c("li","chen","zhang")

									ages

									# > ages

									# li  chen zhang 

									# 23    40    50