R基础

R基础

零、软件安装

1 软件安装

1、官网下载R和Rstudio
2、先装R，再装RStudio
3、安装路径不能包含“空格”、“中文”、“特殊字符”，最好只有字母+数字命名

2 RStudio – 常见快捷方式

1、TAB键： 自动补全（比如对于R中储存变量，如果变量名字较长，不用完整输入，可以采取变量补全的方式）
2、键盘中的向上、向下箭头： 重复之前的命令行输入
3、清空控制台   Ctrl+L  （Mac：Command+L）
4、将光标定位到行首    Home （Mac：Command+Left）
5、将光标定位到行末    End （Mac：Command+Right）
6、中断当前命令的执行   Esc （Mac：Esc）
7、赋值符 （<-）：Alt + —（Mac：Option+-）
8、将光标定位到代码控制台： Ctrl+2（Mac： Ctrl+2 ）
9、将光标定位到文本编辑区： Ctrl+1（Mac： Ctrl+1 ）

一、R包安装和调用

1 通过Rstudio菜单安装

1.1 Tools -> installPacakges 
1.2 Pacakges -> Install

2 通过install.pacakges命令安装

2.1 安装

install.packages('readxl')
install.packages('writexl')

2.2 设置镜像

单次配置

options(repos=structure(c(CRAN="https://mirrors.tuna.tsinghua.edu.cn/CRAN/")))

将上面代码加入 R-3.6.1\etc\Rprofile.site 文件即可永久配置

3 通过BiocManager安装

3.1 手动选择镜像源

install.packages('BiocManager')  # 安装一次
options(BioC_mirror='https://mirrors.tuna.tsinghua.edu.cn/bioconductor') # 每次打开Rstudio均需要设置
BiocManager::install('DESeq2') # Update all/some/none? [a/s/n]: n

3.2 设置Rprofile.site 自动配置镜像

set a CRAN mirror
设置 R-3.6.1\etc\Rprofile.site 永久更改镜像

local({
  r = getOption('repos')
  options(repos = r, BioC_mirror='https://mirrors.tuna.tsinghua.edu.cn/bioconductor')
})

4 conda构建包

如果R环境是基于conda构建，可以采用conda来安装

conda install -c bioconda r-pheatmap
conda install -c bioconda bioconductor-ComplexHeatmap

5 加载R包

if(!require(devtools))
  install.packages("devtools")
if(!require(ggcor))
  devtools::install_github("houyunhuang/ggcor")

6 常用函数

getwd()  #查看当前工作目录
setwd("D:/MyRProject")  #设置工作目录
dir()    #查看当前目录下所有文件名称
system.time() #返回函数运行时间

#数据输入：read.delim、read.table、read.csv
#数据输出：write.table、write.csv

sum()    #求和    
plot()   #绘图    
sort()   #排序    

计算
log(x)    log10(x)    exp(x)
sin(x)    cos(x)      tan(x) 
asin(x)   acos(x)     range(x)
min(x)    max(x)      length(x)    

统计检验
mean(x)    sd(x)    var(x)   median(x)
quantile(x,p)       cor(x,y) 
t.test()   lm(y ~ x)

7 其他

#.Rdata 文件保存代码运行的数据对象
load(“.Rdata”)        #载入.Rdata
#.Rhistory 文件保存代码运行的历史命令
load (“.Rhistory.R”)  #载入.Rhistory.R

二、基础语法

1 算术运算

1 + 2   # 加
3 - 1   # 减
2 * 5   # 乘
5 / 3   # 除
3 ^ 2   # 平方
8 %% 3  # 求余
8 %/% 3 #整除 
%*%     #用于矩阵相乘。 

2 逻辑判断

3 == 2         # 等于
3 != 2         # 不等
3 > 2          # 大于
3 < 2          # 小于
3 >= 2         # 大于等于
3 <= 2         # 小于等于
&      # 元素逻辑与运算符，将第一个向量的每个元素与第二个向量的相对应元素进行组合，如果两个元素都为 TRUE，则结果为 TRUE，否则为 FALSE。
|      # 元素逻辑或运算符，将第一个向量的每个元素与第二个向量的相对应元素进行组合，如果两个元素中有一个为 TRUE，则结果为 TRUE，如果都为 FALSE，则返回 FALSE。
！     #逻辑非运算符，返回向量每个元素相反的逻辑值，如果元素为 TRUE 则返回 FALSE，如果元素为 FALSE 则返回 TRUE。
&&     #逻辑与运算符，只对两个向量对第一个元素进行判断，如果两个元素都为 TRUE，则结果为 TRUE，否则为 FALSE。
||     #逻辑或运算符，只对两个向量对第一个元素进行判断，如果两个元素中有一个为 TRUE，则结果为 TRUE，如果都为 FALSE，则返回 FALSE。

if (cond) {statement_1}
if (cond) {statement_1} else{ statement_2}

switch(expression, case1, case2, case3....)
switch 语句中的 expression 是一个常量表达式，可以是整数或字符串，如果是整数则返回对应的 case 位置值，如果整数不在位置的范围内则返回 NULL。
如果匹配到多个值则返回第一个。
expression如果是字符串，则对应的是 case 中的变量名对应的值，没有匹配则没有返回值。
switch 没有默认参数可用。

3 循环

for (name in expr_1) { expr_2 }
for( 指标变量 in 执行范围) { 语句表达式 }

repeat { 
    // 相关代码 
    if(condition) {
       break
    }
}

while(condition)
{
   statement(s);
}

#循环控制
break  #跳出循环
next   #用于跳过当前循环，开始下一次循环（类似其他语言的 continue）

4 赋值

a = 3
b <-3

5 其他

Inf   # 无穷大
-Inf  # 负无穷
NA    # 缺失值
NULL  # 空值
>     #命令或者运算提示符  
+     #续行符 
>？boxplot 或者 help(boxplot) #求助符 ？ 或 help()
%in%  #用于判断元素是否在向量里，返回布尔值，有的话返回 TRUE，没有返回 FALSE。

6 自定义函数

myfunction <- function(arg1,arg2, ... ){ 
                        statements 
                      return(object) 
} 

my function #函数名称
arg1，arg2  # 参数 ，可设置默认值
statements   #为函数语句
return(object)   #返回结果

#定义中使用
mapply(function(x,y,z) round(mean(c(x,y,z)),2),Math,Science,English)

三、数据类型

1 数值类型

212.21           # 数值型
‘wd’;"aw";"汉字"  # 字符型
TRUE;T;FALSE;F   # 逻辑型

2 R对象

1、对象具有的基本的类有：
  数值（numeric）、逻辑（logical）、字符（character）、列表（list）。
2、在此基础上构成了一些复合型的类：
  矩阵（matrix）、数组（array）、因子（factor）、数据框（dataframe）。
3、R对象都有两个基本属性：mode（类型）属性和length（长度）属性。

mode()     #给出的是一种比较古老的类型划分（S语言是R的前身）
class()    #给出的是基于面向对象的R的类型划分

3 操作

对象类型判断

mode(); class()  # 查看数据类型
#判断数据类型，返回值为TRUE或FALSE
is.numeric()     # 判断是否数值型
is.logical()     # 判断是否逻辑型
is.charactor()   # 判断是否字符型
is.data.frame()  # 判断是否为数据框

对象类型转换

as.numeric()     #转换为数值型
as.logical()     #转换为逻辑型
as.charactor()   #转换为否字符型
as.matrix()      #转换为矩阵
as.data.frame()  #转换为数据框

4 取名规则

1、R区分大小写，A与a是不同的;
2、对象名不能用数字开头，但是数字可以放在中间或结尾。推荐用"."作为间隔，例如 anova.result1;
3、保留名称(命名对象时不要与保留名称冲突): NA, rownames, mean, max......

四 数据结构

0 总览

向量(vector) 一系列元素的组合;
数组(array) 数组是k维的数据表; 
矩阵(matrix) 矩阵是数组的一个特例，维数k = 2 ;
数据框(dataframe) 是由一个或几个向量和（或）因子构成，它们必须是等长的，但可以是不同的数据类型;
列表(list) 列表可以包含任何类型的对象
因子（factor）用于存储类别的类型

1 向量

1.1 向量定义

vec = c(1,2,2,3)    # 自定义数值，字符或逻辑向量
vec = 1:10          # 连续数值向量 等价于 vec<-c(1:10)
vec = 'a':'z'       # 报错，字符不行
letters             # a-z 连续字符
LETTERS             # A-Z 连续字符 
b<-c("one","two","three")             #字符向量
c<-c("TRUE","FALSE","TRUE","FALSE")   #注意这是字符向量
l<-c(TRUE,FALSE,TRUE,FALSE)           #这才是布尔向量      
d<-c(1, 2, 3,  "three",  "hello")     #混合类型向量

1.2 混合元素自动转换字符型

> mix_vec = c(9,T,'212','sd')
> mix_vec
[1] "9"    "TRUE" "212"  "sd"

1.3 定义元素名称

> names(vec) = char_vec  
> vec
A B C D 
1 2 2 3 
> names(vec) = NULL  # 删除元素名称

1.4 向量组合计算

c(1,3,5) + c(1,2,3) = c(1+1,3+2,5+3)# 对应元素相加
c(1,3,5) + c(1,2) = c(1+1,3+2,5+1)  # 重复相加短向量
c(1,3,5) + 2 = c(1+2,3+2,5+2)       #
c(c(1,3,5),c(1,2)) = c(1,3,5,1,2)   # 直接拼接

1.5 元素操作

e<-c(1, 7, 8, 2, 5, 6)
e[3]         #提取第三个值
e[-2]        #提取除第二个值以外的其他值
e[1:3]       #提取连续元素
e[-2:-4]     #除第2/3/4个值以外的其他值
e[c(2, 5, 3)]#返回第2/5/3个值，提取非连续元素


letters[1:7]       # 返回a-g
LETTERS[1:7]       # 返回A-G

#根据条件切片
term = num_vec > 2  #返回一个和num_vec同长度的布尔向量，值为num_vec中对应值的判断结果。这里判断条件为是否大于2
num_vec[term]       #根据布尔向量结果对num_vec切片，返回TRUE值对应元素
which(term)         #返回布尔向量中TRUE值对应的索引。which(num_vec > 2)即返回num_vec中大于2的值的索引

#根据名称切片
num_vec['A']

1.6 常用函数

a %in% b    #判断前面一个向量内的每一个元素分别是否在后面一个向量中，返回布尔向量。
union(x,y)  #返回x和y的并集
intersect(x, y )  #返回x和y的交集，以前一个为准
setdiff( x, y)    #返回x和y的差集（以x为准）
setequal( x, y)   #判断x和y是否有相同的元素，忽略排序

seq(from, to, by,length.out, along.with,...)  #等间隔函数
  from: 序列起点
  to：序列终点
  by：步长，可以是正数、负数、小数
  length.out：序列长度（即序列中的数字个数）
  along.with：序列内容（同样是序列中的数字个数）
seq(from=4, to=10, by=2)
seq(from=0, to=2, length=5)

rep()    #重复函数
rep(1, times=5)
rep(c(1, 2), times=3)

set.seed(250)    #设置随机数种子，这里用于保障随机可重复
runif() 均匀分布随机数 
rnorm() 正态分布随机数; rnorm(10, mean=20, sd =1)
rbinom() 二项分布随机数
rexp() 指数分布随机数

a <- runif(3,  min=0,  max=100)  #产生3个0到100区间的随机数
floor(a)    #对a中数向下取整
ceiling(a)  #对a中数向上取整
round(a,4)  #对a中数四舍五入到第4位小数
sum(a)      #对a中数求和
mean(a)     #对a中数求平均值
max(a)      #对a中数取最大值
min(a)      #对a中数取最小值
sort(a)     #对a中数从小到大排序。对于字符数组，sort按ascii字符码排序。
rev(a)      #返回a的反序向量
length(a)   #返回a长度

2 矩阵

2.1 自定义矩阵

mtx = matrix(1:20, nrow=5,ncol=4)  # byrow = TRUE

2.2 自定义行列名

rownames(mtx) = c('G1','G2','G3','G4','G5') # 自定义行名
colnames(mtx) = c('S1','S2','S3','S4') # 自定义列名
rownames(mtx)  # 查看行名
colnames(mtx)  # 查看列名

2.3 矩阵切片

# 根据位置切片
mtx[1,]    # 提取第1行
mtx[1:3,]  # 提取1-3行
mtx[,2]    # 提取第2列
mtx[,2]          # 访问矩阵的第2列所有元素   返回的结果是一个向量
mtx[,1, drop=F]  # 访问矩阵的第2列所有元素   返回的结果仍是一个矩阵


mtx[-1,]   # 删除第1行

mtx[c(1,2),c(3,4)]  # 提取1/2行，3/4列

# 根据名称切片
mtx[,'S3'] 
mtx[,c('S1','S2')]

2.4 常用函数

cbind(A, B)  # 按列合并   
rbind(A, B)  # 按行合并
transform<-t(A)    # t(A)表示矩阵A的转置
as.vector(A)       # 将矩阵转化为向量

dim(mtx)       # 查看行列数
nrow(mtx)      # 查看行数
ncol(mtx)      # 查看列数
rowMeans(mtx)  # 按行求均值
colSums(mtx)   # 按列求和
length(mtx)    # 获取总长度

3 数据框

3.1 数据框的创建

数据框的每一行包含有同一样本的不同观测值。

patientID <- c(1, 2, 3, 4)
age <- c(25, 34, 28, 52)
diabetes <- c("Type1", "Type2", "Type1", "Type1")
status <- c("Poor", "Improved", "Excellent", "Poor")
patient_data <- data.frame(patientID, age, diabetes, status)

3.2 数据框的引用切片

由于数据框是二维数据，类似矩阵，所以引用方法相似

#subset()对数据框的列进行操作
subset(patientdata, age>30 & diabetes=="Type1",c(age,status),drop=F) 
subset(A, A[,2]>6, select=c(1,3))

3.3 常用函数

attach()  #将数据框添加到R的搜索路径中，R在遇到一个变量名后，将检查搜索路径中数据框的列名。
detach()  #将数据框从R的搜索路径中去除。

4 数组

数组与矩阵类似，但数组的维度可以大于2

#数组创建
myarray <- array(vector,  dimensions,  dimnames)
a <- array(1:24, c(2, 3, 4), dimnames=list(dim1, dim2, dim3))
# dimnames：各维度名称的标签

5 列表

列表允许整合若干（可能无关的）对象到单个对象名下，其对象可以是目前讲到的任何结构（向量、矩阵、数据框等）。

#列表创建
my_list <- list(title=g, ages=h,  j,  k)
#切片
my_list[[2]]  == my_list$age == my_list[["ages"]] #三者等价

6 因子

因子（factor)是R语言中比较特殊的一个数据类型， 它是一个用于存储类别的类型。

# 因子创建
fac = factor(c('A', 'B','A','B','AB','O','A','A'),  # 数据
             levels=c('A','B','AB','O'))  # 类别
fac[1] # 因子水平不改变
  [1] A
  Levels: A B AB O