R语言基础--向量

R-基础-向量

• 运行代码快捷键：ctrl + enter

• tab 补全

• 控制台清屏：ctrl +l

• 赋值（<-）：alt + -

• 放大字体：tools => global options => appearance => zoom => 150%

• 符号皆为英文符号

• ？函数名，查看帮助文档

• 设置工作目录

setwd('E:\bioinfo_study\one')#设置工作目录
Error: '\o' is an unrecognized escape in character string starting "'E:\bioinfo_study\o" 
##报错原因，我直接在文件夹那里复制路径，里面的\，R无法识别，手动改/，即可
##其他错误还可能有，路径当中的文件夹不存在
setwd('E:/bioinfo_study/one')
getwd()
[1] "E:/bioinfo_study/one"

常量和变量

• 基本的数据类型有数值型， 逻辑型（TRUE, FALSE），文本（字符串）

> a <- 1:10
> a
 [1]  1  2  3  4  5  6  7  8  9 10
> typeof(a)
[1] "integer"#数值型 （整型） ##double浮点型
> a <- "good"
> a
[1] "good"
> typeof(a)
[1] "character"#字符型
> a <- TRUE
> typeof(a)
[1] "logical"#逻辑型，一般产生自比较

####类型转换
as.numeric() #转化为数值型
as.logical() #转化为逻辑型
as.character()#转化为字符型

• 常量：数值、字符串、逻辑（TRUE、FALSE）

• 变量：用来保存输入的值或者计算得到的值（赋值的对象）

  变量都有变量名，R变量名必须以字母、数字、下划线和句点组成， 变量名的第一个字符不能取为数字。 变量名是区分大小写的， y和Y是两个不同的变量名

  数据结构之向量

  • 向量赋值，及其基础操作

    1. 赋值

       ####字符串元素，用单引号或者双引号
       > name<-'xiaohong'
       > name
       [1] "xiaohong" #一个元素的向量
       ####数值元素
       ##直接写一个数字
       > b <- 2
       > b
       [1] 2
       ​
       ####用c()函数把多个元素或向量组合成一个向量
       #元素以逗号分隔，元素的序号（下标）从1开始计数
       > marks <- c(10, 6, 4, 7, 8)
       > marks
       [1] 10  6  4  7  8
       > x <- c(1:3, 10:13) # 冒号左右都能取到
       > x
       [1]  1  2  3 10 11 12 13
       > x1 <- c(1, 2)
       > x2 <- c(3, 4)
       > x3 <- c(x1, x2) # 2组向量拼成1组，还是向量（一维的）
       > x3
       [1] 1 2 3 4  
       > print(x3) #显示向量除了直接输入向量名，还可以用 print()
       [1] 1 2 3 4
       > name <- c('AA','BB','CC')
       > name
       >[1] "AA" "BB" "CC"
       ​
       ####用seq 生成连续的数值
       > x4 <- seq(4)
       > x4
       >    [1] 1 2 3 4
       > x4 <- seq(2:4)
       > x4
       >    [1] 1 2 3
       > x4 <- 2:4 ##可以直接用冒号，表示2到4，2和4都能取到
       > x4
       >    [1] 2 3 4

    2. 数值型向量基础操作

       > length(x3)
       [1] 4
       ####使用 [] 根据元素的下标取值，单独一个下标或者【】里面填起始位置和终止位置，冒号连接
       #x[2]取出第二个元素
       #x[2] <- 99 修改第二个元素为99
       #x[c(1,3)] 取出第1、3号元素
       > x
       [1]  1  2  3 10 11 12 13
       > x[1:4] 
       [1]  1  2  3 10
       ###which 返回的是满足条件的元素的下标
       > which.max(x)
       [1] 7 #下标
       > which.min(x)
       [1] 1 #下标
       ##如果用substring是什么效果，这个函数看名字就知道是在字符串中使用的
       > print(x3)
       [1] 1 2 3 4
       > substring(x3,2,3) 
       [1] "" "" "" ""   #但是也并没有报错
       > x3[2:3]
       [1] 2 3
       ​
       #######
       ######四则运算用+ - * / ^表示(加、减、乘、除、乘方)，略
       #四则运算时如果有缺失值，缺失元素参加的运算相应结果元素仍缺失
       #等长向量的运算为对应元素两两运算
       #两个不等长向量的四则运算，规则是每次从头重复利用短的一个，示例如下
       > x1 <- c(1, 2) #2个元素
       > x4
       [1] 2 3 4 #3个元素
       > x1+x4
       [1] 3 5 5 # 先按下标对应相加，然后循环长度短的那个，即1+4=5
       Warning message: ###两个向量的长度不是倍数关系会发出警告
       In x3 + x4 :
        longer object length is not a multiple of shorter object length
       ​
       #除法取整
       > 5 %/% 3
       [1] 1
       #取余
       > 5 %% 3
       [1] 2
       ###取余的一个应用是，判断某数是不是偶数、3的倍数、5的倍数等
       x %% 2 == 0
       ​
       ######基础常用统计函数
       > x <- c(33, 55, 11)
       > sort(x) ##正序
       [1] 11 33 55
       > rev(sort(x))  ##倒序
       [1] 55 33 11
       > order(x) ##正序的下标
       [1] 3 1 2
       > sum(x) #和
       [1] 99
       > mean(x) #均值
       [1] 33
       > var(x) #方差
       [1] 484
       > sd(x) #标准差
       [1] 22
       > min(x)
       >    [1] 11
       > max(x)
       >     [1] 55
       > prod(x) #乘积
       >    [1] 19965
       > cumsum(1:5) #1 2 3 4 5累加
       >    [1]  1  3  6 10 15  #一步一步累加的和
       > cumprod(1:5)
       >    [1]   1   2   6  24 120 #一步一步累乘的积
       > sqrt(c(1, 4, 6.25))
       >    [1] 1.0 2.0 2.5  #平方根
       ​
        ######其他函数
        #如log10
       ​
       > a <- c(1,10,100)
       > a
       >    [1]   1  10 100
       > log10(a)
       >    [1] 0 1 2

    “为了查看这些基础的数学函数的列表，运行命令help.start()， 点击链接“Search Engine and Keywords”， 找到“Mathematics”栏目， 浏览其中的“arith”和“math”链接中的说明”
    --R语言教程

    3. 逻辑型向量

       逻辑值一般产生自比较、判断

    > c(1, 3, 5) > 2
    [1] FALSE  TRUE  TRUE
    > (1:4) >= (4:1)
    [1] FALSE FALSE  TRUE  TRUE
    > c(1, NA, 3) > 2
    [1] FALSE    NA  TRUE
    > NA == NA
    [1] NA
    ####使用 is.na 判断值是否是NA
    > is.na(c(1, NA, 3))
    [1] FALSE  TRUE FALSE
    ####比较运算符 <   <=  >  >=  ==  !=  %in%
    ### x %in% y，判断x向量中的元素能否在y中找到
    > c(NA,3) %in% c(2,3,4)
    [1] FALSE  TRUE
    > c(3,4) %in% c(2,3,4) ##无论下标一致与否，找到就是true
    [1] TRUE TRUE
    ####
    > match(c(1, 3), c(2,3,4,3))
    [1] NA  2
    
    #####逻辑运算符 与 &   或 |     非 ！
    > 1==2&3!=4
    [1] FALSE
    > 1==2|3!=4
    [1] TRUE
    #####使用 all 判断逻辑向量的所有元素为真，全部为真，则TRUE
    > c(1, NA, 3) > 2
    [1] FALSE    NA  TRUE
    > all(c(1, NA, 3) > 2)
    [1] FALSE
    ####使用 any 判断逻辑向量的至少有一个元素为真
    > any(c(1, NA, 3) > 2)
    [1] TRUE
    ##返回真值的下标
    > which(c(1, NA, 3) > 2)
    [1] 3
    
    #####使用 identical(x,y) 比较xy的内容是否完全相同
    > identical(c(1,2,3), c(1,2,NA))
    [1] FALSE
    > identical(c(1,2,3), c(1,2,3))
    [1] TRUE
    #### 使用 duplicated 判断重复
    > duplicated(c(1,2,1,3,NA,4,NA))
    [1] FALSE FALSE  TRUE FALSE FALSE FALSE  TRUE #第一次出现不会被认为重复
    ####使用 unique 去重
    > unique(c(1,2,1,3,NA,4,NA))
    [1]  1  2  3 NA  4 #顺序还是原来的第一次出现的那个

    4. 字符型向量基础操作

    > ############################## 拼接 ###############################
     > a <- 1:15
     > a
      [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
     #####使用 rep 生成重复的元素，注意！！！不是repet()
     > b <- rep("gene",times=15) ##rep("gene",15)也可以
     > b
      [1] "gene" "gene" "gene" "gene" "gene" "gene" "gene" "gene" "gene" "gene" "gene"
     [12] "gene" "gene" "gene" "gene"
     ##### paste 拼接两个向量
     > paste(b,a)
      [1] "gene 1"  "gene 2"  "gene 3"  "gene 4"  "gene 5"  "gene 6"  "gene 7"  "gene 8" 
      [9] "gene 9"  "gene 10" "gene 11" "gene 12" "gene 13" "gene 14" "gene 15"
     ###注意1：本来a是数值型，b是字符串，paste自动把数值型向量转换为字符型
     ###注意2：gene和1之间存在空，这是默认用空格连接
     ###注意3：及时查看帮助
     #paste (..., sep = " ", collapse = NULL)#语法,可看到默认分隔符
     #paste0(..., collapse = NULL)#语法，这个没有分隔
     #所以：
     > paste(b,a,sep="")
      [1] "gene1"  "gene2"  "gene3"  "gene4"  "gene5"  "gene6"  "gene7"  "gene8"  "gene9"  "gene10"
     [11] "gene11" "gene12" "gene13" "gene14" "gene15"
     > paste0(b,a)
      [1] "gene1"  "gene2"  "gene3"  "gene4"  "gene5"  "gene6"  "gene7"  "gene8"  "gene9"  "gene10"
     [11] "gene11" "gene12" "gene13" "gene14" "gene15"
     ###再简化
     > paste0("gene",1:5)
     [1] "gene1" "gene2" "gene3" "gene4" "gene5"
     ###再拓展
     > paste0(c("a","b","c"),seq(3),collapse = "") #collapse参数是拼成一个元素
     [1] "a1b2c3" ##注意顺序，采用一般向量间运算规则
     ​
     ########################### 大小写转换 ##############################
     > d <- c("a","b","c")
     > toupper(d)
     [1] "A" "B" "C"
     > tolower(c("PASSWORD"))
     [1] "password"
     ​
     ###################### 取子串 ##################################
     # substr(x, start, stop) 
     > substr("password",1,4)
     [1] "pass"
     > substr(c('JAN07', 'MAR66'), 1, 3)##注意！！！是对每个元素取1到3字符，向量长度不变。与 【】 取子集区分
     [1] "JAN" "MAR"
     > name <- c('AA','BB','CC')
     > name[2:3]
     [1] "BB" "CC" #向量的长度改变
     > substring(c('JAN07', 'MAR66'), 4)##stop不写，默认取到最末
     [1] "07" "66"
     ​
     ########################## 拆分 ################################
     语法strsplit(x, split, fixed = FALSE, perl = FALSE, useBytes = FALSE)
      > y <- '10,8,7,abc,&'
     > strsplit(y, ',', fixed=TRUE)[[1]]
     [1] "10"  "8"   "7"   "abc" "&" ##以“，”分隔，TRUE：完全分割
     ​
     ######################## 替换 ####################
     grep(pattern, x, ignore.case = FALSE, perl = FALSE, value = FALSE,
      fixed = FALSE, useBytes = FALSE, invert = FALSE)
     #替换的模式，操作对象，
     gsub(pattern, replacement, x, ignore.case = FALSE, perl = FALSE,
      fixed = FALSE, useBytes = FALSE)
     > x <- '1, 3; 5'
     > gsub(';', ',', x, fixed=TRUE) #冒号 替换成 逗号，
     [1] "1, 3, 5"
     > grep(3,x) #抓取x中的3
     [1] 1 #返回数量
     > grep(3,x,fixed=TRUE)
     [1] 1

    其他

    > c <- 33.3 ##浮点数
    > typeof(c)
    [1] "double" #浮点型
    > b <- 2
    > b
    [1] 2
    > typeof(b)
    [1] "double"  ##在R语言中数值一般看作double, 如果需要明确表明某些数值是整数， 可以在数值后面附加字母L
    > class(b)
    [1] "numeric"
    > d <- 2L #大写L，换成其他字母不可，小写l也不可。
    > class(d)
    [1] "integer" ## 2L是个整型。
    > typeof(d)
    [1] "integer" ##typeof和class都是返回类型，integer和double都是numeric
    > y <- 1:5
    > typeof(y)
    [1] "integer" #整型
    > y2 <- seq(5)
    > typeof(y2)
    [1] "integer" #整型
    > y3 <- c(1,2,3,4,5) #用c()函数就是浮点型
    > class(y3)
    [1] "numeric"
    > typeof(y3)
    [1] "double"

    贴一个网上的资料:

    https://www.cnblogs.com/csguo/p/7285453.html