R语言的基础知识

R语言基本操作

设定工作目录

1,设定工作目录
getwd()   #查看当前工作目录
setwd("C:/Users/86133/Desktop/RData")        #设置当前工作目录    
dir()     #查看当前目录下的文件

变量的赋值

> x <- 4
> x
[1] 4

查看变量情况

> ls()   #查看当前的变量信息
[1] "x"
> ls.str()  #查看当前变量以及变量的具体内容
x :  num 4
> str(x)  #查看指定变量值
 num 4

删除变量

> rm(x)   #删除变量
> rm(y,z)   #删除多个变量
> rm(list = ls())   #删除所有变量

查看之前的操作记录

> history()  #查看所有记录

保存文件

> save.image()   #保存当前的操作文档
> q()    #退出编辑

R包的安装

联网在线安装

> install.packages()   #导入所有的包用鼠标进行选择性的R包导入
>  install.packages("vcd")    #直接指定R包进行导入
> .libPaths()    #显示所有的R包库所在的位置
>  library()    #显示所有的已经安装了的R包
>  install.packages(c("ARE","ca"))   #一次性安装多个包
>  update.packages()      #更新安装的R包

R包的使用

> help(package = "vcd")   #查看指定R包的帮助文档
> library(help = "vcd")    #显示包的基本信息
> ls("package:vcd")  #列出包中包含的函数
> data(package = "vcd")  #显示包中所有的数据集
> detach("package:vcd")   #移除加载了的包
>  require(vcd)   #加载要使用的R包
>  remove.packages("vcd")    #删除已安装了的包（从硬盘上彻底删除无法进行使用）

获取帮助

> help.start()   #R语言总的帮助文档
> help("sum")    #查看函数用法    =   > ?sum
> args(sum)   #查函数参数，不想看文档的话
> example("mean")      #查询函数示例代码进行学习
> demo (graphics)   #可以列出很多用R绘制出来的图
> help(package=vcd)  #查看R安装的某个包的帮助文档
> ??gplot  #查询函数帮助文档，不加载包也可以
>  ??heatmap  #本地的模糊搜索，模糊匹配

内置数据集

> help(package="datasets")  #内置数据集存在这个包中
> data()    #访问数据集
>  rivers   #直接输出数据集的名字就能使用数据集（数据集的名字都是内置的）
>  help("mtcars")   #查看数据集的具体信息
> names(euro)  #输出向量的属性信息

> state <- data.frame(state.name,state.abb,state.area,state.division,state.region)  #使用data.frame函数将数据构成数据框（因子）

> heatmap(volcano)    #画热力图

#有些R包也有很多数据集
> data(package = "MASS")  #查看这个R包有哪些数据集可用
>  data(package = .packages(all.available = TRUE))   #显示所有R包的可用数据集

#不想加载R包但是想包的使用其中数据集

> data(Chile,package="car")   

数据结构

R中数据类型

1，数值型，数值可以用于直接计算，加减乘除
2，字符串型，可以进行连接，转换，提取
3，逻辑型，真或者假
4，日期型

向量

向量：一维数组（存储数值型，字符型，逻辑型）；是构成其他数据结构的基础，类似于集合，由一个或者多个元素构成
用函数 c 来创建向量（collect）
向量 数据都为同一类型，不能混合类型

#向量数据集
euro #欧元汇率，长度为11，每个元素都有命名
landmasses #48个陆地的面积，每个都有命名
precip #长度为70的命名向量
rivers #北美141条河流长度
state.abb #美国50个州的双字母缩写
state.area #美国50个州的面积
state.name #美国50个州的全称

#定义向量
> x<- c(1,2,3,4,5)
> y <- c("one","two","three")
> z <- c(TRUE,T,F)

#等差序列
> seq(from=1,to=100,by=2)    #设置输出范围以及控制步长
> seq(from=1,to=100,length.out = 10)  #控制输出的等差数列的长度（步长自动调节变大）

#重复元素
> ?rep
> rep(2,5)  #将2重复5次输出--5个2
> rep(x,5)  #将x重复5次
> rep(x,each=5)  #each 将每个元素分类输出
> rep(x,each=5,times=2)   #每个元素重复次数为  each*times

#向量中只有一个元素，可以不加c函数，直接赋值
> a = 2    #一个值，又叫标量
> b = 3
> c = "Hello,Word"
> d = TRUE
> a;b;c;d

#向量化编程，计算非常方便
> x <- c(1,2,3,4,5)   #两个向量（两个集合）
> y <- c(6,7,8,9,10)
> x*2 + y   #避免使用循环，向量化编程
> x[x>3]   #x中取出大于3的值

> rep(x,c(2,4,6,1,3))   #分别控制x向量中每个元素重复的个数
 [1] 1 1 2 2 2 2 3 3 3 3 3 3 4 5 5 5

向量索引

1,正（负）整数索引
2，逻辑向量索引
3，名称索引

> x <- c(1:100)
> length(x)   #统计向量个数
> x[1]   #向量的下表从1开始
> x[-19]  #负数，输出除了19这个数的其他所有元素

> x[c(4:18)]   # 索引使用向量，一次访问多个元素；输出对应索引位置范围的元素
> x[c(1,23,45,67,89)]
> x[c(-2,-3,4)]                #不能有正有负，逻辑错误

##用逻辑值进行索引-- #索引中输逻辑值
> y <- c(1:10)
> y[c(T,F,T,T,F,T)]   #只把逻辑为真的数输出来，循环次序判断
> y[c(T)]  #全输出
> y[c(F)]   #无输出
> y[c(T,F)]  #输出全为奇数
> y[c(T,F,T,T)]   #进行这种判断的循环判断
> y[c(T,F,T,T,T,F,T,T,T,T)]  
> y[c(T,F,T,T,T,F,T,T,T,T,F,T,T)]  #有判断，没元素，产生缺失值。超出了元素个数为NA
 [1]  1  3  4  5  7  8  9 10 NA NA

> y[y>5]  #给出条件判断表达式
> y[y>5&y<9]  #列表里面写逻辑表达式

##字符串向量
> "one" %in% z    #元素是否在向量中
> z["one" %in% z]        #逻辑条件添加到索引中.索引为T,全输出
[1] "one"   "two"   "three" "four"  "five" 

> z[z %in% c("one","two")]  #判断是否在数组中，输出为T的元素
[1] "one" "two"
> z %in% c("one","two")   #只输出TRUE的元素
> k <- z %in% c("one","two")
> z[k]
[1] "one" "two"


##使用names为向量元素添加名称
> names(y)
NULL
> names(y) <- c("one","two","three","four","fiv","six","seven","eight","nine","ten")
> y
  one   two three  four   fiv   six seven eight  nine   ten 
    1     2     3     4     5     6     7     8     9    10 
> y["one"]     #通过每个元素的names访问元素值
one

## 修改向量（添加数据，删除数据，修改数据）
======================================================================================
1，增加向量
> x[101] <- 101   #增加一个数据
> x 

> v <- 1:3

> v[c(4,5,6)] <- c(4,5,6)   #根据索引增加多个元素
> v
[1] 1 2 3 4 5 6

> v[20] <- 4   #下标扩大，中间有很多空值
> v
 [1]  1  2  3  4  5  6 NA NA NA NA NA NA NA NA NA NA NA NA NA  4

> append(x=v,values = 99,after = 5)   #指定位置添加向量（从第5个元素后面添加）
 [1]  1  2  3  4  5 99  6 NA NA NA NA NA NA NA NA NA NA NA NA NA  4
> append(x=v,values = 99,after = 0)    #插入头部
 [1] 99  1  2  3  4  5  6 NA NA NA NA NA NA NA NA NA NA NA NA NA  4
-------------------------------------------------------------------------------------------------------------------------------------------------------
# 删除向量
> rm(v)   			#rm,删除整个向量
> y <- y[-c(1:3)]    #删除向量中的某个元素-c
> y["four"] <- 100  #修改向量中某个元素的值

向量运算

## 向量加法
> x <- 1:10
> x+1    #每一个元素的加减
======================================================================================
##向量与向量的运算   （对应元乘除）
> x
> y <- seq(1,100,length.out=10)  #等差数列，seq
> x+y     
> x*y
> x**y
> y%%x   #取余运算
> y%/%x   #整除运算

 > z<-c(1,2)  #x向量与z向量长度不相等
> x
 [1]  2  3  4  5  6  7  8  9 10 11
> x+z     #循环进行运算，依次+1，+2，+1，+2，+1，+2(长的向量个数必须是短的向量个数的整数倍关系才满足循环运算)
 [1]  3  5  5  7  7  9  9 11 11 13
> z
[1] 1 2
======================================================================================
##向量的逻辑运算<,>（每种运算都可以返回逻辑值）
> x>5
 [1] FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE  TRUE  TRUE  TRUE
> x
 [1]  2  3  4  5  6  7  8  9 10 11
> y
 [1]   1  12  23  34  45  56  67  78  89 100
 
> x>y    #一一比对，返回T，F
 [1]  TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
 
> c(1,2,3) %in% c(1,2,3,4,5,6)    #存在就判断输出，否则跳过
[1] TRUE TRUE TRUE

> x==y     # ==判断
 [1] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE

======================================================================================
#向量运算的函数（数学函数，统计函数）
--------------------------------------------------------------------------------------------------------------------------------------------------
 #数学函数
 > x <- -5:5

> x
 [1] -5 -4 -3 -2 -1  0  1  2  3  4  5
> abs(x)  #返回向量的绝对值
> sqrt(5)   #计算平方根
> log(16,base=2)
> log(16)  #不加base参数，默认是自然对数
> log10(10)  #以10为底的对数，log10
> exp(x)   #计算向量中每个元素的指数
> ceiling(c(-2.3,3.1415))  #返回返回不小于x的最小整数
[1] -2  4
> floor(c(-2.3,3.468))   #floor返回不大于x的整数
[1] -3  3
> trunc(c(-2.3,3.468))   #trunc返回整数部分
[1] -2  3
> round(c(-2.3,3.1425),digits = 2)   #round进行向量的四舍五入；向量+保存位数
[1] -2.30  3.14
> signif(c(-2.3,3.1425),digits = 2)   #保留有效数字
[1] -2.3  3.1
> sin(x)  #三角函数...
> cos(x)
-----------------------------------------------------------------------------------------------------------------------------------------
#统计函数
> vec <- 1:100
> sum(vec)
> max(vec)
> min(vec)
> range(vec)   #输出范围
> mean(vec)  #返回平均数
> var(vec)  #返回方差
> round(var(vec),digits = 2)  #设置保留两位小数
> round(sd(vec),digits = 2)  #sd设置向量的标准差sd
> prod(vec)  #向量的连乘的积
> median(vec)  #计算中位数

> quantile(vec)   #计算分位数
    0%    25%    50%    75%   100% 
  1.00  25.75  50.50  75.25 100.00 
> quantile(vec,c(0.4,0.5,0.8))   #根据数组指定分位数
 40%  50%  80% 
40.6 50.5 80.2 

> t <- c(1,4,2,5,7,9,6)
> which.max(t)  #返回值的索引值
> which.min(t)  #返回值的索引值
> which(t==7)  #返回值的索引值
> which(t>5)  #返回值的索引值
[1] 5 6 7
> t[which(t>5)]  #根据返回的索引进行输出对应的值
[1] 7 9 6

矩阵与数组

矩阵:
是二维的，需要有行和列；
R中，矩阵是有维数的向量，矩阵的每个元素必须都拥有相同的模式，和向量一致
矩阵就是给向量加一个维度

#矩阵的数据集
矩阵、数组
euro.cross #11种货币的汇率矩阵
freeny.x #每个季度影响收入四个因素的记录
state.x77 #美国50个州的八个指标
USPersonalExpenditure #5个年份在5个消费方向的数据
VADeaths #1940年弗吉尼亚州死亡率（每千人）
volcano #某火山区的地理信息（10米×10米的网格）
WorldPhones #8个区域在7个年份的电话总数
iris3 #3种鸢尾花形态数据
Titanic #泰坦尼克乘员统计
UCBAdmissions #伯克利分校1973年院系、录取和性别的频数
crimtab #3000个男性罪犯左手中指长度和身高关系
HairEyeColor #592人头发颜色、眼睛颜色和性别的频数
occupationalStatus #英国男性父子职业联系

矩阵

#矩阵的基本用法
> heatmap(state.x77)    #对矩阵数据画热力图
> x <- 1:20
> m <- matrix(x,nrow = 4,ncol = 5)   #根据x向量，设置4行5列的矩阵
> m <- matrix(1:20,4,5)  #根据向量设置4行5列的矩阵
> m <- matrix(x,nrow = 4)  #参数只给一个，会自动分配
> m <- matrix(x,nrow = 4,byrow = T)  #设置参数，规定按行还是按列进行分配.默认按列
> m <- matrix(x,nrow = 4,byrow = F)  #设置参数，规定按行还是按列进行分配.默认按列

#通过列表，设置矩阵的属性名
> rnames <- c("R1","R2","R3","R4")
> cnames <- c("C1","C2","C3","C4","C5")
> dimnames(m) <- list(rnames,cnames)    #dim给m向量设置维数，通过list转为矩阵
> m
   C1 C2 C3 C4 C5
R1  1  5  9 13 17
R2  2  6 10 14 18
R3  3  7 11 15 19
R4  4  8 12 16 20

> ?dim()
> dim(x)  #显示向量的维数
NULL
> dim(x) <- c(4,5)  #为向量x添加维数4行5列
> x
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    5    9   13   17
[2,]    2    6   10   14   18
[3,]    3    7   11   15   19
[4,]    4    8   12   16   20

数组

===================================================================================
#数组
向量就像数组，多维数组就是矩阵

#数组用法
> x <- 1:20
>  dim(x) <- c(2,2,5)   #长宽高为2，2，5的长方体

#用array创建数组
> > ?array
> dim1 <- c("A1","A2")    #创建标签向量
> dim2 <- c("B1","B2","B3")
> dim3 <- c("C1","C2","C3","C4")
> z <- array(1:24,c(2,3,4),dimnames = list(dim1,dim2,dim3))   #array创建数组，向量+平分向量个数的维数+向量标签名

> Titanic   #R数据集中的内置数组

矩阵的索引

================================================================================
#矩阵的索引（访问，删除，修改数据）
#矩阵下标进行访问
> m <- matrix(1:20,4,5,byrow = T)
> m[1,2]  #访问第一行，第二列的元素2
> m[1,c(2,3,4)]  #一次访问多个元素(第一行，2，3，4列的元素)
> m[c(2:4),c(2,3)]  #输出矩阵的子集
     [,1] [,2]
[1,]    7    8
[2,]   12   13
[3,]   17   18

> m[2,]  #访问第二列
> m[,2]  #访问第二行
> m[2]  #访问行数据，根据索引访问
> m[-1,2]  #去除第一行，取第二列
> dimnames(m) = list(rnames,cnames)  #给m增加维度，并增加行列名
> m["R1","C2"]  #根据标签名进行访问元素，唯一值
-------------------------------------------------------------------------------------------------------

矩阵的运算

> m+1   #每个元素加1，矩阵与矩阵得运需要行和列一致

#矩阵的数学函数

> n <- matrix(1:20,5,4)
> colSums(m)   #计算矩阵每一列的和
> rowSums(m)  #计算矩阵每一行的和 
> colMeans(m)  #计算列的平均值
> rowMeans(m)  #计算行的平均值

> n <- matrix(1:9,3,3)  #创建一个3行3列的矩阵，值为1-9
> t <- matrix(2:10,3,3)  #创建一个3行3列的矩阵
> n*t  #矩阵对应位置元素相乘--内积
> n %*% t  #矩阵的外积
> diag(n)  #返回矩阵对角线位置的值
> t(m)  #t对矩阵进行转置，将行和列进行互换

列表

列表：
用来存储很多内容的集合
是一些对象的有序集合。
列表中可以存储若干向量，矩阵，数据框，甚至其它列表的组合 混合的数据结构

列表数据集：
state.center #美国50个州中心的经度和纬度

##列表的创建
> a <- 1:20 #向量
> b <- matrix(1:20,4)  #矩阵
> c <- mtcars
> d <- "This is a test list"  #标量
> a;b;c;d

>  mlist <- list(a,b,c,d)   #创建一个列表
>mlist <- list(first=a,second=b,third=c,forth=d)  #为每个对象添加名称


##列表的访问
> mlist[1]  #访问列表的第一个元素（访问第一列）$first
> mlist[c(1,4)]  #一次访问多个元素，用向量

> state.center[c("x","y")]   #使用名称进行访问
> mlist$third    #用$符进行高效访问列表

>mlist[1]  #输出的是列表的一个子集，仍然是一个列表【】
> mlist[[1]]   #输出的是元素本身的数据类型integer【】【】 两个[],输出一个元素，可以采用矩阵方式进行元素的访问

##列表的赋值
> mlist[[5]]<-iris   #列表对列表赋值不成立，需要进行两个【】，成为向量去赋值

##删除列表中的元素

> mlist[-5]        #采用负索引，然后再赋值给原来的列表
>  mlist[5] <- NULL        #将原来的要删除的列表元素赋值为NULL

数据框

数据框：
表格式的数据结构
数据集是矩形数组，行表示观测，列表示变量
本质是列表，列表中的元素是向量，成为列，每列相同长度
数据框是矩形结构，列必须命名
每列同一类型，每一行可以不同

#数据框的数据集
数据框
airquality #纽约1973年5-9月每日空气质量
anscombe #四组x-y数据，虽有相似的统计量，但实际数据差别较大
attenu #多个观测站对加利福尼亚23次地震的观测数据
attitude #30个部门在七个方面的调查结果，调查结果是同一部门35个职员赞成的百分比
beaver1 #一只海狸每10分钟的体温数据，共114条数据
beaver2 #另一只海狸每10分钟的体温数据，共100条数据
BOD #随水质的提高，生化反应对氧的需求（mg/l）随时间（天）的变化
cars #1920年代汽车速度对刹车距离的影响
chickwts #不同饮食种类对小鸡生长速度的影响
esoph #法国的一个食管癌病例对照研究
faithful #一个间歇泉的爆发时间和持续时间
Formaldehyde #两种方法测定甲醛浓度时分光光度计的读数
Freeny #每季度收入和其他四因素的记录
dating from #配对的病例对照数据，用于条件logistic回归
InsectSprays #使用不同杀虫剂时昆虫数目
iris #3种鸢尾花形态数据
LifeCycleSavings #50个国家的存款率
longley #强共线性的宏观经济数据
morley #光速测量试验数据
mtcars #32辆汽车在11个指标上的数据
OrchardSprays #使用拉丁方设计研究不同喷雾剂对蜜蜂的影响
PlantGrowth #三种处理方式对植物产量的影响
pressure #温度和气压
Puromycin #两种细胞中辅因子浓度对酶促反应的影响
quakes #1000次地震观测数据（震级>4）
randu #在VMS1.5中使用FORTRAN中的RANDU三个一组生成随机数字，共400组。
#该随机数字有问题。在VMS2.0以上版本已修复。
rock #48块石头的形态数据
sleep #两药物的催眠效果
stackloss #化工厂将氨转为硝酸的数据
swiss #瑞士生育率和社会经济指标
ToothGrowth #VC剂量和摄入方式对豚鼠牙齿的影响
trees #树木形态指标
USArrests #美国50个州的四个犯罪率指标
USJudgeRatings #43名律师的12个评价指标
warpbreaks #织布机异常数据
women #15名女性的身高和体重

##数据框的创建
> ?data.frame  #可以使用data.frame创建数据框
> state <- data.frame(state.name,state.abb,state.region,state.x77)  #数据合并成为数据框. 将数据存储到R进行分析，每列内容存储成向量，再利用dataframe进行合并

##数据框的访问
======================================================================================
#通过索引来访问数据

> state[1]   #输出数据框的第一列
> state[c(2,4)]   #里面可以是数组，输出第二列和第四列
> state[-c(2,4)]      #添加负索引就是去掉这部分内容
> state[,"state.abb"]     #利用行和列的名字直接取出对应的行和列
>  state["Alabama",]    
> state$state.name      #采用$符的访问方式，快速取出任意一列
---------------------------------------------------------------------------------------------------------------------------------------------
>  plot(women$height,women$weight)    #plot绘制身高和体重散点图
>  lm (weight  ~height,data = women)    #lm进行线性回归，直接给出列名
------------------------------------------------------------------------------------------------------------------------------------------------
> ?attach  #加载数据框到R搜索目录中
> attach(mtcars)     #一次使用数据框的多列数据
> mpg    #直接敲数据框列的名字
--------------------------------------------------------------------------------------------------------------------------------------------------
> rownames(mtcars)   #查看行列的名称
>  colnames(mtcars)
----------------------------------------------------------------------------------------------------------------------------------------------
> detach(mtcars)            # 取消加载数据框到R的搜索目录中
> with(mtcars,{hp})    #with也可实现查看数据框的指定列

因子

变量分类：
1，名义型变量（独立，字符串数据）
2，有序型变量（不同值之间有顺序关系）
3，连续型变量（数值类多）

因子:
名义型变量+有序型变量，factor
分类变量的可能值称为一个水平，level (good,better,best)
因子本身也是一个向量，它是一个集合，里面的元素有分类效果(分类)
整个集合称为因子的数据，不是某个变量，水平

因子的应用:
计算频数
独立性检验
相关性检验
方差分析
主成分分析
因子分析

##因子的基本用法
> table(mtcars$cyl)    #使用table进行频数统计  (这一列可以作为因子类型)
 4  6  8    #分为4，6，8三种类型   level
11  7 14    #对应的数量
------------------------------------------------------------------------------------------------------------------------------------------------
##将向量转换为因子（创建因子  factor）
> f <- factor(c("red","red","green","blue","green","blue","blue"))
> f
[1] red   red   green blue  green blue  blue 
Levels: blue green red
-----------------------------------------------------------------------------------------------------------------------------------------------------------------
#有序型变量作为level
> week  <- factor(c("Mon","Fri","Thu","Wed","Mon","Fri","Sun"))
> week
[1] Mon Fri Thu Wed Mon Fri Sun
Levels: Fri Mon Sun Thu Wed   #输出不规范

> week  <- factor(c("Mon","Fri","Thu","Wed","Mon","Fri","Sun"),ordered = T,levels = c("Mon","Tue","Wed","Thu","Fri","Sat","Sun"))   设置level,排序
> week
[1] Mon Fri Thu Wed Mon Fri Sun
Levels: Mon < Tue < Wed < Thu < Fri < Sat < Sun
-----------------------------------------------------------------------------------------------------------------------------------------------------
#绘图
> plot(mtcars$cyl)   #向量输出散点图
> plot(factor(mtcars$cyl))    #因子输出条形图
------------------------------------------------------------------------------------------------------------------------------------------------------
#连续型变量分为n个因子
> num <- 1:100
> cut(num,c(seq(0,100,10)))
10 Levels: (0,10] (10,20] (20,30] (30,40] (40,50] (50,60] (60,70] (70,80] ... (90,100]

缺失数据的分类

缺失值NA：
存储缺失信息
NA表示没有，不知道是多少，不一定是0

##NA的处理
> a <- c(NA,1:49)
> a
 [1] NA  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
[29] 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
> sum(a)
> [1] NA
> sum(a,na.rm = TRUE)   #na,rm 跳过缺失值.    na.rm
[1] 1225
-------------------------------------------------------------------------------------------------------------------------------------------------------
#测试数据里面是否有NA
> is.na(a)   #测试NA  -TRUE

#去掉缺失值，生成新的没有NA的数据集 na.omit
> ?na.omit
> c <- c(NA,1:20,NA,NA)
> c
 [1] NA  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 NA NA
> d <- na.omit(c)  #去掉缺失值
> d
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20

> is.na(d)
 [1] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
[15] FALSE FALSE FALSE FALSE FALSE FALSE
-------------------------------------------------------------------------------------------------------------------------------------
#不同缺失值
1，NA--有存在的值，不知道是多少
2，NaN--不存在
3，inf 存在，无穷大，表示不可能的值

字符串处理函数

统计字符串长度 nchar()

nchar("hello wd")   #统计字符串长度
month.name   #12个变量的名字（字符串）
nchar(month.name)   #返回每个月份的字符数（返回每个元素的字符串的个数）
length(month.name)   #返回元素的个数

> nchar(c(12,2,345))   #统计数值型，返回每个数值型的长度
[1] 2 1 3

将多个字符串合并为一个字符 paste()

> paste(c("everybody","lovers","states"))   
>  paste("everybody","lovers","states")     #默认使用空格进行字符分割
>   paste("everybody","lovers","states",sep = "-")   #设置分割符
> names <- c("z","x","r")
> paste(names,"love whj")  #分别处理，进行向量的组合

字符的提取 substr()

> substr(x = month.name,start = 1,stop = 3)   #字符串的截取
> temp <- substr(x = month.name,start = 1,stop = 3)
> toupper(temp)   #将所有字符转换为大写
> tolower(temp)  #将所有字符转换为小写

查找字符串 grep() + match()

> x <- c("b","A+","AC")
> grep("A+",x)   #正则匹配原则，23的首字母都有A,返回2，3
> grep("A+",x,fixed = T)   #精准匹配，返回2

> match("A+",x)   #相当于包含于的操作%in%

字符串的分割 strsplit()

> path <- "/user/local/bin/R"
> strsplit(path,"/")   #返回的是列表
> class(strsplit(path,"/")) 
[1] "list"
> strsplit(c(path,path),"/")

生成字符串成对组合的技巧 outer()

> face <- 1:13
> suit <- c("spades","clubs","hearts","diamonds")
>  outer(suit,face,FUN = paste)

日期和时间

1，对时间序列的描述
2，利用前面的结果进行预测

将字符串格式化为data类

> a <- "2017-01-01"
> as.Date(a,format = "%Y-%m-%d")   %将字符串转换为时间序列

创建连续的时间点 seq() as.Date()

 seq(as.Date("2017-01-01"),as.Date("2017-07-05"),by=5)

将R生成时间序列 ts() 将向量转换为时间序列函数

 sales <- round(runif(48,min = 50,max = 100))    #随机生成48个数，最小值~最大值  runif
 ts(sales,start = c(2010,5),end = c(2014,4),frequency = 1)   #时间序列格式（以年为单位的频率变化）

常见错误

1，向量加c (表示集合)；标量可用=
2,矩阵matrix;数据框data.frame;
3,字符串有引号，函数有括号；安装R包时候加引号
4，路径问题 /
5，记得载入R包

获取数据

R获取数据的3种途径

1. 利用键盘来输入数据

> a <- c(1,2,3,4)
> b <- c("10/2/3","4/6/8","3/23/1","23/63/2")
> c <- c(2,4,6,7)
> data <-  data.frame(a,b,c)    #创建一个数据框

> datad2 <- data.frame(a=numeric(),b=character(),c=numeric())  #创建数据框的时候指定数据类型
> datad2 <- edit(datad2)   #对数据进行值的可视化编辑 edit(),有返回值需要变量
>  fix(datad2)   #作用同上

3. 通过读取存储在外部文件上的数据

读取纯文本文件

1，读取纯文本文件
> x <- read.table("input.txt")
> head(x)   #查看头，默认6行
> tail(x)   #查看尾，默认6行
> head(x,n=10)   #查看指定的行数n

> y <- read.table("input.csv",sep = ",")
> y <- read.table("input.csv",sep = ",",header = TRUE)   #将表格的第一行设置为表格的列变量header=TRUE
> read.table("input 1.txt",header = TRUE,skip = 5)  #有的文件有注释信息，需要跳过内容
> read.table("input 1.txt",header = TRUE,skip = 5,nrows = 200)   #读取行数nrow

读取网络文件

#1，读取html中的表格
> install.packages("XML")
>readHTMLTable("网址",which=3)  #从网址中读取第几个表格

读取压缩软件

> read.table(gzfile("input.txt.gz"))

读取不标准的数据

> readLines("input.csv",n = 5)   #每次读取一行
> scan("文件"，what=list( character(3),numeric(0),muneric(0)   ))   #读取单元值

通过访问数据库系统来获取数据

> install.packages("RODBC")   #加载能够访问数据库的odbc包
>library(RODBC)
> help(package="RODBC")

写入文件

write直接将结果写入文件里面

> x <- rivers
> cat(x)   #将结果显示在屏幕上

> #write直接将结果写入文件里面
> #对象是数据框，write.table
> 对象是csv文件write.csv

> x <- read.table("input.txt",header = TRUE)   #读文件
> write.table(x,file = "C:/Users/86133/Desktop/RData/test.txt")    #写文件
> write.table(x,file = "C:/Users/86133/Desktop/RData/test.csv",sep = ",")   #写文件，会自动编号
> write.table(x,file = "C:/Users/86133/Desktop/RData/test2.csv",sep = ",",row.names = FALSE)  #√ ，不会自动编号，数据格式内容正常

##追加数据到文件中
write.table(iris,file = "C:/Users/86133/Desktop/RData/test2.txt",append = T)   

写成压缩文件

 write.table(mtcars,gzfile("test.csv.gz"))

R中读写Excel文件

1，将excel文件另存为csv/txt文件,使用read函数读取

read.csv("x")

2，使用能够直接读取excel文件的包（RODBC包，XLConnect包）

XLConnect包，支持所有平台，依赖于java,首先需要配置java的运行环境

 install.packages("XLConnect")
 > library(XLConnect)
 
 ## 分两步去读取文件
 1.读取整个工作簿，也就是整个excel文件
 > ex <- loadWorkbook("data.xlsx")
 2，读取具体的工作表的内容
 > edata <- readWorksheet(ex,1)  #1代表工作溥中第一个工作表的内容；读取后直接保存为数据框
 
 #控制读取工作表的范围
 edata <-  readWorksheet(ex,1,startRow = 0,startCol = 0,endRow = 50,endCol = 3)  #第一个单元格开始，读取50行3列数据

将数据写入excel(四步法)

1，创建工作簿
2，创建工作表
3，将数据保存在工作表中
4，将工作簿存为文件

> createSheet(wb,"Sheet 1")
> writeWorksheet(wb,data = mtcars,sheet = "Sheet 1")
> saveWorkbook(wb)
> writeWorksheetToFile("file1.xlsx",data = iris,sheet = "Sheet 1")

读写R格式的文件

存成R文件后只能在R中打开；R会对存储的内部文件格式的数据进行自动压缩处理，也会存储R元数据信息。数据包含因子，日期，时间或者类的属性信息

#存储单个文件RDS格式
> saveRDS(iris,file = "iris.RDS")
> readRDS("iris.RDS")

#存储多个文件成为Rdata文件
> save(iris,iris3,file = "C:/Users/86133/Desktop/RData/iris.Rdata")
> load("C:/Users/86133/Desktop/RData/iris.Rdata")

#保存当前工作蒲的所有对象
> save.image()

数据转换

数据类型转换(一)

> library(xlsx)
> cars32 <- read.xlsx("mtcars.xlsx",sheetIndex=1.header =T)  #读取excel的文件

> is.data.frame(cars32)   #判断是否是数据框形式
>  is.data.frame(as.data.frame(state.x77))  #转换数据为数据框格式  as.data.frame()

>  as.matrix(~)  #转换为矩阵形式
>  as.vector()  #转换为向量
>  as.factor()  #转换为因子
> as.list(x)   #转换为列表

> x <- state.abb
> dim(x) <- c(5,10)  #设置向量维度，

> x <- state.abb
> as.factor(x)   #变成因子类型
> > as.list(x)  #变成列表

> state <- data.frame(x,state.region,state.x77)  #设置数据框
> state$Income   #使用$取出数据框中的任何一列
> state["Nevade",]   #取出行使用名称索引，后面加逗号，前取行后取列   
> unname(y)  #unname()  不需要列名
>  unlist(y)  #转换为向量

数据取子集/抽样/增加数据

对数据取子集-索引

> setwd(dir = "C:/Users/86133/Desktop/RData")
> who <- read.csv("WHO.csv",header = T)   #读取数据框文件
>  who1 <- who[c(1:50),c(1:10)]   #数据框的子集。前50行10列

#利用索引可以提取数据框中的任何内容
> who2 <- who[c(1,3,5,7),c(2,14,18)]   #提取1，3，5，7行，2，14，18列
> who4 <- who[which(who$CountryID >50 & who$CountryID <=100 )]   #使用逻辑进行提取数据

对数据取子集-函数subset

> who5 <- subset(who,who$CountryID >50 & who$CountryID <=100 )

随机抽样sample

> x <- 1:100
> sample(x,30)   #无放回抽样
 > sample(x,60,replace = T)   #有放回抽样，值有重复
> who[sample(who$CountryID,30,replace = F),]      #对数据框进行抽样，取子集

删除固定行的数据

mtcars[,-1,-5]                #`删除列`
mtcars$mpg <- NULL  #将这一列赋值给NULL.,清空这一列数据

为数据框增加行/列 cbind/rbind

> data.frame(USArrests,state.division)   #直接data.frame直接生成新的数据框
> cbind(USArrests,state.division)   #直接cbind/rbind函数，在原数据上进行合并操作.必须有相同的行列名
> unique（data）   #去除重复数据

数据框的翻转/修改值/排序

数据框的翻转t()/rev()

> sractm <- t(mtcars)   #t()函数实现行和列的翻转

#单独一行翻转rev()
> rev(letters)
women[rev(rownames(women)),]

修改数据框中的值transform()

 transform(women,height=height*5)  #每个height值都*5，原数据上进行修改
 > transform(women,cm=height*5)   #使用新的一列进行计算

数据框的排序sort/order
-sort 对向量进行排序，返回排序后的结果向量–只能对向量进行排序> sort(state.name)，取相反结果rev()
-order 返回排序后的索引值> order(rivers)，可以根据索引返回数据的值> mtcars[order(mtcars$mpg),]，取相反的顺序，> mtcars[order(-mtcars$mpg),],对多个条件进行排序mtcars[order(mtcars$mpg,mtcars$disp),]

数据转换(四)

对数据框进行数学计算

> worldphones <-  as.data.frame(WorldPhones)   #将矩阵转换为数据框
> rs <- rowSums(worldphones)   #计算每一行的数据求和
>  cm <- colMeans(worldphones)   #计算每列的平均数
> total <- cbind(worldphones,Total = rs)  #cbind将每行的和添加到最后一列
>  rbind(total,Mean=cm)  #添加列

apply函数–适用数据框和矩阵

apply(WorldPhones, MARGIN = 1, FUN = sum)   #对每一行求和
apply(WorldPhones, MARGIN = 2, FUN = mean)   #对每一列求平均值

lapply函数 --适用列表，返回值是列表lapply(state.center, FUN = length)
sapply 函数 --返回向量值> sapply(state.center, FUN = length)
tapply 函数 --根据因子进行分区计算处理> sapply(state.center, FUN = length)

数据的中心化与标准化（向数据中心靠拢）

数据中心化：数据的各项数据减去数据集的均值
数据标准化：数据中心化的数据再除以数据集的标准差

reshape2包对数据进行格式转换

reshape2进行宽数据转换为长数据

> install.packages("reshape2")
> library(reshape2)

> names(airquality) <- tolower(names(airquality))  #将列名改为小写
> aql <- melt(airquality)   #融合数据，每一行都是变量的组合，将宽数据变为了长数据
> aql <- melt(airquality,id.vars = c("month","day"))  #设置id,其余作为观测值

tidyr包 进行数据转换

tidyr 处理整洁数据
gather好处：让固定列不变，而其他列进行转换

> install.packages(c("tidyr","dplyr"))
> library(tidyr)
> tdata <- mtcars[1:10,1:3]   #截取10行3列数据  

> tdata <- data.frame(names=rownames(tdata),tdata)  #增加一列
> gather(tdata,key = "Key",value = "Value",cyl,disp,mpg)  #指定k,v，以及需要处理的列
> gather(tdata,key = "Key",value = "Value",cyl:disp,mpg)  #：指定哪些列放在同一列中cyl:disp放在了同一列中
> gather(tdata,key = "Key",value = "Value",cyl,-disp)   #添加-，减去不需要转换的列
> gather(tdata,key = "Key",value = "Value",2:4)  #列的名字容易出错，就写列编号

spead 与gather作用相反，转换为tidy格式数据

> gdata <- gather(tdata,key = "Key",value = "Value",2:4)   
> spread(gdata,key = "Key",value = "Value")  #把长数据返回成tidy数据

separate将列进行拆分

 df <- data.frame(x=c(NA,"a.b","a.d","b.c"))
 > separate(df,col = x,into = c("A","B"))  #默认识别分割符
 > df <- data.frame(x=c(NA,"a.b-c","a-d","b-c"))
 > > separate(df,col = x,into = c("A","B"),sep = "-")  #多个分隔符指定分隔符进行拆分

unite将列进行连接

> x <- separate(df,col = x,into = c("A","B"),sep = "-")
> unite(x,col = "AB",A,B,sep = "-")  #连接数据，设置列名与指定连接的列并设置连接符

dplyr包进行数据转换

dplyr对单表格进行操作

> library(dplyr)
> ls("package:dplyr")  #查看包里面的函数
> help(package="dplyr")

> dplyr::filter(iris,Sepal.Length >7)   #过滤操作
> dplyr::distinct(rbind(iris[1:10,],iris[1:15,]))   #取出某些行进行组合构成数据框，并实现去重
> dplyr::slice(iris,10:15)  #切片，取出数据的任意行
> dplyr::sample_n(iris,10)   #随机取样抽出10行
> dplyr::sample_frac(iris,0.1) #按比例进行随机选取
> dplyr::arrange(iris,Sepal.Length)   #按照花的长度进行排序
>  dplyr::arrange(iris,desc(Sepal.Length)）   #按照相反的方向进行排序

取子集

> ?select

统计函数

> summarise(iris,avg=mean(Sepal.Length))   #求平均
> summarise(iris,sum=sum(Sepal.Length))   #求和

链式操作符

将一个函数的输出作为另一个函数的输入 ctrl+shift+M %>%

> head(mtcars,20) %>% tail(10)  #输出第11-20行。基本表是前面函数的前20行数据的输入
> dplyr::group_by(iris,Species)   #进行分组
> iris %>% group_by(Species)   #功能同上
> iris %>% group_by(Species) %>% summarise(avg = mean(Sepal.Width))   #分组统计，计算平均值
> iris %>% group_by(Species) %>% summarise(avg = mean(Sepal.Width))  %>%  arrange(avg)  #对分组统计的结果进行排序
> dplyr::mutate(iris,new=Sepal.Length+Petal.Length)  #添加新的一列变量

dplyr对双表格操作

> a <- data.frame(x1=c("A","B","C"),x2 = c(1,2,3))
> b <- data.frame(x1=c("A","B","C"),x3=c(T,F,T))

> dplyr::left_join(a,b,by="x1")   #左连接
>dplyr::right_join(a,b,by="x1")   #右连接
> dplyr::full_join(a,b,by="x1")   #全连接
> dplyr::semi_join(a,b,by="x1")   #半连接，输出交集
> dplyr::anti_join(a,b,by="x1")  #反连接 ，输出补集

运算

 first <- slice(mtcars,1:20)   #取出数据，不包含行名
 > mtcars <- mutate(mtcars,Model=rownames(mtcars))   #设置行名列
 
 > first <- slice(mtcars,1:20)
> second <- slice(mtcars,1:380)
> intersect(first,second)   #取交集
> dplyr::union_all(first,second)  #取并集
> setdiff(first,second)   #取first的补集

R中的函数

数学统计函数

R概率分布函数

> ?Normal
> rnorm(n=100,mean=15,sd=12)   #均值15，方差为2的100个随机数
> round(rnorm(n=100,mean=15,sd=12))  #取整
> runif(50,min = 1,max = 100)   #生成50-100的50个随机数

描述性统计函数

> myvars <- mtcars[c("mpg","hp","wt","am")]  
> summary(myvars)   #对一个数据进行详细统计

频数统计函数

一维

> mtcars$cyl <- as.factor(mtcars$cyl)   #转换为因子
> split(mtcars,mtcars$cyl)   #分组

#cut  对连续数据进行切割
> cut(mtcars$mpg,c(seq(10,50,10)))   #对连续数据进行分割  10-50切成10份
>  table(mtcars$cyl)   #进行频数统计
>  prop.table(table(mtcars$cyl))    #计算频率
> prop.table(table(mtcars$cyl)) *100   #百分比的值

二维数据框的频数统计

> library(vcd)   
> table(Arthritis$Treatment,Arthritis$Improved)   #进行频数统计

独立性检验函数

变量之间是独立的，没有关系

> mytable <- table(Arthritis$Improved,Arthritis$Sex)
> chisq.test(mytable)   #卡方检验。p-value值越小越好、。证明两个变量独立

绘图函数

R语言四大作图系统

• 基础绘图系统
• lattice包
• ggplot2包
• grid包

> ls("package:graphics")   #基础绘图函数总和
>  help(package="graphics")   #查看帮助文档