R语言入门——数据类型与向量

一、class(x)判断数据类型（如：

1.png

1、字符型要加引号）

2、R语言三种数据类型

①数值型②字符型③逻辑型

二、判断数据类型,使用is函数，返回T/F

  1. is.numeric(x)
  2. is.logical(x)
  3. is.character(x)

三、数据类型转换，使用as函数

  1. is.numeric(x)
  2. is.logical(x)
  3. is.character(x)

四、R语言数据结构类型

1、向量（表格的一列，一列只能一种数据类型）

#使用c()来创建

c(1,2,3)
c(“a”,”b”)
#c()也可以用来数据类型转换，如：

  1. c(1,"a") #数值型与字符型转换，均变为字符型
  2. [1] "1" "a"
  3. c("a",TRUE) #逻辑型与字符型转换，均变为字符型
  4. [1] "a"    "TRUE"
  5. c(TRUE,2) #逻辑型与数值型转换，均变为数值型
  6. [1] 1 2
  7. #连续的数字可用":"
  8. c(3:10)

#重复的使用rep();有规律的序列用seq()，随机数用rnorm()

  1. rep("a",times=5)
  2. [1] "a" "a" "a" "a" "a"
  3. seq(from=5,to=100,by=5)
  4. [1]   5  10  15  20  25  30  35  40  45  50  55  60  65  70  75
  5. [16]  80  85  90  95 100

#函数组合构建复杂向量

  1. paste0(rep("sample",time=7),seq(from=4,to=30,by=4))
  2. [1] "sample4"  "sample8"  "sample12" "sample16" "sample20"
  3. [6] "sample24" "sample28"
  4. #!!注意paste0与paste区别
  5. paste(rep("a",times=5),1:5)
  6. [1] "a 1" "a 2" "a 3" "a 4" "a 5"

#重复的使用rep();有规律的序列用seq()，随机数用rnorm()

  1. rep("a",times=5)
  2. [1] "a" "a" "a" "a" "a"
  3. seq(from=5,to=100,by=5)
  4. [1]   5  10  15  20  25  30  35  40  45  50  55  60  65  70  75
  5. [16]  80  85  90  95 100

#函数组合构建复杂向量

  1. paste0(rep("sample",time=7),seq(from=4,to=30,by=4))
  2. [1] "sample4"  "sample8"  "sample12" "sample16" "sample20"
  3. [6] "sample24" "sample28"
  4. #!!注意paste0与paste区别
  5. paste(rep("a",times=5),1:5)
  6. [1] "a 1" "a 2" "a 3" "a 4" "a 5"2、数据框（类似于表格）3、矩阵4、列表五、对单个向量操作1、给变量名赋值>     (x=c(1,2,3,4,5))
  7. [1] 1 2 3 4 5
  8. x <- c(1,2,3,4,5)#<-赋值符号可用快捷键option+-实现
  9. x
  10. [1] 1 2 3 4 5
  11. #两种方式将赋值结果输出2、对单个向量进行操作(x <- c(2,8,4,8))
  12. [1] 2 8 4 8

#简单数学计算

  1. x+1
  2. [1] 3 9 5 9
  3. log(x)
  4. [1] 0.6931472 2.0794415 1.3862944 2.0794415
  5. sqrt(x)
  6. [1] 1.414214 2.828427 2.000000 2.828427

#根据某条件进行判断,生成逻辑型向量（生成逻辑型向量个数与x中元素个数相等）

  1. x>3
  2. [1] FALSE  TRUE  TRUE  TRUE
  3. x==3
  4. [1] FALSE FALSE FALSE FALSE

#初级统计

  1. max(x) #最大值
  2. [1] 8
  3. min(x) #最小值
  4. [1] 2
  5. mean(x) #均值
  6. [1] 5.5
  7. median(x) #中位数
  8. [1] 6
  9. var(x) #方差
  10. [1] 9
  11. sd(x) #标准差
  12. [1] 3
  13. sum(x) #总和
  14. [1] 22
  15. length(x) #长度(向量里面元素个数)
  16. [1] 4
  17. unique(x) #去重复(保留重复值第一次出现时候)
  18. [1] 2 8 4
  19. duplicated(x) #对应元素是否重复（与前面出现元素比较）
  20. [1] FALSE FALSE FALSE  TRUE
  21. !duplicated(x)
  22. [1]  TRUE  TRUE  TRUE FALSE
  23. table(x) #重复值统计
  24. x
  25. 2 4 8
  26. 1 1 2
  27. sort(x)#排序（升序）
  28. [1] 2 4 8 8
  29. rev(sort(x))#排序（降序）
  30. [1] 8 8 4 2
  31. sort(x,decreasing = T)
  32. [1] 8 8 4 2
  33. 六、对两个向量操作1、相同长度> x = c(1,3,5,1)
  34. y = c(3,2,5,6)

逻辑比较，生成等长的逻辑向量

  1. x == y #x与对应位置y相比
  2. [1] FALSE FALSE  TRUE FALSE
  3. x %in% y #x的每个元素在y中存在吗
  4. [1] FALSE  TRUE  TRUE FALSE

数学计算

  1. x + y
  2. [1]  4  5 10  7

连接

  1. paste(x,y,sep=",")#paste可以自定义连接方式
  2. [1] "1,3" "3,2" "5,5" "1,6"
  3. paste(x,y,sep ="-")
  4. [1] "1-3" "3-2" "5-5" "1-6"

交集 并集 差集

  1. intersect(x,y)
  2. [1] 3 5
  3. union(x,y)
  4. [1] 1 3 5 2 6
  5. setdiff(x,y)#x里面有，y里没有的
  6. [1] 1
  7. setdiff(y,x)#y里面有，x里面没有
  8. [1] 2 62、不同长度——循环补齐> x = c(1,3,5,6,2)
  9. y = c(3,2,5)
  10. x == y # 啊！warning！
  11. [1] FALSE FALSE  TRUE FALSE  TRUE
  12. Warning message:
  13. In x == y : 长的对象长度不是短的对象长度的整倍数  #warning不代表错误
  14. a=c(2,1,5,6,2,2,3,4,5)
  15. y==a
  16. [1] FALSE FALSE  TRUE FALSE  TRUE FALSE  TRUE FALSE  TRUE
  17. #循环补齐(谁长谁说了算)3、循环补齐应用（简化代码）> paste0(rep("x",3),1:3)
  18. [1] "x1" "x2" "x3"
  19. paste0("x",1:3)
  20. [1] "x1" "x2" "x3"七、向量筛选（取子集）——x[]1、x[逻辑值向量]:将TRUE对应值选出，FALSE舍去（依据逻辑值判断，[]中是与x等长的逻辑值向量） ps:注意-号优先级> x <- 8:12

根据逻辑值(与x等长）取子集

  1. x[x==10]
  2. [1] 10
  3. x[x<12]
  4. [1]  8  9 10 11
  5. x[x %in% c(9,13)]
  6. [1] 92、x[数值向量] （依据位置，位置下标从1开始，[]中是由x下标组成的向量）> x <- 8:12

根据位置取子集

  1. x[4]
  2. [1] 11
  3. x[2:4]
  4. [1]  9 10 11
  5. x[c(1,5)]
  6. [1]  8 12
  7. x[-4]
  8. [1]  8  9 10 12
  9. x[-(2:4)]
  10. [1]  8 12
  11. #注意取不连续的位置用c()
  12. x[1,5]
  13. Error in x[1, 5] : 量度数目不对3、修改向量元素(修改一定要赋值！）修改向量中的某个/某些元素：取子集+赋值
  14. x
  15. [1]  8  9 10 11 12
  16. #改一个元素
  17. x[4] <- 40
  18. x
  19. [1]  8  9 10 40 12

改多个元素

  1. x[c(1,5)] <- c(80,20)
  2. x
  3. [1] 80  9 10 40 204、向量作图简单向量作图
  4. k1 = rnorm(12);k1
  5. [1]  0.6543997  0.1743535  1.7244068  2.1252670 -0.8985623
  6. [6] -0.2718248  1.2440448 -1.5326994 -1.1267285  0.4771538
  7. [11] -1.7292906 -0.2294147
  8. k2 = rep(c("a","b","c","d"),each = 3);k2
  9. [1] "a" "a" "a" "b" "b" "b" "c" "c" "c" "d" "d" "d"
  10. plot(k1)
  11. boxplot(k1~k2)八、调整元素顺序——order()和sort()区别 调整元素顺序
  12. x <- c("A","B","C","D","E");x
  13. [1] "A" "B" "C" "D" "E"
  14. x[c(2, 4, 5, 1, 3)]
  15. [1] "B" "D" "E" "A" "C"
  16. scores = c(100,59,73,95,45);scores
  17. [1] 100  59  73  95  45
  18. sort(scores)
  19. [1]  45  59  73  95 100
  1. scores[c(5,2,3,4,1)]
  2. [1]  45  59  73  95 100
  1. scores[order(scores)] #sort(x)约等于x[order(x)]
  2. [1]  45  59  73  95 100
  3. order(scores)
  4. [1] 5 2 3 4 1sort(x)是对向量x进行排序，返回值排序后的数值向量。而order()的返回值是对应“排名”的元素所在向量中的位置。两者默认升序，可加descreaing=T降序排列PS：sort（）在单变量排序中，效果较好；order()因为可以标记排序好之后的下标，在数据框中的排序操作，实用性超强，可以实现。#order应用
  5. #scores依次属于以下几个小朋友，按照分数从低到高给小朋友的名字排序（两个向量等长）
  6. kids = c("jimmy","nicker","lucy","doodle","tony")
  7. scores = c(100,59,73,95,45);scores
  8. [1] 100  59  73  95  45
  9. kids[order(scores)]
  10. [1] "tony"   "nicker" "lucy"   "doodle" "jimmy"
  11. kids[sort(scores)]
  12. [1] NA NA NA NA NA

当向量不等长时(人名>分数)

  1. kids = c("jimmy","nicker","lucy","doodle","tony")
  2. scores = c(100,59,73,95);scores
  3. [1] 100  59  73  95
  4. kids[order(scores)]
  5. [1] "nicker" "lucy"   "doodle" "jimmy"

当向量不等长时(人名<分数)

  1. scores = c(100,59,73,95,45);scores
  2. [1] 100  59  73  95  45
  3. kids = c("jimmy","nicker","lucy","doodle")
  4. kids
  5. [1] "jimmy"  "nicker" "lucy"   "doodle"
  6. kids[order(scores)]
  7. [1] NA       "nicker" "lucy"   "doodle" "jimmy"九、向量匹配——match()ps:    match(y,x)以y为模版调整x顺序(括号里谁在前面谁是模版)，并返回x的元素在向量中位置；x[match(y,x)]谁在外面，谁就在后面> x <- c("A","B","C","D","E");x
  8. [1] "A" "B" "C" "D" "E"
  9. y <- c("B","D","E","A","C")
  10. match(y,x)
  11. [1] 2 4 5 1 3
  12. x[match(y,x)]#谁在外面，谁就在后面
  13. [1] "B" "D" "E" "A" "C"九、错题重现#生成10个随机数: rnorm(n=10,mean=0,sd=18)，用向量取子集的方法，筛选出其中小于-2的值
  14. b=rnorm(n=10,mean=0,sd=18);b[b<(-2)]
  15. [1] -16.174121  -4.892846 -27.588588 -20.281114
  16. #> b=rnorm(n=10,mean=0,sd=18);b[b<-2]（-号优先级低，记得加括号；没有报错不代表没错）
  17. #[1] 0.8782899

生成sample4，sample8，sample12…sample28

  1. x=seq(from=4,to=30,by=4);paste0("sample",x)
  2. [1] "sample4"  "sample8"  "sample12" "sample16" "sample20"
  3. [6] "sample24" "sample28"

x=c(1,1,3,5,7),y=c(2,4,5,6,7)。下列哪些代码可以产生与x等长的逻辑值向量？A、B、C
A x>10
B x%in%y
C dumplicated(x)
D unique(x)

  1. x=c(1,1,3,5,7)
  2. y=c(2,4,5,6,7)
  3. x>10
  4. [1] FALSE FALSE FALSE FALSE FALSE
  5. x%in%y
  6. [1] FALSE FALSE FALSE  TRUE  TRUE
  7. duplicated(x)
  8. [1] FALSE  TRUE FALSE FALSE FALSE
  9. unique(x)
  10. [1] 1 3 5 7

本文图与代码摘自生信技能树，感谢各位老师帮助