[R learning]-0001-向量-创建向量

1. 直接创建

r语言list函数怎么单独提取向量 r语言提取向量元素_升序

r语言list函数怎么单独提取向量 r语言提取向量元素_删除元素_02

# 创建等差序列
x1 <- 1:10
x1
##  [1]  1  2  3  4  5  6  7  8  9 10
# 创建一个值的向量
x2 <- 666
x2
## [1] 666
# 创建逻辑型向量
x3 <- TRUE
x3
## [1] TRUE
# 创建字符串型向量
x4 <- "Tianjin"
x4
## [1] "Tianjin"
# 大小写
x5 <- "Tianjin"
x5
## [1] "Tianjin"
X5
## 报错, 找不到对象'X5'

0002-向量-元素的命名

给向量对应的元素命名的names()函数

vn <- c(11,22,33,44)
 names(vn) <- c('A','B','C','D')
 # 给11，22，33，44分别命名为A，B，C，D
 vn## A B C D
 ## 11 22 33 44

练习

score <- c(33,44,55,66,22)
 stu_name <- c('张三','李四','王五','赵六','Jim')
 names(score) <- stu_name
 score## 张三 李四 王五 赵六 Jim
 ## 33 44 55 66 22

0003-向量-向量的访问

1. 使用元素的位置引用来访问向量中元素的值

vc <- c(11,22,33,44,55,66)
 # 提取第一个元素值：11
 vc[1]## [1] 11
# 提取1~3个元素的值：11，22，33
 vc[1:3]## [1] 11 22 33
# 提取第2，4，5个元素的值：22，44，55
 vc[c(2,4,5)]## [1] 22 44 55
# 使用“-”来取反
 vc[-1]## [1] 22 33 44 55 66
 
vc[-(1:3)]
## [1] 44 55 66
 
vc[-c(2,4,5)]
## [1] 11 33 66

2, 使用逻辑向量来访问向量中元素的值

vc
## [1] 11 22 33 44 55 66
 
vc[c(TRUE,TRUE,FALSE,FALSE,TRUE,FALSE)]
## [1] 11 22 55
vc[c(T,T,F,F,T,T)]
## [1] 11 22 55 66
 
# 逻辑向量元素个数超过原向量元素个数则返回NA
 vc[c(T,T,F,F,T,T,T,T)]## [1] 11 22 55 66 NA NA
 
# 如果逻辑向量元素个数不足，则循环补齐，即循环重复此逻辑向量直到与原向量元素个数相等
 vc[c(T,T,F)]## [1] 11 22 44 55
 
# 循环补齐等价于这个
 vc[c(T,T,F,T,T,F)]## [1] 11 22 44 55
 
# 循环补齐另一个例子
 vc[c(T,F,F,T)]## [1] 11 44 55
 
vc[c(T,F,F,T,T,F,F)]
## [1] 11 44 55

3. 使用元素的名称来访问向量中元素的值

vc
## [1] 11 22 33 44 55 66
 
# 命名
 names(vc) <- c("one","two","three","four","five","six")
 vc## one two three four five six
 ## 11 22 33 44 55 66 
vc["one"]
## one
 ## 11 
vc[c("one","three","six")]
## one three six
 ## 11 33 66 
# 注意输出，元素值上方会带有对应的名称
# 改变访问顺序
 vc[c("six","two","five")]## six two five
 ## 66 22 55

4. 使用which()函数筛选向量中的值

  • 本质上是逻辑访问
vc
## one two three four five six
 ## 11 22 33 44 55 66 
 
vc==11
## one two three four five six
 ## TRUE FALSE FALSE FALSE FALSE FALSE 
which(vc==11)
## one
 ## 1# 或运算
 which(vc==11 | vc==33)## one three
 ## 1 3 
 
which(vc<=11 | vc>=55)
## one five six
 ## 1 5 6 
# 与运算
 which(vc>11 & vc<=44)## two three four
 ## 2 3 4 
# which的max方法和min方法
 which.max(vc)## six
 ## 6 
which.min(vc)
## one
 ## 1

5. 使用subset()函数索引向量

    • subset()函数可以找出向量中满足给定条件的向量元素值
• subset(向量名,逻辑条件)
vc <- c(11,22,33,44,55,66)
 vc## [1] 11 22 33 44 55 66
 
subset(vc, c(TRUE,FALSE,TRUE))
## [1] 11 33 44 66
 
# 注意循环补齐！
subset(vc, vc>11 & vc<55)
## [1] 22 33 44

    0004-向量-向量的编辑

    1. 扩展向量

    直接定义

    a <- c(1:6)
 a## [1] 1 2 3 4 5 6
 
a <- c(1:6, 7:10)
 a## [1] 1 2 3 4 5 6 7 8 9 10
 
b <- c(7:10)
 d <- c(a, b)
 d## [1] 1 2 3 4 5 6 7 8 9 10 7 8 9 10
 
f <- c(d, 100)
 f## [1] 1 2 3 4 5 6 7 8 9 10 7 8 9 10 100

    使用append

    a <- c(1:6)
 b <- c(7:10)
 append(a,b)## [1] 1 2 3 4 5 6 7 8 9 10
 
a
## [1] 1 2 3 4 5 6
 
a <- c(1:6)
 b <- c(7:10)
 a <- append(a,b)
 a## [1] 1 2 3 4 5 6 7 8 9 10
 
# 指定元素插入位置，插入到某个元素后面
 a## [1] 1 2 3 4 5 6 7 8 9 10
 
append(a,100,3) # 将100插入a的第三个元素后面
## [1] 1 2 3 100 4 5 6 7 8 9 10
 
a
## [1] 1 2 3 4 5 6 7 8 9 10
 
append(a,2,100) # 将2插入a的第100个元素后面，因为没有100个元素，所以追加在了a的最后面
## [1] 1 2 3 4 5 6 7 8 9 10 2
 
# 在最前面插入100
 a## [1] 1 2 3 4 5 6 7 8 9 10
 
append(a,100,0)
## [1] 100 1 2 3 4 5 6 7 8 9 10

    2. 改变元素的值

    # 将等于11的元素赋值为100
 vc <- c(11,22,33,11,11,44,55,66)
 vc## [1] 11 22 33 11 11 44 55 66
 
vc[vc==11] <- 100
 vc## [1] 100 22 33 100 100 44 55 66
 
vc
## [1] 100 22 33 100 100 44 55 66
 
vc[vc>=33 | vc==11] <- 0
 vc## [1] 0 22 0 0 0 0 0 0

    3. 删除元素

    vc <- c(11,22,33,44,55,66)
 vc## [1] 11 22 33 44 55 66
 
vc <- vc[-1]
 vc## [1] 22 33 44 55 66
 
vc
## [1] 22 33 44 55 66
vc <- vc[-c(1:3)]
 vc## [1] 55 66
 
vc <- c(11,22,33,44,55,66)
 vc## [1] 11 22 33 44 55 66
vc <- vc[c(2:4)]
 vc## [1] 22 33 44

    0005-向量-向量的排序

    1. sort()函数

      • sort(x, decreasing = FALSE, na.last = NA, index.return = FALSE,…) 
  
• x为要排序的对象
• decreasing为排序顺序，是否为降序，默认为FALSE，即降序=否，即升序排列
• na.last是对NA值的处理，若为TRUE，则NA值将放在最后，若为FALSE，NA值将放在最前面，若为NA，则排序时剔除掉NA值
• index.return是个逻辑值，设置是否显示排序序列对应的元素值在未排序前序列中的对应位置索引，默认为FALSE
vc <- c(10,NA,9,8,8,13,10,10,10,12)
 vc## [1] 10 NA 9 8 8 13 10 10 10 12
 
sort(vc)
## [1] 8 8 9 10 10 10 10 12 13
 
vc
## [1] 10 NA 9 8 8 13 10 10 10 12
 
sort(vc, decreasing = TRUE)
## [1] 13 12 10 10 10 10 9 8 8
 
vc
## [1] 10 NA 9 8 8 13 10 10 10 12
 
sort(vc, na.last = NA)
## [1] 8 8 9 10 10 10 10 12 13
 
sort(vc, na.last = FALSE)
## [1] NA 8 8 9 10 10 10 10 12 13
 
sort(vc, na.last = TRUE)
## [1] 8 8 9 10 10 10 10 12 13 NA
 
a <- c(34,234,3,1)
 a## [1] 34 234 3 1
 
sort(a)
## [1] 1 3 34 234
 
sort(a, index.return = FALSE)
## [1] 1 3 34 234
sort(a, index.return = TRUE) # 返回排序后当前元素在原来向量中的位置index
 ## [1] 4 3 1 2

      2. order()函数与rank()函数

        • order() 
  
• 返回升序排序结果的值，在原有向量中的位置
• 按照升序排序，当前位置的值来源于原始向量中哪个位置上的元素
a <- c(34,234,3,1)
 a## [1] 34 234 3 1
 
order(a)
## [1] 4 3 1 2
 
• rank() 
  
• 返回的是向量中每个数值对应的秩
• 或者说返回升序排序，排序前元素在排序后向量的位置index
a
## [1] 34 234 3 1
 
rank(a)
## [1] 3 4 2 1

        3. rev()函数

          • rev() 
  
• 将向量倒序
vc
## [1] 10 NA 9 8 8 13 10 10 10 12
 
rev(vc)
## [1] 12 10 10 10 13 8 8 9 NA 10
 
sort(vc)
## [1] 8 8 9 10 10 10 10 12 13
 
rev(sort(vc))
## [1] 13 12 10 10 10 10 9 8 8

          0006-R语言的基本函数

          1. 求和函数sum()

          v <- c(1:10)
 v## [1] 1 2 3 4 5 6 7 8 9 10
 
 
sum(v)
## [1] 55

          2. 求最大值函数max()

          max(v)
## [1] 10

          3. 求最小值函数min()

          min(v)
## [1] 1

          4. 求均值函数mean()

          mean(v)
## [1] 5.5

          5. 求中位数函数median()

          median(v)
## [1] 5.5

          6. 范围函数range()

          # 其实就是求max和min然后放一起
 range(v)## [1] 1 10

          7. 求方差函数var()

          var(v)
## [1] 9.166667

          8. 求标准差函数sd()

          sd(v)
## [1] 3.02765

          9. 求向量元素值连乘积prod()

          prod(v)
## [1] 3628800

          10. 累加和向量函数cumsum()

          # 创建一个新向量，新向量第n项的值是原向量前n项值累加后的和
 v## [1] 1 2 3 4 5 6 7 8 9 10
cumsum(v)
## [1] 1 3 6 10 15 21 28 36 45 55