R语言入门 Chapter01 | 向量

2020-10-30 15:11发布

站内文章 / 网络爬虫
964 0 0

一、向量的概念及简单介绍

1、概念

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

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

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

其中R内置的函数中，格式为为向量的有：

euro

rivers

stat.abb

state.name

state.area123456789

2、创建向量和查看向量

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] 6123456789101112131415161718192021222324

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

# 查看字符串向量
> mode(y)
[1] "character"

# 查看向量的长度
> length(x1)
[1] 5

# 查看向量的类型
> mode(x1)
[1] "numeric"1234567891011

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] 2112345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273

  •  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.00000123456789101112131415161718

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

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

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

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

二、索引及元素的增删改查

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

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

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

1.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 812345678910111213141516171819

  •  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"123456789101112131415161718192021

PS：中括号里的是条件，把条件单独放出来，就会将对象按照是否符合条件分为TURE和FALSE，放在中括号就会只输出TRUE的内容。

1.3、名称索引

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

2、元素的增删改查

2.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

#