我记了一个R视频笔记-提示我该学哪些

1.R语言、Rstudio简介

• 11:50 CRAN官方网站

image-20191002135537331

Task views 比如我想做生存分析 但是我不知道生存分析哪些包可以做，这时我就可以在这里面找

向下拉可以看到有很多包，可以看到有的包后面带有core字样，这种为核心包

展示这个包的函数的用法及

• 19:38 Rstudio网站的包

image-20191002150829525

• 23:00推荐R网站

r-bolggers

Rdocumentation：包含cran、bioconductor 、github

中文网站：统计之都（可在网站中提问）

• 27:00Rstudio基本设置

  • 功能区（主要是plots、packages、help三个工具框）
  • packages-install：可以安装cran上的包或者已经下载好的以.tgz和.tar.gz的包
    • install dependencies 是否安装依赖包，如果不勾选，一些包的功能就无法实现
  • help上的帮助问答和在cran官网上看到的包的帮助文档是一样的
    • 

      image-20191002154538382

• 34:04Rstudio上的工具框

  • file:同左上角点击+新建rscripts
  • import dataset ：from csv\spss 等
  • tools：点击global options
    • appearance
    • packages：镜像问题 r语言在中国也是有镜像的，因此不需要登录到美国去，可以增加下包的速度
    • code：点击saving：改变默认字符编码格式，改成UTF-8,为了方便我们以后读入含有中文的数据集，防止出现乱码
  • 改变四个框的排版问题
  

  image-20191002153214069

• 保存问题

  • 如果是untitiled,退出后写的代码不会消失
  • 如果已经点过保存，那么会让你命名，如果接下来对代码进行了修改，那么关掉时会询问，如果点击don‘t save，那么刚才修改了的代码就不会保存下来，点击save才会保存最后关掉时的代码

2.R包的安装、向量

• 02:11R包安装函数 install.packages后面的r包名称要是一个字符串，也就是加了''的

  • repos：传入的镜像地址可以提高下载r包速度
  • dependencies 逻辑参数，默认是设置为true的
  • installed.packages
  • 三种包来源：cran、bioconductor、github（devtools）

• 10:47devtools帮助从github上下载包

  • devtools是扩展包，不是R的内置包，使用前必须要加载

• 16:00查看安装的r包所在的位置 .libPaths()

• 卸载包remove.packages()

• 18:46向量

  • 赋值 <- =推荐前者

  • identical 可以用来判断两个向量是否一样，只有全部（位置）一样，才返回TRUE

    #根据向量位置，也就是位置
    vector <- 1:10
    vector[1:4] #1:4为1到4
    vector[-c(2,5,8)] #2,5,8是下标
    vector2<-c(1,4,'ABC','nihao')#通过c函数将括号里面所有的封装在一起
    

• 思考题

  • x<-1:5
    y<-6:10
    x+y
    x<-1
    x+y
    

3.数值型、逻辑型向量

• 1:20向量类型

  • 数值型向量：r语言中只有数值型，无整型intrger、浮点型floot的区分

  • 当有y<-1:3,class(y),结果就是integer

  • seq

  • seq(from=1,to =5,by=0.5)
    seq(1,5,length.out=8)
    seq(1,5,len=-10)
    seq(1,5,along.with=1:3)
    

  • rep

  • rep(c(1,3),time=5)
    rep(c(1,3),each=5)
    rep(c(1,3),leng=9)
    

• 19:09逻辑型

  • 非错即对

  • logit<-c(100>99,100>101)
    

  • 进行逻辑判断：'>' '<' '==' '!='

  • AND符号：& 必须全部满足，才会返回true

  • c(100>90&100>100)
    [1]FALSE
    c(100>90&110>100)
    [1]TRUE
    

4.逻辑表达式&字符串向量

• 00:50逻辑表达式

  • x<-seq(1,100,lenth.out = 20) #是一个均分的过程
    index<- x > 80#当不知道下标时，需要一个逻辑向量的概念
    x[index]#默认取出true
    #也可以通过下标来取出，如下
    which(x>80)
    x[which(x>80)]
    x[x>80&x<90]
    x[x>80|x<90]
    

• 9:30 字符串

  • 用''包括

  • string<-c('abc','def',1,2)#1就不再是数值型，而是字符型
    class(string[3])
    [1] 'character'
    is.character(string)
    [1] TRUE
    

• 12:16 letters/LETTERS都是向量

  • 目的：帮助在进行因子型操作时可以更简洁生成分类变量

  • letters[1:5]
    [1]'a''b''c''d''e'
    LETTERS[24:28]
    [1]'X''Y''Z'NA NA
    

  • 上面的NA是因为没有这个元素，用下标提取时，由于没有这个下标的元素，就会产生NA

• 15:40总结注意理解用[]+逻辑表达式进行元素的提取

5.因子型变量

• 00:25也可以是分类变量

  • 男女、血型：无序型变量
  • 药物是否有效：无效、有效、痊愈，有序型变量，因为是一个逐渐递增的过程

• 01:58在r中介绍

  • my_fac<-factor(x=c(1,2),times=5,leves=c(1,2),labels=c('male','female'))
    class(my_fac)
    

    my_fac2<-factor(LETTERS[1:5],labels = letters[1:5])
    my_fac3<-factor(1:5,labels = letters[1:5])
    my_fac4<-gl(n=2,k=5,labels = c('control','treatment'))
    my_fac5<-gl(n=2,k=1,length=8,labels = c('control','treatment'))
    

    temp_string<-c('A','B','AB','0')
    my_fac6<-as.factor(temp_string) #把temp_string变成因子
    my_fac6
    as.character(my_fac6)#互相转换
    

    nlevels(my_fac6)#可以查看有几个水平，通常结合as.factor使用
    [1] 4
    leves(my_fac6)
    [1]'A','B','AB','0'
    

• 16:20 reference：得到的结果都要同reference来进行比较，就需要生成一个哑变量，就是这个reference

  • my_fac7<-relevel(my_fac6,ref='b')
    my_fac7
    [1]A B AB 0
    Levels:B A AB 0 #这里的levels就是讲B设置为了reference，也就是哑变量,出现在第一位
    my_fac6
    [1]A B AB 0 #未设置前默认A第一位是这个哑变量
    Levels：A B AB 0
    

• 19:34 有序型因子变量

  • x<-c('0mg','10mg','20mg','50mg')
    my_order_fac<-factor(x,ordered=T)
    [1]0mg 10mg 20mg 50mg
    levels：0mg<10mg<20mg<50mg
    #有一个扩展包DescTools #的reorder函数
    x<-c('p','10mg','20mg','50mg')
    my_order_fac<-factor(x,ordered=T)
    my_order_fac
    [1] p 10mg 20mg 50mg
    levels:10mg<20mg<50mg
    

6.列表&矩阵

• 1:15列表&矩阵

• 2:10在r中生成列表

  • my_list<-list(1,2,3,'R','nihao',TRUE,FALSE)
    [[1]]
    [1] 1
    
    [[2]]
    [1] 2
    
    [[3]]
    [1] 3
    
    [[4]]
    [1] "R"
    
    [[5]]
    [1] "nihao"
    
    [[6]]
    [1] TRUE
    
    [[7]]
    [1] FALSE
    
    

• 4:50从list中提取元素

  • > my_list2<-list(1:10,letters[1:5])
    > my_list2
    [[1]]
     [1]  1  2  3  4  5  6  7  8  9 10
    
    [[2]]
    [1] "a" "b" "c" "d" "e"
    > my_list2[1]
    [[1]]
     [1]  1  2  3  4  5  6  7  8  9 10
    
    > class(my_list2[1])
    [1] "list"
    > my_list2[[1]]
     [1]  1  2  3  4  5  6  7  8  9 10
    > class(my_list2[[1]])
    [1] "integer"
    > my_list2[[1]][3]
    [1] 3
    > my_list2[[2]]
    [1] "a" "b" "c" "d" "e"
    > my_list2[[2]][4]
    [1] "d"
    

• 8:20 再建一个比较复杂的list,list可以包含list

  • my_list3 <- list(1:10,letters[1:5],list=(11:14,LETTERS[1:5]))
    #找到my_list3里的大写A
    > my_list3<-list(1:10,letters[1:5],list(11:14,LETTERS[1:5]))
    > my_list3
    [[1]]
     [1]  1  2  3  4  5  6  7  8  9 10
    
    [[2]]
    [1] "a" "b" "c" "d" "e"
    
    [[3]]
    [[3]][[1]]
    [1] 11 12 13 14
    
    [[3]][[2]]
    [1] "A" "B" "C" "D" "E"
    
    
    > my_list3[[3]][[2]][1] #两个[[]]可以取到下一层，一个[]还是list，往下取就是matrix
    [1] "A"
    

• 11:40 矩阵

  • 是一个线性代数的一个概念

  • my_matrix<-matrix(data=1:6,nrow=2,brow=TRUE)#brow默认是false，就是默认是按列排列的
    my_matrix2<-matrix(data=1:10,nrow=5)
    > my_matrix3
         [,1] [,2] [,3] [,4]
    [1,]    2    2    2    2
    [2,]    2    2    2    2
    [3,]    2    2    2    2
    > my_matrix4<-matrix(data = letters[1:3], nrow = 2,ncol = 4)
    Warning message:
    In matrix(data = letters[1:3], nrow = 2, ncol = 4) :
      数据长度[3]不是矩阵行数[2]的整倍
    > my_matrix4
         [,1] [,2] [,3] [,4]
    [1,] "a"  "c"  "b"  "a" 
    [2,] "b"  "a"  "c"  "b" 
    > my_matrix5<-matrix(data = 1:12,nrow = 3,ncol = 4,dimnames = list(c('a','b','c'),c('v1','v2','v3','v4')))
    > my_matrix5
      v1 v2 v3 v4
    a  1  4  7 10
    b  2  5  8 11
    c  3  6  9 12
    

• 19:50转至

  • 也是线性代数的一个概念

  • > t(my_matrix5)
        a  b  c
    v1  1  2  3
    v2  4  5  6
    v3  7  8  9
    v4 10 11 12
    

• 20:50除了列表外，向量、矩阵李敏所要求的数值型类型必须是相同的，即使原本传入的是数值型，matrix也会把数值型转变成字符型

  • > my_matrix6<-matrix(c(1:5,letters[1:5]),nrow = 2)
    > my_matrix6
         [,1] [,2] [,3] [,4] [,5]
    [1,] "1"  "3"  "5"  "b"  "d" 
    [2,] "2"  "4"  "a"  "c"  "e" 
    

7.数组&初识数据框

• 0050:生成数组

  • array，括号里依次是行、列、层

  • > my_array<- array(data=1:16,dim=c(2,4,2)) ##第一个数组示例
    > my_array
    , , 1
    
         [,1] [,2] [,3] [,4]
    [1,]    1    3    5    7
    [2,]    2    4    6    8
    
    , , 2
    
         [,1] [,2] [,3] [,4]
    [1,]    9   11   13   15
    [2,]   10   12   14   16
    
    > my_array2<-  array(1:16,dim=c(4,2,2),dimnames=list(c(LETTERS[1:4]),c('col1','col2'),c('first','second')))  ##第二个数组示例，包括给数组命名
    > my_array2
    , , first
    
      col1 col2
    A    1    5
    B    2    6
    C    3    7
    D    4    8
    
    , , second
    
      col1 col2
    A    9   13
    B   10   14
    C   11   15
    D   12   16
    

• 10:58数据框

  • 生成数据框

  • > my_df<-data.frame(name=c('TOM','ANDY','MARRY'),age=c(24,25,26),hegight=c(178,156,176))
    > my_df
       name age hegight
    1   TOM  24     178
    2  ANDY  25     156
    3 MARRY  26     176
    

  • nrow、ncol

• 18:20介绍iris数据集

8.数据框

• 00：50注意变量名

  • 当某一列长度不一样，会报错
  • str 查看结构
  • stringsAsFactors = FALSE

• 08:40数据操作

  • my_df$four <-letters[1:5,1:5]#新增
    my_df2<-edit(my_df)#弹出后，修改某一个数值，必须赋值一个新变量
    fix(my_df)#永久改，不需要赋值一个新的变量
    

• 16:40 head tail

• 18:30 describe(iris)用来查看数据框里更多内容：mean

• 21:55names查看变量名names(iris)<-c('a','b','c','d','e')

• 23:50把变量名改成中文,可以帮助改变量名，解决中文乱码

  • 需要增加一行代码

  • Sys.setlocale(catrgory = 'LC_CTYPE',locale='zh_CN.UTF-8')#mac系统
    Sys.setlocale(locale='chinese') #windows可以改
    

9.数据框的基本操作

• 01:40cbind函数 ：按列合并要求必须行数相同

image-20191003122444068

image-20191003122456621

• 03:20rbind函数：按行合并，要求有相同的变量数目

• 06:50merge函数 不加任何参数，会按相同列进行merge

• 11:50数据框的切分

  • 抽样sample

  • iris[sample(1:nrow(iris),30,),]#行数的下标
    

• 17:15随机数种子set.seed为了方便后续可重复性操作

下面是3中切分方式

• 18:20大刀阔斧切分

  • split

  • iris_sub2<-split[iris,f = iris $setosa]#会切分出三个小数据框，只有list可以容纳3个数据框，因此iris_sub2是一个列表
    

• 20:40手术刀切分

  • 根据逻辑表达式找到下标的位置

  • iris_sub3<- iris[iris$方=='setosa'& iris$我>4.5,1:2]#精细操作，用&增加逻辑条件，同时','后面又增加了只取1到2列
    

• 23:40subset函数

  • iris_sub4<-subset(iris,iris$方=='setosa'& iris$我>4.5,select = 1:2)#select用来选择想要的列
    

10.条件与循环

• 条件用if语句，判断条件是否成立，r里不推荐用
• 04:30{}放在if语句后面，为执行语句==放在同一行，要用；====else要跟在第二个‘}’==,要是else另起一行，r语言就不认识了

image-20191003130946507

• 09:30循环-repeat

  • repeat是一个语句，因此后面也跟{}，表示重复。

  • > i<- 5
    > repeat{if (i>25) break else
    + {print(i)
    +   i<-i+5}
    + }
    [1] 5
    [1] 10
    [1] 15
    [1] 20
    [1] 25
    

• 12:10 while

  • while 当满足时就执行这个语句体，当不满足时，就不执行

  • > i<-5
    > while(i <=25){
    +   print(i)
    +   i<-i+5
    + }
    [1] 5
    [1] 10
    [1] 15
    [1] 20
    [1] 25
    

• for 语句

  • > for (i in 1:10){    ##i为在事先赋值，让i在1:10里循环，这也是一个体现向量化循环
    +   print(i)
    + }
    [1] 1
    [1] 2
    [1] 3
    [1] 4
    [1] 5
    [1] 6
    [1] 7
    [1] 8
    [1] 9
    [1] 10
    

    > set.seed(2017)
    > x<-sample(10:100,10)
    > y<-sample(1:100,10)
    > for(i in 1:10){#i可以看成是一个位置，就是往z里填充元素，但是这个z装下是个数
    +   z[i]= x[i]>y[i] 
    +   }
    > z
     [1] FALSE  TRUE FALSE FALSE  TRUE FALSE FALSE FALSE  TRUE FALSE
    > x
     [1] 37 14 39 46 94 27 35 42 99 38
    > y
     [1] 89  1 56 57 70 86 63 44 72 69
    

    • ==append==但是把z附一个初值

    > ####append
    > set.seed(2017) #结合了for循环，就会变成向量化操作
    > x<-sample(10:100,10)
    > y<-sample(1:100,10)
    > z<-NULL
    > for(i in 1:10){
    +   if(x[i] > y[i]){
    +     z= append(z,x[i])  #append追究添加到z的结果里，先进行一个 if(x[i]>y[i]的判断
    +   }
    + }
    > z
    [1] 14 94 99
    > x
     [1] 37 14 39 46 94 27 35 42 99 38
    > y
     [1] 89  1 56 57 70 86 63 44 72 69
    

• 19:00两重循环

  • mat<-matrix(NA,nrow = 4,ncol = 5)
    for(i in 1:4){
      for(j in 1:5){
        mat[i,j] <- 2
      }
    }
    

    

    image-20191003133625109
  • 

    image-20191003133650909

11.自定义函数&数据读取

• 01:00mean()

• 04:20自定义函数

  • #三个...代表缺省参数,{}里面是函数体
    (1)my_fun1<-function(x,y){
      x+y
    }
    my_fun1(1+2)
    
    (2)my_fun2<-function(x,y=2){   #x是实名参数
      x+y
    }
    my_fun2(1)
    
    (3)values<-c(sqrt(1:100))
    my_fun3<-function(x,...){ #不知道summary里有什么参数因此两个...相互呼应,完全一致的
      print(x)
      summary(...)
    }
    my_fun3('here is the summary for values:',values,digits=2)
    
    (4)addemup<-function(x,...){
      args<-list(...)
      for(a in args) x<-x+a
      x
    }
    addemup(1,2,3,4,5)
    
    (5)normalize<-function(x,m=mean(x,...),s=sd(x,...),...){
      (x-m)/s
    }
    normalize(x=1:100)                      
    
     
    

• 14:20从外部读取数据

  • 顶部File 》Impotr Dataset
    • comma：逗号分隔符
  • read.csv对应.csv
    • header:设置为真，就是第一行为变量名
    • sep：默认是‘，’
    • col.names：对列名想要更改可以重新定义它
  • read.table对应.txt
  • ==library====(read_exc====el)==》read_excel函数
  • XLConnect包

image-20191004094417173

12.数据的读取与写出

• 00:50scan/cat
  • scan函数 扫描
  • cat函数 读出去 file = 就是一个完整路径，在最后命个名
• 03:15读取SPSS SAS SATAT
  • library(foreign)
  • readLines可以读取fasta
  • stringi包也可以读取fasta，也就是文本格式
• 14:00导出去
• write.csv
• 读取excel时不能用read.csv，但是导出excel时可以用write.csv
  • 如果是新文件不需要设置append=T，如果是已经存在的文件需要加参数append=T
• writeLines()

13.数据排序与长宽型数据转换

• sort、rank（秩次，返回的是位置）

• order(x)可对数据框排序，返回的是排序前的元素当按照从小到大排列后，排序前的元素的位置

  • > x<-c(23,24,56,46,78,2,95,47)
    > sort(x)
    [1]  2 23 24 46 47 56 78 95
    > rank(x)
    [1] 2 3 6 4 7 1 8 5
    > order(x)
    [1] 6 1 2 4 8 3 5 7
    > x[order(x)]
    [1]  2 23 24 46 47 56 78 95
    

• 12:30长宽数据转换-stack

  

  image-20191004103528348
  

  image-20191004103554576

• 

  image-20191004103802869
  

  image-20191004103834437

  • Value:值

    index：分类

• 16:30reshape

• 

  image-20191004110403412

• 22:00reshape2进行长宽型数据转换

  • 判断是长形数据还是宽型数据，若是宽型数据，我们就用melt函数把它融化成长形数据，其中id.vars=...，这个...如果是长形数据，那么这一列就不需要融化，就用id.vars给标识出来就可以

  #melt()融化函数 参数：id.vars= 就是标示出不融化的
  #dcast()汇总函数 参数：
  #(1)formula= Species～variable formula就是写一个公式，标识变量写在左边，想要操作的变量写在右边，
  #(2)fun.aggregate 汇总函数 
  #(3)value.var 对哪个变量进行汇总
  

• 26:00复杂一点的数据

  • 下面这个后5列都是长形数据，是一个不同水平堆栈在一起的一个结构，只有前两列是纯粹数据。因此不需要melt来融化了，直接可以用dcast()函数
• 

  image-20191004111925715

  tips #上面的图片来自tips数据
  dcast(data=tips,formula = sex~. , fun.aggregate = mean, value.var = tip)#.是目前仅对sex这一个分类变量，用.来进行站位
  
  dcast(dcast(data=tips,formula = sex~somker , fun.aggregate = mean, value.var = tip))
  

14.变量的因子化

• 变量的因子化：患者年龄，不能按照连续性变量，但可以变成分类变量

• 1.公式法

  age<-sample(20:80,20)
  > age
   [1] 59 41 68 27 26 23 47 58 44 75 72 38 77 24 56 48 74 66 54 70
  age1<-1+(age>30)+(age>=40)+(age>=50)
  age2<-1*(age<30)+2*(age>=30&age<40)+3*(age>=40&age<50)+4*(age>50)
  

• 2.cut()

• age3<-cut(age,breaks = 4,labels = 'young','middle','m-old','old'),include.lowest = TRUE, right =TRUE)
  
  > age4<-cut(age,breaks = seq(20,80,length=4),labels = 'young','middle','m-old','old')
  Error in cut.default(age, breaks = seq(20, 80, length = 4), labels = "young",  : 
    'breaks'和'labels'的长度不一样
  

  • 小插播seq，加length和不加length的区别

  > seq(20,80,4)
   [1] 20 24 28 32 36 40 44 48 52 56 60 64 68 72 76 80
  > seq(20,80,length=4)
   [1] 20 40 60 80
  

• 3.ifelse()

• ifelse(age>35,'old','young')
  ifelse(age>60,ifelse(age<30,'young','old',))
  > ifelse(age>60,'old',ifelse(age<30,'young','middle'))
   [1] "middle" "middle" "old"    "young"  "young"  "young"  "middle" "middle" "middle" "old"    "old"   
  [12] "middle" "old"    "young"  "middle" "middle" "old"    "old"    "middle" "old"   
  

• 4.car()扩展包

• recode(var=age,recodes="20:29 =1;30:39=2;40:49=3;50:hio=4")
  

15.apply函数家族

• 00:44数据汇总

• 3:00apply+lapply

• mat<-matrix(1:24,nrow =4,ncol= 6)
  apply(mat,1,sum)
  apply(iris[,1:4],2,mean)
  lapply(X = c(1:5),FUN = log)#返回的是list #遍历
  lapply(iris[,1:3],function(x)lm_x~iris$Petal.Width,data=iris[,1:3])
  

• 07:40sapply 返回的是向量、矩阵、数据框

• sapply(1:5,log)
  sapply(1:5,function(x)x+3)
  

• 09:26tapply 只适用于数据框，是根据分类变量将一个数值型变量进行切分，在进行数据汇总

• tapply(X=iris$Sepal.Length,INDEX = iris$Species,FUN = mean)
  

• 11:40mapply

  myfun<-function(x,y){
    if(x>4)return(y)
    else return(x+y)
  }
  myfun(1:5,2:6)
  
  mappply(myfun,1:5,2:6)
  

16.数据汇总函数

• 1:30 Ave

• 3:00 by

• 5:50aggrate 根据数据框原本的变量生成新的变量

• view(mtcars)
  

  

  image-20191004162515374

• 14:30vsweep 针对数组

17.plyr包

• 

  image-20191004171145882
  

  image-20191004172823006

  ==上面显示sex和smoker的方法是相同的意思，都是分类变量==

• 21:00dlply,lapply输出都是list，在做回归分析时用的多

  ​ 比如对iris数据集中的两个变量进行回归

  my_model<-function(x)lm(Sepal.length~Sepal.Width,data =x)
  dlply(iris,~Species,my_model)
  

  ==上面不太懂==

• 23:50 each()、colwise()、numcolwise()对数据集进行批量操作
• 

  image-20191004175815830
• 

  image-20191004180310297

18.dplyr包

• 00:40filter

  sub1<-filter(tips,tis$smoker=='No',tips$day=='Sun')#filter只针对数据框的行进行筛选
  sub2<-slice(tips,1:5)#针对行
  sub3<-select(tips,tip,sex,smoker)
  sub4<-select(tips,2:5)
  

• Arrange()

• nex_tips <- arrange(tips,desc(total_bill),tip)
  head(nes_tips)
  
  new_tips<-rename(tips,bill = total_bill,tipp = tip)
  distinct(tips,day)#返回因子水平函数
  
  

• mutate()

• mutate(tips,rate=tip/total,new_rate=rate*100)#new_rate和rate同步运行
  #transform这种情况就会报错，运行rate，可直接new_rate
  transform(tips,rate=tip/total,new_rate=rate*100)
  

• sample_n

• sample_n(iris,size=10)#随机抽取10行，
  sample_frac(iris,0.1)#随机抽取10%的行数，数据有150行，抽取15行
  

• group_by,与summarise结合使用

• group = group_by(tips,smoker)#把数据框中根据分类变量进行分组，然后进行汇总操作
  summarise(group,count = n(),mean_tips = mean(tip),sd_bill=sd(total_bill))#n用来计数
  

• %>%管道符

• result<-tips %in% group_by(smoker,sex) %in% summarise(group,count = n(),mean_tips = mean(tip),sd_bill=sd(total_bill))
  

• 20:20join家族

• df_a<-data.frame(x=c('a','b','c','a','c','b','c'),y=1:7)
  df_b<-data.frame(x=c('a','b','c'),z=10:12)
  
  inner_join(df_a,df_b,by='x')
  
  semi_join(df_a,df_b,by='x')
  
  anti_join(df_a,df_b,by='x')
  
  left_join(df_a,df_b,by='x')
  
  right_join(df_a,df_b,by='x')
  

19.data.table

• data.table 变量长度不一样时，长度短的变量会自动重复

• dt<-dta.table(v1=c(1,2),v2=LETTERS[1:3],v3=round(rnorm(12,2,2)),v4=sample(1:20,12))#rnorm 生成均值为2标准差为2的服从标准正态分布
  
  dt[3:6,]
  dt[v2=='B']同df[v2=='B',]相同
  dt[v2 %in% c('A','B')]
  dt[,list(1,2)]
  dt[,list(sum_v4=sum(4),mean_v4=mean(v4))]
  dt[,list(v5=v4+1,v6=v3-1)]
  dt[,{print(v2);plot(1:12,v3,col='red')}] #;的作用就是分行 
  dt[,list(sum_v3=sum(v3),mean_v4=mean(v4),by=v2)]
  dt[,list(sum_v3=sum(v3),mean_v4=mean(v4),by=.(v1,v2)]
  dt[,list(sum_v3=sum(v3),mean_v4=mean(v4),by=list(v1,v2)]         
  dt[1:8,list(sum_v3=sum(v3),mean_v4=mean(v4),by=v2)]
  #N频数汇总
  dt[,.N,by=list(v1,v2)]
  dt[,v5 : v4+1]
  dt[,c('v5','v6'):= list(v3+1,v4-1]
  

• Set key()设置关键变量

• attach(iris)#如果不知道Species在attach里面，就可以先执行attach
  Species
  detach(iris)
  
  setkey(df,v2)#setkey设置让r知道现在要对df的v2进行搜索了
  dt[c('A','C')]
  
  dt[v2 %in% c('a','c')]
  

• nomatch

  dt[c('A','D'),nomatch=0] #没有D就不显示出来
  

• by = .EACHI

• %>% 串联操作

• dt[,.(v4_sum = sum(v4)),by = v2][v4_sum>40]
  

20.缺失值的识别与处理(1)

• NA

• X<-C(1,2.3,NA,NA,4)
  mean(x,na.rm=TRUE)
  sum(x,na.rm=TRUE)
  #对确实值求个数
  sum(is.na(x))
  #去掉na
  x[!is.na(x)]
  
  

  iris_na<-iris
  for(i in 1:4){
    iris_na[sample(1:nrow(iris),5),i]==NA
  }
  sapply(iris_na[,1:4],function(x)which(is.na(x)))
  sapply(iris_na[,1:4],function(x)sum(is.na(x)))
  

• psych包

• library(psych)
  describe(iris_na)#由于前面我们设置了5个确实值，所以现在返回的是145行，把有na值的行直接去掉了
  sapply(iris_na[,1:4],function(x)(sum(is.na(x))/nrow(iris_na)))
  lm()
  

• 09:30回顾分析里有确实值

• lm(Sepal.Length~Width,data = iris_na, na.action = na.omit)
  mean_value<-sapply(iris_na[,1:4],mean,na.rm =TRUE)
  
  for(i in 1:4){
    iris_na[is.na(iris_na[,i]),i]] = mean_value[i]
  }
  summary(iris_na)#可以计算mean了，说明现在没有na了
  describe(iris_na)#看看此时na是不是150了
  

• 14:20新创立一个数据集

  >cancer <- data.frame(id= 1:1000,#replace=T,可以设置重复取值
                      sur_days=sample(100:1000,1000,replace =TRUE),
                      type= sample(c('colon','liver','lung'),1000,replace =TRUE),
                      treatment = sample(c('chemo','sugr'),1000,replace = T))
  
  > cancer
       id sur_days  type treatment
  1     1      193 colon     chemo
  2     2      273 colon      sugr
  3     3      551 liver      sugr
  4     4      830 liver      sugr
  5     5      457  lung     chemo
  6     6      207  lung      sugr
  
  ##随机生成一些确实值
  cancer[sample(1:1000,90),2]<-NA
  mean_value<- tapply(cancer$sur_days,list(cancer$type,cancer$treatment),mean,na.rm=TRUE)
  > mean_value
           chemo     sugr
  colon 532.6167 564.6667
  liver 583.8652 566.6500
  lung  549.1429 582.9648
  
  for(i in 1:3){
    for(j in 1:2){
      cancer$sur_days[is.na(cancer$sur_days)&cancer$type == rownames(mean_value)[i]& cancer$treatment == colnames(mean_value)[j]]= mean_value[i,j]
    }
  }#因为上面的mean——value是有两个维度的所以要有i和j两个变量
  

21.缺失值的识别与处理(2)

• 缺失值的识别与处理

rm(list = ls())
library(mlbench)
data('BostonHousing')
head(BostonHousing)

original_data<-BostonHousing
set.seed(2017)
BostonHousing[sample(1:nrow(BostonHousing),80),'rad']<-NA #生成缺失值
BostonHousing[sample(1:nrow(BostonHousing),80),'PTRATION']<-NA
library(mice)
md.pattern(BostonHousing) 

library(Hmisc)

im_mean<-impute(BostonHousing$ptratio,median)
head(im_mean)
BostonHousing$ptratio<-NULL

• mice包进行缺失值的插补

mice_mod<-mice(BostonHousing[,!names(BostonHousing)%in% 'medv'],method = 'rf')#rf是随机森林的缩写，不要把medv这个变量放进来，接下来做回归分析把缺失值的作为因变量，其他不含缺失值变量的作为自变量，建立一种模型来进行回归，对因变量进行估计，最后预测那些缺失值是多少。现在ptratio因为含有缺失值，就是这里面的因变量
mice_output<-complete(mice_mod)

actuals <- original_data$rad[is.na(BostonHousing$rad)]

predics<-mice_output[is.na(BostonHousing$rad)]

mean(actuals!=predicts)

• VIM包

library(VIM)
data('airquality')
md.pattern(airquality)

aggr_plot<-aggr(airquality,col=c('red','green'),numbers=TRUE,sortVars = TRUE,labels = names(airquality),cex.axis = 0.7,gap = 3) #numbers真是把缺失值和不缺失值的比例显示出来，sortVars是根据缺失值的多少进行排序

#另一个可视化的函数

marginplot(airquality[1:2])

#把因变量的值当成未知，用自变量对其预测

data(sleep)
head(sleep)
sleepIm<-regressionImp(Sleep+Gest+Span+Dream+NonD~BodyWgt+BrainWgt,data=sleep)
head(sleepIm)
#因变量放在公式的左边,就是在～左边。得到的TRUE表示之前此处是缺失值
#因变量有连续性变量和离散型变量，如果知道左侧的因变量都是分类变量面就可以用family='logical',如果不知道，就用family='auto'
sleepIm<-regressionImp(Sleep+Gest+Span+Dream+NonD~BodyWgt+BrainWgt,data=sleep,family='auto')
head(sleepIm)

22.异常值和重复值的处理

image-20191005164148850

• 重复值的处理

  > x<-c(1,2,3,4,5,1,2,3)
  > unique(x)
  [1] 1 2 3 4 5
  > duplicated(x)
  [1] FALSE FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE
  > tmp<-x[!duplicated(x)]
  > tmp
  [1] 1 2 3 4 5
  

23.字符串的处理

> x<-c('fudan','jiaoda')
> nchar(x)
[1] 5 6
> length(x)
[1] 2
> toupper('shengxinjinengshu')
[1] "SHENGXINJINENGSHU"
> tolower('SHENGXINJINENGSHU')
[1] "shengxinjinengshu"

> stringa<-LETTERS[1:5]
> STRINGB<-1:5
> paste(stringa,STRINGB,sep = '-')
[1] "A-1" "B-2" "C-3" "D-4" "E-5"
> paste(stringa,STRINGB,collapse = '-')
[1] "A 1-B 2-C 3-D 4-E 5"
 
> paste0(stringa,STRINGB)
[1] "A1" "B2" "C3" "D4" "E5"
> paste0(stringa,STRINGB,sep = '-')
[1] "A1-" "B2-" "C3-" "D4-" "E5-"
> paste0(stringa,STRINGB,collapse  = '-')
[1] "A1-B2-C3-D4-E5"

> stringC<-paste(stringa,STRINGB,sep = '/') 
> stringC
[1] "A/1" "B/2" "C/3" "D/4" "E/5"
> strsplit(stringC,split = '/')
[[1]]
[1] "A" "1"

[[2]]
[1] "B" "2"

[[3]]
[1] "C" "3"

[[4]]
[1] "D" "4"

[[5]]
[1] "E" "5"

> stringd<-c('sheng','xin','ji','neng','shu')
> sub_str<-substr(stringd,start = 2,stop = 4) 
> sub_str
[1] "hen" "in"  "i"   "eng" "hu" 
> substr(stringd,start = 2,stop = 4)<-'aaa'
> stringd
[1] "saaag" "xaa"   "ja"    "naaa"  "saa"   
> my_string <- c('above','about','abrotion','cab') 
> grep('ab\\b',my_string,value = T)
[1] "cab"
> grep('\\bab',my_string,value = T)
[1] "above"    "about"    "abrotion"
> money<-c('$1888','$2888','$3888') 
> as.numeric(money)
[1] NA NA NA
Warning message:
强制改变过程中产生了NA  
> gsub('\\$',replacement = '',money)
[1] "1888" "2888" "3888"
> sub('\\$',replacement = '',money)
[1] "1888" "2888" "3888"
> money2<-c('$1888 $2888 $3888')
> sub('\\$',replacement = '',money2)
[1] "1888 $2888 $3888"
> test_string<- c('happy','apple','application','apolitic') 
> regexpr('pp',test_string)
[1]  3  2  2 -1
attr(,"match.length")
[1]  2  2  2 -1
attr(,"index.type")
[1] "chars"
attr(,"useBytes")
[1] TRUE
> test_string[regexpr('pp',test_string)>0] #不匹配的就是-1
[1] "happy"       "apple"       "application"
> agrep()#匹配英美式
Error in agrep() : 缺少参数"pattern",也没有缺省值
> string1<-c('I need a favour','my favorite report','you made an error')
> agrep('favor',string1)
[1] 1 2

image-20191005173203407

• grep（value=T和不加 的 区别）

image-20191005173247442

• grepl
  • 没有value = T 这个参数
  • ignore.case = T，可以帮助忽略大小写

image-20191005173629633

image-20191005173834186

image-20191005173940484

• 利用正则表达式
  • 找到字符串中的年份，如S2008
  • \\b表示放在最右边表示右边界

image-20191005174430380

image-20191005174532917

24.正则表达式

• 网上

.	默认情况下, 句点匹配除新行符 (rn) 序列外的任何单个字符,例如, ab. 可以匹配 abc 和 abz 以及 ab_.
*****	星号匹配零个或多个前面的字符。例如, a* 可以匹配 ab 和 aaab. 它还可以匹配完全不包含 "a" 的任意字符串的开始处.通配符: 句点星号模式 .* 是匹配范围最广的模式之一, 因为它可以匹配零个或多个 任意 字符 (除了新行符: r 和n). 例如, abc.*123 可以匹配 abcAnything123, 也能匹配 abc123.
?	问号匹配零或一个前面的字符,可以理解为 "前面的那项是可选的". 例如, colou?r 可以匹配 color 和 colour, 因为 "u" 是可选的.
+	加号匹配一个或多个前面的字符，例如 a+ 可以匹配 ab 和 aaab. 但与 a+ 和 a? 不同的是, 模式 a+ 不会匹配开始处没有 "a" 的字符串.
{min,max}	匹配出现次数介于 min 和 max 的前面的字符, 例如, a{1,2} 可以匹配 ab 但只匹配 aaab 中的前两个 a.此外, {3} 表示准确匹配 3 次, 而 {3,} 则表示匹配 3 次或更多. 注: 且第一个必须小于等于第二个.
[...]	字符类: 方括号把一列字符或一个范围括在了一起 (或两者). 例如, [abc] 表示 "a, b 或 c 的中任何一个字符". 使用破折号来创建范围; 例如, [a-z] 表示 "在小写字母 a 和 z (包含的) 之间的任何一个字符". 列表和范围可以组合在一起; 例如 [a-zA-Z0-9_] 表示 "字母, 数字或下划线中的任何一个字符".字符类后面可以使用 *, ?, + 或 {min,max} 进行限定. 例如, [0-9]+ 匹配一个或多个任意数字; 因此它可以匹配 xyz123 但不会匹配 abcxyz.
[^...]	匹配 不 在类中的任何一个字符. 例如, [^/]* 匹配零个或多个 不是 正斜杠的任意字符, 例如 , [^0-9xyz] 匹配既不是数字也不是 x, y 或 z 的任何一个字符.
\d	匹配任意一个数字 (相当于类 [0-9]). 相反地，大写的\D表示“任意的非 数字字符”。 例如, [\d.-] 表示 "任何数字, 句点或负号".
\s	匹配任意单个空白字符 , 主要是==空格, tab 和新行符 (r 和n==). 相反地, 大写的 \S 表示 "任何 非空白字符".
\w	匹配任何==单个 "单词"== 字符, 即==字母, 数字或下划线==. 这等同于 [a-zA-Z0-9_]. 相反地, 大写的 \W 表示 "任何 非 单词字符".

• R中的练习

> ###1.原义表达式
> mystring1<- c('apple','orange')
> grep('p',string1)
[1] 2

> ###2.转移表达式
> mystring2<-c('shuda','.dfs','-dsfd')
> grep('.',mysting2) #.作为pattern的话，是一个转义表达式，代表所有字符，包括它自己
[1] 1 2 3

> mystring3<-c('9aee','fese7','10000')
> grep('[7-9]',mystring3)
[1] 1 2
> 
> grep('[0-1]',mystring3)
[1] 3
> grep('[0-6]',mystring3)
[1] 3

> mystring4<-c('apple','application','abb')
> grep('^ap',mystring4)
[1] 1 2

> mystring3<-c('9aee','fese7','10000')
>
> grep('[^0-1]',mystring3)
[1] 1 2
> grep('[^7-9]',mystring3)
[1] 1 2 3
> grep('[^2-6]',mystring3)
[1] 1 2 3
> mystring3<-c('9aee','fese7','50000')
> grep('[^0-1]',mystring3)
[1] 1 2 3

> mystring6<-c('1220','2267','2226','12333')
> grep('2{2,3}',mystring6) #重复2到3次
[1] 1 2 3
> grep('2{2,}',mystring6) #重复大于等于2次的返回
[1] 1 2 3

> mystring7<-c('food','foot','foul','fans')
> grep('fo{1,}',mystring7)#只对o起作用
[1] 1 2 3
> grep('fo+',mystring7)
[1] 1 2 3
> grep('(fo){1,}',mystring7)
[1] 1 2 3

> mystring8<-c('kobe','messi','neymar')
> grep('^k|^m',mystring8)
[1] 1 2

> mystring9<-c('active','positive','negative','love')
> grep('ive$',mystring9)
[1] 1 2 3
> grep('ive\\b',mystring9) #\\b:boundry
[1] 1 2 3

> ###保义符
> mystring10<-c('ac^bb','^df')
> grep('\\^',mystring10)
[1] 1 2

25.stringr&stringi包

> ###stringr
> library(stringr)
> library(stringi)
> str_c('a','b',sep = '-') #与paste类似
[1] "a-b"
> str_length() #nchar()
Error in stri_length(string) : 缺少参数"string",也没有缺省值

> jns <- 'sheng xin ji neng shu'
> str_sub(jns,c(1,4,8),c(2,6,11)) #与substr()类似
[1] "sh"   "ng "  "in j"
> str_sub(jns,1,1)<-'S'
> jns
[1] "Sheng xin ji neng shu"

> fruit<-c('apple','pear','banana')
> str_dup(fruit,2)
[1] "appleapple"   "pearpear"     "bananabanana"
> str_dup(fruit,2:4)
[1] "appleapple"               "pearpearpear"            
[3] "bananabananabananabanana"
> str_dup(fruit,2:5) #循环补齐
[1] "appleapple"                "pearpearpear"             
[3] "bananabananabananabanana"  "appleappleappleappleapple"
Warning message:
In stri_dup(string, times) :
  longer object length is not a multiple of shorter object length

> string<- ' Eternal love for jns '
> str_trim(string ,side = 'both')
[1] "Eternal love for jns"

> phones<- c(' 219 733 8965','329-356-765 ','banana','456 789 234','764 126 893','apple','233.456.7656 ','333 555 7777','123 234 3456 and 456 567 6789','Work:333-666-8888','$1000','Home: 543.355.6790')
> str_extract(phones,'([1-9][0-9]{2})[- .]([0-9]{3})[- .]([0-9]{4})') #{}内是重复几次
 [1] "219 733 8965" NA             NA             NA            
 [5] NA             NA             "233.456.7656" "333 555 7777"
 [9] "123 234 3456" "333-666-8888" NA             "543.355.6790"
> str_extract(phones,'([1-9][0-9]{2})[- .]([0-9]{3})[- .]([0-9]{3,})') #{}内是重复几次
 [1] "219 733 8965" "329-356-765"  NA             "456 789 234" 
 [5] "764 126 893"  NA             "233.456.7656" "333 555 7777"
 [9] "123 234 3456" "333-666-8888" NA             "543.355.6790"
> 
> fruits<-c('one apple','two pears','three bananas')
> str_replace(fruits,'[aeiou]','-')
[1] "-ne apple"     "tw- pears"     "thr-e bananas"

> ###stringi
> stri_join(1:7,letters[1:7], sep='-')
[1] "1-a" "2-b" "3-c" "4-d" "5-e" "6-f" "7-g"
> stri_join(1:7,letters[1:7], collapse = '-')
[1] "1a-2b-3c-4d-5e-6f-7g"

> stri_cmp_eq('AB','aB')
[1] FALSE
> stri_cmp_neq('AB','aB')
[1] TRUE

> stri_cmp_lt('121','221')#不是当成数值比较，而是当成字符串比较,前者小于后者
[1] TRUE

> stri_cmp_lt('a121','b221')
[1] TRUE
> stri_cmp_lt('c121','b221')
[1] FALSE
> stri_cmp_gt('e121','b221')
[1] TRUE
> stri_cmp_gt('e321','b221')
[1] TRUE

> language<-c('Python','R','PHP','Ruby','Java','JavaScript','C','Oracle','C++','C#','Spark','GO','Room','Good','Pathon','ScriptJava','R2R','C+','C*')
> stri_count(language,fixed = 'R')
 [1] 0 1 0 1 0 0 0 0 0 0 0 0 1 0 0 0 2 0 0
> stri_count(language,regex = '^J')
 [1] 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0

> test<-'The\u00a0aboue-mentioned   features are very useful.  Warm thank to you.   Tomorrow is a, new $# day##'
> stri_count_boundaries(test,type='word')
[1] 44
> stri_count_boundaries(test,type='sentence')
[1] 3
> stri_count_boundaries(test,type='character')
[1] 97

> stri_dup(c('abc','pqrst'),c(4,2))
[1] "abcabcabcabc" "pqrstpqrst"  

> stri_duplicated(c('a','b','a',NA,'a',NA))
[1] FALSE FALSE  TRUE FALSE  TRUE  TRUE

> stri_duplicated(c('a','b','a',NA,'a',NA),fromLast = T) #从后往前判断
[1]  TRUE FALSE  TRUE  TRUE FALSE FALSE

> stri_duplicated_any(c('a','b','a',NA,'a',NA))
[1] 3

> stri_detect_fixed(c('stringi R','Rexamine','123'),c('i','R','0'))
[1]  TRUE  TRUE FALSE

> stri_detect_regex(c('apple','application','append','ape'),'^ap')
[1] TRUE TRUE TRUE TRUE
> 
> stri_detect_regex(c('apple','application','append','ape'),'^app')
[1]  TRUE  TRUE  TRUE FALSE

> stri_detect_regex(c('apple','application','append','ape'),'e\\b')
[1]  TRUE FALSE FALSE  TRUE

> stri_detect_regex(c('APPLE','application','appEND','ape'),'e\\b',case_insensitive = TRUE) #这个case_insensitive（忽略大小写）为什么不能补齐呢？
[1]  TRUE FALSE FALSE  TRUE

> stri_startswith_fixed(c('a1','a2','b3','a4','c5'),'a')
[1]  TRUE  TRUE FALSE  TRUE FALSE

> stri_startswith_fixed(c('a1','a2','b3','a4','c5'),'a1')
[1]  TRUE FALSE FALSE FALSE FALSE

> stri_startswith_fixed(c('abada','aabadc','abaee'),'ba',from = 2)
[1]  TRUE FALSE  TRUE

> stri_endswith_fixed(c('abaDC','aabadc','ababa'),'ba')
[1] FALSE FALSE  TRUE

> stri_endswith_fixed(c('abaDC','aabadc','ababa'),'ba',to = 3)
[1]  TRUE FALSE  TRUE

> stri_extract_all_fixed('abaBAba','Aba',case_insensitive = TRUE,overlap=T)
[[1]]
[1] "aba" "aBA" "Aba"

> stri_extract_all_boundaries('stringi: THE string processing package 123.45...')
[[1]]
[1] "stringi: "   "THE "        "string "     "processing " "package "   
[6] "123.45..."  


> stri_extract_all_words('stringi: THE string processing package 123.45...')
[[1]]
[1] "stringi"    "THE"        "string"     "processing" "package"   
[6] "123.45"    


> stri_isempty(c(',','','123'))
[1] FALSE  TRUE FALSE

> stri_locate_all('I love biotree, I love jinengshu',fixed = 'lo')
[[1]]
     start end
[1,]     3   4
[2,]    19  20

• {2,4}匹配2到4次。\\b边界，放在最后就是右边界

image-20191006015240570