[R语言] R语言入门 Chapter01 | 向量

不登高山,不知天之高也；不临深溪,不知地之厚也。 ——荀子

• 一、向量的概念及简单介绍
  
• 
  
  
  
  • 1、概念
    
  • 2、创建向量和查看向量
    
  • 3、向量运算的简单介绍(最后有补充)
    
  
  
• 二、索引及元素的增删改查
  
• 
  
  
  
  • 1、索引
    
  • 
    
    
    
    • 1.1、整数索引
      
    • 1.2、逻辑向量索引
      
    • 1.3、名称索引
      
    
    
  • 2、元素的增删改查
    
  • 
    
    
    
    • 2.1、添加元素
      
    • 2.2、删除元素
      
    
    
  
  
• 三、向量运算(补充)
  

• 快速入门之Tableau系列：快速入门之Tableau
  
• 快速入门之爬虫系列：快速入门之爬虫
  
• COVID-19分析专栏：COVID-19分析
  

向量，vector，是R中最重要的一个概念，它是构成其他数据结构的基础。R中的向量概念与数学之间的向量是不同的，类似于数学上的集合的概念，由一个或多个元素所构成。

向量其实是用于存储数值型、字符型或逻辑型数据的一维数组。

用函数C来创建向量。c代表concatenate连接，也可理解为收集collect，或者合并combine。

euro
rivers
stat.abb
state.name
state.area

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

2、查看向量的长度和类型

# 查看字符串向量
> mode(y)
[1] "character"
# 查看向量的长度
> length(x1)
[1] 5
# 查看向量的类型
> mode(x1)
[1] "numeric"

• 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()函数
  

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()函数
  

此函数可以生成重复序列

> 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、正(负)整数索引
2、逻辑向量索引
3、名称索引

• 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 subscripts

常用的方式，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的内容。

> 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

> 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  4

# 如果要删除整个向量
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

在第一部分已经有了介绍，下面的为补充部分，各位可自行运行了解

#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))  #