不登高山,不知天之高也；不临深溪,不知地之厚也。 ——荀子
这篇文章讲述的是R语言中关于向量相关知识。希望这篇R语言文章对您有所帮助！如果您有想学习的知识或建议，可以给作者留言
一、向量的概念及简单介绍
1、概念
向量，vector，是R中最重要的一个概念，它是构成其他数据结构的基础。R中的向量概念与数学之间的向量是不同的，类似于数学上的集合的概念，由一个或多个元素所构成。
向量其实是用于存储数值型、字符型或逻辑型数据的一维数组。
用函数C来创建向量。c代表
concatenate连接，也可理解为收集collect，或者合并combine。
其中R内置的函数中，格式为为向量的有：
代码语言：javascript复制euro
rivers
stat.abb
state.name
state.area2、创建向量和查看向量
1、创建向量
- 1、创建向量：c()，查看长度length()，查看类型mode()
# 创建向量
x1 <- c(2,4,6,8,0)
x2 <- c(1,3,5,7,9)
# 创建字符串向量
> y <- c("li","hua","xin")
> y
[1] "li" "hua" "xin"
# 创建逻辑型向量
> z <- c(TRUE,FALSE,T,F)
> z
[1] TRUE FALSE TRUE FALSE
# 创建从1到100的向量
a1 <- c(1:100)
# 查看向量x1的内容
> x1
[1] 2 4 6 8 0
# 查看向量x1中的第三个数
> x1[3]
[1] 6代码语言：javascript复制2、查看向量的长度和类型
# 查看字符串向量
> mode(y)
[1] "character"
# 查看向量的长度
> length(x1)
[1] 5
# 查看向量的类型
> mode(x1)
[1] "numeric"3、向量运算的简单介绍(最后有补充)
- 1、简单介绍
# 创建一个1到10的向量
> 1:10
[1] 1 2 3 4 5 6 7 8 9 10
# 向量中每一个数都减1
> 1:10-1
[1] 0 1 2 3 4 5 6 7 8 9
# 向量中每一个数都乘以2
> 1:10*2
[1] 2 4 6 8 10 12 14 16 18 20
# 向量中每一个数都乘以2加1
> 1:10*2 1
[1] 3 5 7 9 11 13 15 17 19 21
> a <- 1:60*2 1
> a
[1] 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45
[23] 47 49 51 53 55 57 59 61 63 65 67 69 71 73 75 77 79 81 83 85 87 89
[45] 91 93 95 97 99 101 103 105 107 109 111 113 115 117 119 121
# a向量中下标为5的数的值
> a[5]
[1] 11
> a[5]
[1] 13
> a <- 2:60*2 1
> # a向量中下标除了5以外的所有元素
> a[-5]
[1] 5 7 9 11 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49
[23] 51 53 55 57 59 61 63 65 67 69 71 73 75 77 79 81 83 85 87 89 91 93
[45] 95 97 99 101 103 105 107 109 111 113 115 117 119 121
# 向量a中前五个元素
> a[1:5]
[1] 5 7 9 11 13
# 向量a中除了前五个下标以外对应的数
> a[-(1:5)]
[1] 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 51 53 55 57
[23] 59 61 63 65 67 69 71 73 75 77 79 81 83 85 87 89 91 93 95 97 99 101
[45] 103 105 107 109 111 113 115 117 119 121
# 错误，度量值不对
> a[1,2,3]
Error in a[1, 2, 3] : incorrect number of dimensions
# 向量a中的第2，4，7个元素
> a[c(2,4,7)]
[1] 7 11 17
# 向量a中第三个到第八个元素的内容
> a[3:8]
[1] 9 11 13 15 17 19
# 向量a中小于20的元素
> a[a<20]
[1] 5 7 9 11 13 15 17 19
# 向量a中中大于30小于50的元素
> a[a>30 & a<50]
[1] 31 33 35 37 39 41 43 45 47 49
# 向量a中前三个元素相加
> a[a[3]]
[1] 21- 2、Seq()函数
代码语言：javascript复制Seq()函数可以按照指定的规律创建向量
# 创建一个从5到20的向量
> seq(5,20)
[1] 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
# 创建一个从5到121的向量，公差为2
> seq(5,121,by=2)
[1] 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47
[23] 49 51 53 55 57 59 61 63 65 67 69 71 73 75 77 79 81 83 85 87 89 91
[45] 93 95 97 99 101 103 105 107 109 111 113 115 117 119 121
# by 和 length 不能同时指定
> seq(5,121,by=2,length=10)
Error in seq.default(5, 121, by = 2, length = 10) : 太多参数
# 创建一个从5到121的向量，总共有10项，自动计算公差
> seq(5,121,length=10)
[1] 5.00000 17.88889 30.77778 43.66667 56.55556 69.44444 82.33333 95.22222 108.11111
[10] 121.00000- 3、产生字母序列letters[ ]
# 生成字母序列，超过部分 NA自动补齐
> letters[1:30]
[1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s" "t" "u" "v"
[23] "w" "x" "y" "z" NA NA NA NA - 4、which()函数
> a <- c(2,3,4,2,5,1,6,3,2,5,8,5,7,3)
# 最大值的位置
> which.max(a)
[1] 11
# 最小值的位置
> which.min(a)
[1] 6
# 最小下标的值
> a[which.min(a)]
[1] 1
# 向量中值为2的下标
> which(a==2)
[1] 1 4 9
# 向量中2所在的位置
> a[which(a==2)]
[1] 2 2 2
# 向量中值大于5的下标(返回的索引值)
> which(a>5)
[1] 7 11 13
# 向量中大于5的元素(通过索引值返回向量值)
> a[which(a>5)]
[1] 6 8 7- 5、rev()函数，sort()函数
> a <- 1:20
> a
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
# 倒序向量
> rev(a)
[1] 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
# 随机创一个向量
> a <- c(2,3,4,2,5,1,6,3,2,5,8,5,7,3)
# 排序向量
> sort(a)
[1] 1 2 2 2 3 3 3 4 5 5 5 6 7 8
# 把排序好的向量倒序
> rev(sort(a))
[1] 8 7 6 5 5 5 4 3 3 3 2 2 2 1- 6、rep()函数
代码语言：javascript复制此函数可以生成重复序列
> x <- c(1,2,3,4,5)
# 把2重复5次
> rep(2,5)
[1] 2 2 2 2 2
# 把向量x重复10次
> rep(x,10)
[1] 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5
[46] 1 2 3 4 5
# 把向量中的每一个数字分别重复五次
> rep(x,each=5)
[1] 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3 4 4 4 4 4 5 5 5 5 5
# 当each和times同时使用时，结果为他们的乘机即5x2
> rep(x,each=5,times=2)
[1] 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3 4 4 4 4 4 5 5 5 5 5 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3 4 4 4 4 4
[46] 5 5 5 5 5
# x中的元素，每一个分别重复c向量中的个数
> rep(x,c(2,4,6,2,3))
[1] 1 1 2 2 2 2 3 3 3 3 3 3 4 4 5 5 5二、索引及元素的增删改查
1、索引
1、正(负)整数索引 2、逻辑向量索引 3、名称索引
1.1、整数索引
- 1、正整数索引
> x <- c(1:100)
> x
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
[23] 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
[45] 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66
[67] 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88
[89] 89 90 91 92 93 94 95 96 97 98 99 100
# 个数
> length(x)
[1] 100
# 第一个元素
> x[1]
[1] 1
# 第零个元素，由于没有0所以没有显示 // 请自行忽略掉这个不是正整数呀
> x[0]
integer(0)- 2、负整数索引
# 随机一个，即出去这个元素外其他的正常显示
> x[-19]
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 20 21 22 23
[23] 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45
[45] 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67
[67] 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89
[89] 90 91 92 93 94 95 96 97 98 99 100- 3、向量化操作
> x[c(4:18)]
[1] 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
# 随机选取数值，取出
> x[c(1,23,45,77)]
[1] 1 23 45 77
# 不能要取数值不能异号，否则会出错
> x[c(-2,34)]
Error in x[c(-2, 34)] : only 0's may be mixed with negative subscripts1.2、逻辑向量索引
常用的方式，T输出，F不输出，找不到的用NA表示
- 1、数字型操作
> y <- c(1:10)
> y[c(T,F,T,T,F,F,T,T,T,F,T)]
[1] 1 3 4 7 8 9 NA
> y[c(T)]
[1] 1 2 3 4 5 6 7 8 9 10
> y[c(T,F)]
[1] 1 3 5 7 9
> y[c(T,F,T)]
[1] 1 3 4 6 7 9 10
> y[y>5]
[1] 6 7 8 9 10
> y[y>5 & y<9]
[1] 6 7 8- 2、字符型操作
> z <- c("one","two","three","four","five")
# 查看是否在z中
> "one" %in% z
[1] TRUE
# 将逻辑条件添加到索引中
> z["one" %in% z]
[1] "one" "two" "three" "four" "five"
> z[z %in% c("one","two")]
[1] "one" "two"
# 用在索引中只输出两个元素
> z %in% c("one","two")
[1] TRUE TRUE FALSE FALSE FALSE
> k <- z%in% c("one","two")
> z[k]
[1] "one" "two"PS：中括号里的是条件，把条件单独放出来，就会将对象按照是否符合条件分为TURE和FALSE，放在中括号就会只输出TRUE的内容。
1.3、名称索引
代码语言：javascript复制> names(y) <- c("one","two","three","four","five","six","seven","eight","nine","ten")
# 显示所有
> y
one two three four five six seven eight nine ten
1 2 3 4 5 6 7 8 9 10
> name(y)
Error in name(y) : could not find function "name"
# 显示y中的名称即索引
> names(y)
[1] "one" "two" "three" "four" "five" "six" "seven" "eight" "nine" "ten"
# 通过索引查找值，不过貌似不常用
> y["one"]
one
1 2、元素的增删改查
2.1、添加元素
代码语言：javascript复制> x <- 1:100
> x
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
[23] 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
[45] 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66
[67] 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88
[89] 89 90 91 92 93 94 95 96 97 98 99 100
# 直接添加
> x[101] <- 101
> x
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
[23] 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
[45] 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66
[67] 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88
[89] 89 90 91 92 93 94 95 96 97 98 99 100 101
> v <- c(1,2,3)
# 批量赋值
> v[c(4,5,6)] <- c(4,5,6)
> v
[1] 1 2 3 4 5 6
# 为v中的第20个元素赋值为4
> v[20]=4
> v
[1] 1 2 3 4 5 6 NA NA NA NA NA NA NA NA NA NA NA NA NA 4
# 如果想在中间插入数值，需要使用append()函数
> append(v,99,after = 5)
[1] 1 2 3 4 5 99 6 NA NA NA NA NA NA NA NA NA NA NA NA NA 4
# 如果想赋值可，直接赋值
> v[2]=15
> v
[1] 1 15 3 4 5 6 NA NA NA NA NA NA NA NA NA NA NA NA NA 42.2、删除元素
代码语言：javascript复制# 如果要删除整个向量
rm(v)
# 删除个别元素
> y[-c(1:3)]
four five six seven eight nine ten
4 5 6 7 8 9 10
# 重新赋值给原来的向量
> y <- y[-c(1:3)]
# 查看
> y
four five six seven eight nine ten
4 5 6 7 8 9 10 三、向量运算(补充)
代码语言：javascript复制在第一部分已经有了介绍，下面的为补充部分，各位可自行运行了解
#vector functions 定义一个数学函数
x <- -5:5
abs(x) # 返回向量的绝对值
sqrt(x) # 计算平方根
log(16,n=2) #求对数，其中参数为要求的值，第二个参数base为底数
log10(10) # 不加base参数，默认为自然对数
exp(x) # 计算向量中每个元素的指数
ceiling (c(-2.3,3.1415)) # 返回x中不小于零的整数
floor(c(-2.3,3.1415)) # 返回x中不大于零的整数
trunc(c(-2.3,3.1415)) # 返回函数的整数部分
round (c(-0.618,3.1415),digits=2) # 用来进行四舍五入
signif (c(-0.0618,3.1415),digits=3) # 与round函数类似，只不过保留小数部分有效数字
sin(x);cos(x);tan(x) # 三角函数
# 下面为统计函数
vec <- 1:100 # 数值向量，有100个函数
sum(vec) # 求和
max(vec) # 求最大值
min(vec) # 求最小值
range(vec) # 直接返回最大值和最小值
mean(vec) # 返回向量的平均值
var(vec) # 返回向量的方差
round (var(vec),digits=2) # 保留两位小数
sd(vec) # 返回向量的标准差
prod(vec) # 返回向量连乘的积
median(vec) # 计算中位数
quantile(vec) # 计算分位数
quantile (vec,c(0.4,0.5,0.8)) # 
