向量

用于储存数值型，字符型，逻辑型数据的一维数组。

x = c(1,2,'a','b',TRUE)  ##用函数c连接，不同元素之间用逗号分隔

设置等差数列

seq(from=1,to=100,by=2) ##by设置公差
seq(1,100,by=2)
seq(from=1,to=100,length.out=10)  ##length.out设置输出个数

重复序列

rep(x,times)
> x=c(1,2,3,4,5)
> rep(x,5)
 [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
> rep(x,each=5) ##each控制重复的格式，由1234512345变成1122334455
 [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
> 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
[39] 3 3 4 4 4 4 4 5 5 5 5 5

必须是同一类型的向量才能计算

a=c(1,2,3,4)
b=c(6,7,8,9)
a*2+b
8,11,14,17

向量索引（也叫访问向量）

注意R中的角标是从1开始的，python中是从0开始的。

• 1.访问数值型向量（正，负整数索引）

> a=c(1,2,3,4,5)
> a[1]   ##正整数，访问该向量
[1] 1
> a[-1]  ##负整数，访问除该向量之外的向量
[1] 2 3 4 5

> a
  [1]   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16
 [17]  17  18  19  20  21  22  23  24  25  26  27  28  29  30  31  32
 [33]  33  34  35  36  37  38  39  40  41  42  43  44  45  46  47  48
 [49]  49  50  51  52  53  54  55  56  57  58  59  60  61  62  63  64
 [65]  65  66  67  68  69  70  71  72  73  74  75  76  77  78  79  80
 [81]  81  82  83  84  85  86  87  88  89  90  91  92  93  94  95  96
 [97]  97  98  99 100
> a[c(1:10)]
 [1]  1  2  3  4  5  6  7  8  9 10
> a[c(1,2,24,56,88)]
[1]  1  2 24 56 88

> a=c(1:10)
> a[a>5]  ## 也可以是逻辑值访问
[1]  6  7  8  9 10
> a[a>5 & a<8]
[1] 6 7
> a[c(T,F)] ##循环判断访问
[1] 1 3 5 7 9

访问字符型向量

• 2.利用%in% 判断元素是否在向量中

> 'one' %in% x    ##判断'one'字符是否在x向量中，返回逻辑值TRUE
[1] TRUE
再将逻辑条件添加到索引中
> x['one' %in% x]   ##相当于x[TURE]，会输出x向量内所有的元素
[1] "one"   "two"   "three" "four"  "five"
> x %in% c('one','two')
[1]  TRUE  TRUE FALSE FALSE FALSE
> x[x %in% c('one','two')]   
[1] "one" "two"

• 3。利用元素名称访问
  利用names函数对向量的每个元素添加名称

> y=c(1,2,3,4,5,6,7,8)
> names(y) = c('A','B','C','D','E','F','G','H')  ##对元素添加名称
> y
A B C D E F G H 
1 2 3 4 5 6 7 8
> y['A']  ##通过元素名称访问
A 
1 
> names(y) = rep(c('A','B'),each=2,times=2)
> y
A A B B A A B B 
1 2 3 4 5 6 7 8

向量添加元素

数值向量直接添加，注意左手边是元素，右手边是向量索引。

> a=c(1:20)
> a
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20
> a[21] = 21
> a
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21

利用append添加

> append(x=a,values=6,after=5)
 [1]  1  2  3  4  5  6  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21

删除向量

rm(a)  ##直接rm函数

删除向量中的元素

a=c(1:10)
> a[-c(4:7)]
[1]  1  2  3  8  9 10

修改向量的某个元素

> a
A B C D E 
1 2 3 4 5 
> a['A']= 10   ##直接找到某个向量进行赋值
> a
 A  B  C  D  E 
10  2  3  4  5

向量运算

+ 相加  2 + 2 =4
- 相减  2 - 2 = 0
* 乘  2 * 2 = 4
** 幂 2 ** 3 = 8
/ 除  10 / 3 =3.3333
%% 取余  10 %% 3 =1
%/% 整除运算   10%/% 3 = 3

> a = -5:5
> a
 [1] -5 -4 -3 -2 -1  0  1  2  3  4  5
> abs(a)  ##abs函数返回绝对值
 [1] 5 4 3 2 1 0 1 2 3 4 5
> sqrt(abs(a))  ## sqrt返回平方根
 [1] 2.236068 2.000000 1.732051 1.414214 1.000000 0.000000 1.000000
 [8] 1.414214 1.732051 2.000000 2.236068
> log(10,base = 10)  ##log取对数，bese为底数
[1] 1

> exp(0) ##取自然对数e的指数函数 ，e的0次方
[1] 1
> ceiling(2.1) ##返回不小于2.1的最小整数
[1] 3
> floor(3.4)  ## 返回不大于3.4的最大整数
[3] 3
> trunc(3.4)  ##返回整数部分
[1] 3
> round(3.141592,digits = 4)  ##round进行四舍五入，digits决定保留位数
[1] 3.1416
> signif(3.144,digits = 3)  ##signif保留小数的有效位数，dignits觉得保留位数
[1] 3.14

统计函数

对所有数据进行处理，返回一个值。

> vec = c(1:100)
> sum(vec)   ##求和
[1] 5050
> max(vec)  ##取最大值
[1] 100
min(vec)  ##最小值
range(vec)  ##最大值和最小值
mean(vec)  ##取均值
> var(vec)  ## 方差
[1] 841.6667
> sd(vec)  ##标准差
[1] 29.01149
> prod(vec)  ##返回所有元素连乘的积
[1] 9.332622e+157
> median(vec)  ##中位数
[1] 50.5
> quantile(vec)  ##求分位数
    0%    25%    50%    75%   100% 
  1.00  25.75  50.50  75.25 100.00 
> quantile(vec,c(0.2,0.5,0.8))  ##取2，4，8分位数
 20%  50%  80% 
20.8 50.5 80.2

> a = c(1,3,6,8,9)
> which.max(a)  ##返回最大元素的索引值
[1] 5
> which(a==6)  ##返回a向量元素为6的索引值
[1] 3
> a[which(a>3)]  ##利用返回的索引值获取向量的元素
[1] 6 8 9