一、R与Rstudio的安装

· R可以在CRAN上免费下载：(https://www.r-project.org/)

· ①. 首先，点击 download R

image.png

· ②. 其次，选择清华镜像

image.png

· ③. 接着，选择合适自己系统的R版本

image.png
· ④. 最后，选择base，即可安装成功
image.png

· 然后，安装RStudio：(https://rstudio.com/products/rstudio/download/)
· RStudio是比较推荐的R的集成开发软件
· 我们安装RStudio的免费版本

image.png
· 同样要选择合适自己系统的版本
image.png
· 最后，假如你是window，建议你再安装一个Rtools
· Rtools的作用是什么？就是为了在window系统下更好地建设R包环境
· 例如，你在window下安装R包shiny时，没有安装Rtools就会报错
· 在清华大学的 CRAN 镜像中可以下载 Rtools
image.png
image.png

· 假如你的R不是最新的，你也可以在this page页面下载到和自己R版本对应的Rtools工具

image.png image.png
· 安装 Rtools时，一定要要勾选添加 rtools 到环境变量中这个选项
image.png
· 安装Rtools的第二种方法：通过设置清华大学 CRAN 后，先安装installr包，再通过这个包直接下载安装 Rtools

options("repos"=c(CRAN="https://mirrors.tuna.tsinghua.edu.cn/CRAN/"))
install.packages('installr')
library(installr)
install.Rtools()

二、R包的安装

①. 从CRAN中安装R包

· 我们可以在控制台直接输入"install.packages("ggplot2")"

image.png

· 我们也可以通过RStudio安装“ggplot2”

image.png

重点掌握:
· R包安装成功后，我们通过library(ggplot2)或require(ggplot2)加载到环境中;
· 假如你想查看已安装的R包，可以使用installed.packages()查看;
· 假如你想知道R包被安装在哪个位置，可以使用.libPaths();
· 假如你想将已加载的R包从环境中卸载，可以使用detach("package:ggplot2")，也可以通过"Packages"界面取消勾选相应的R包;
· 假如你查看R包里面有什么函数，可以通过help(package="ggplot2");
· 假如你对ggplot2中的某个函数不太清楚，例如geom_bar函数，可以通过?geom_bar查看它的具体用法
· 假如你想移除你的R包，可以使用remove.packages("ggplot2")
· 假如你想查看R版本及加载进去的R包的信息，可以使用sessionInfo()

②.从bioconductor中安装R包

image.png
· 从bioconductor中安装R包，要先安装BiocManager包

if (!requireNamespace("BiocManager", quietly = TRUE))
    install.packages("BiocManager")

BiocManager::install("clusterProfiler")

· 如果感觉从CRAN或者Bioconductor上下载太慢，可以适当改变一下镜像

############################### r语言最新镜像 ##############################
options(BioC_mirror="https://mirrors.tuna.tsinghua.edu.cn/bioconductor/")
options("repos" = c(CRAN="http://mirrors.cloud.tencent.com/CRAN/")) 
options(download.file.method = 'libcurl')
options(url.method='libcurl')
BiocManager::install("miRNAtap",ask = F,update = F)
BiocManager::install("topGO",ask = F,update = F)
BiocManager::install("miRNAtap.db",ask = F,update = F)

③.从github中安装R包

image.png

· 从github中安装R包，要先安装devtools

install.packages("devtools")
library(devtools)
devtools::install_github("jokergoo/ComplexHeatmap")

· 如果有时候网速太慢，迫不得已需要下载zip包（推荐用迅雷）

image.png

· 从github上将zip包下载到本地后，我们需要经过编译才能安装上；
· 编译的方式有两种：
· ①. devtools::install_local("路径")

devtools::install_local("C:\\Users\\Administrator\\Desktop\\ComplexHeatmap.zip")
devtools::install_local("C:/Users/Administrator/Desktop/ComplexHeatmap.zip")

· ②. 先解压zip成文件夹，install.packages("路径",repos = NULL, type="source")

install.packages("C:\\Users\\Administrator\\Desktop\ComplexHeatmap",repos = NULL, type="source")

· 这两种编译方式看起来一样，但实则大不一样。
· 前者的路径写到zip文件即可，后者需要先把zip文件加压后，然后再路径写到文件夹；
· 在window系统中，路径要用\\或者 /隔开，在linux中要用\

④.从gitee中安装R包

· 如果有时候github上网速慢到zip包都下载不下来，或者R包项目文件非常大、非常多难以下载，这时候我们就需要先把github上的包克隆到gitee，然后再从gitee上下载
· 因为gitee在国内的下载速度还是很喜人的
· 假如你已经把项目克隆到gitee上，你可以直接从gitee上安装R包

devtools::install_git("https://gitee.com/jmzeng/GEOmirror")

· 如果你要直接install_git，并且你的电脑是window系统，记得提前安装一个Git客户端，给电脑增加一个git环境，才能运行成功这个代码。
.当然，你也可以从gitee上下载zip文件，然后再在本地进行编译安装
· gitee的顺利使用，需要你先在gitee上注册账号。

三、R语言编程基础

· 查看当前工作目录，可以用getwd()函数。
· 设置工作目录，可以用setwd()函数，也可以在Rstudio里面更改

> getwd()
[1] "/home/shpc_8b2a385294/conf"
> setwd("~/fcq")
> getwd()
[1] "/home/shpc_8b2a385294/fcq"

· R的注释有#开头，出现在#后面的文本会被R解释器忽略
· R语句由函数和赋值构成，赋值符号为<-或=，虽然这两个都能起到赋值的作用，但个人建议用<-，这样不容易出错
· <-的快捷键是Alt+-

> a <- 2 # I'm an anotataion
> a
[1] 2
> a = 2 # I'm an anotataion
> a
[1] 2
> 

· R语言的数学运算和我们平时的数学运算（+、-、*、/）是一致的

> 1+1
[1] 2
> 1-1
[1] 0
> 1*1
[1] 1
> 1/1
[1] 1
> a = 1+1
> a
[1] 2

· class()函数可以查看数据类型、数据结构
· R中有4种数据类型：数值型、字符型、逻辑型和日期型

> a <- 1
> class(a)
[1] "numeric"
> a <- "1"
> class(a)
[1] "character"
> a <- T
> a
[1] TRUE
> class(a)
[1] "logical"
> a <- TRUE
> a
[1] TRUE
> class(a)
[1] "logical"
> a <- as.Date("2021-03-17")
> a
[1] "2021-03-17"
> class(a)
[1] "Date"

· 字符不能直接相加，但数值可以直接相加

> a <- "1"
> b <- "1"
> a
[1] "1"
> b
[1] "1"
> a+b
Error in a + b : non-numeric argument to binary operator
> a <- 1
> b <- 1
> a+b
[1] 2

· R语言的逻辑运算：>、==、<、>= 、<=、!=、&（和）、|（或）、!（非）

> a <- 1
> a > 1
[1] FALSE
> a = 1
> a == 1
[1] TRUE
> a < 1
[1] FALSE
> a >= 1
[1] TRUE
> a <= 1
[1] TRUE
> a != 1
[1] FALSE

> a <- T
> a
[1] TRUE
> b <- F
> b
[1] FALSE
> a & b
[1] FALSE
> a | b
[1] TRUE
> !a
[1] FALSE
> !b
[1] TRUE

· R语言的数据结构：向量、矩阵、数据框、列表 。
· 1. 向量：使用c()函数创建，常见有3种类型：数值型、字符型和逻辑型。单个向量的数据类型是固定的。

> a <- c(1,2,3,4)
> a
[1] 1 2 3 4
> class(a)
[1] "numeric"
> a <- c("1","2","3","4")
> a
[1] "1" "2" "3" "4"
> class(a)
[1] "character"
> a <- c(T,F,T,F)
> a
[1]  TRUE FALSE  TRUE FALSE
> class(a)
[1] "logical"

> a <- c(1,2,"3","4")
> a
[1] "1" "2" "3" "4"
> class(a)
> a <- c(1,2,T,F)
> a
[1] 1 2 1 0

· ①. 向量的索引

> a <- c(1,2,4,3)
> a
[1] 1 2 4 3
> a[1]
[1] 1
> a[3]
[1] 4
> a[1:3]
[1] 1 2 4
> a[-1]
[1] 2 4 3
> a[c(1,4)]
[1] 1 3
> a[a>2]
[1] 4 3
> a[a>3]
[1] 4
> a[a==3]
[1] 3
> a[a<=3]
[1] 1 2 3

· ②. 向量的排序

> a <- c(1,2,4,3)
> a
[1] 1 2 4 3
> ?sort
> sort(a)
[1] 1 2 3 4
> sort(a,decreasing = T)
[1] 4 3 2 1
> sort(a,index.return=T,decreasing = T)
$x
[1] 4 3 2 1

$ix
[1] 3 4 2 1

· ③. 向量的唯一化

> a <- c("b","b","c","c","d","d")
> a
[1] "b" "b" "c" "c" "d" "d"
> unique(a)
[1] "b" "c" "d"

· ④. 连续向量的离散化

> a <- c(1,2,4,3)
> a
[1] 1 2 4 3
> a <- cut(a,breaks = c(0,2,4),labels = c("0-2","2-4"),right = T)
> a
[1] 0-2 0-2 2-4 2-4
Levels: 0-2 2-4

· ⑤. 向量的因子化

> a <- c("good","good","fair","fair","very good","very good")
> a
[1] "good"      "good"      "fair"      "fair"      "very good" "very good"
> class(a)
[1] "character"
> a <- as.factor(a)
> a
[1] good      good      fair      fair      very good very good
Levels: fair good very good
> a <- c("good","good","fair","fair","very good","very good")
> a <- factor(a)
> a
[1] good      good      fair      fair      very good very good
Levels: fair good very good
> a <- c("good","good","fair","fair","very_good","very_good")
> a
[1] "good"      "good"      "fair"      "fair"      "very_good" "very_good"
> class(a)
[1] "character"
> a <- as.factor(a)
> a
[1] good      good      fair      fair      very_good very_good
Levels: fair good very_good
> a <- c("good","good","fair","fair","very_good","very_good")
> a <- factor(a)
> a
[1] good      good      fair      fair      very_good very_good
Levels: fair good very_good
> a <- factor(a,levels = c("fair","very_good","good"))
> a
[1] good      good      fair      fair      very_good very_good
Levels: fair very_good good
> a <- factor(a,levels = c("fair","very_good","good"),ordered = T)
> a
[1] good      good      fair      fair      very_good very_good
Levels: fair < very_good < good

· ⑤. 向量类型的转化：

> a <- c("1","2","3","4")
> a
[1] "1" "2" "3" "4"
> a <- as.numeric(a)
> a
[1] 1 2 3 4

· 因子型向量转换成数值型向量，需要先转换成字符型向量，再从字符型向量转化成数值型向量

> a <- factor(c(1,3,5,2,4),ordered = T)
> a
[1] 1 3 5 2 4
Levels: 1 < 2 < 3 < 4 < 5
> a <- as.numeric(a)
> a
[1] 1 3 5 2 4
> a <- factor(c(1,3,5,2),ordered = T)
> a
[1] 1 3 5 2
Levels: 1 < 2 < 3 < 5
> a <- as.numeric(a)
> a
[1] 1 3 4 2
> a <- factor(c(1,3,5,2),ordered = T)
> a <- as.character(a)
> a
[1] "1" "3" "5" "2"
> a <- as.numeric(a)
> a
[1] 1 3 5 2

· 2. 数据框：一般用行来表示观测，用列来表示变量。
· 你可以把数据框看作由不同数据类型的向量组成的集合。
· data.frame函数可以构建数据框

> df <- data.frame()  # 空数据集
> df
data frame with 0 columns and 0 rows
> df <- data.frame(x=c("a","b","c"),y=1:3,z=c(2,5,6))
> df
  x y z
1 a 1 2
2 b 2 5
3 c 3 6

· 查看数据框各列的数据类型

> df <- data.frame(x=c("a","b","c"),y=1:3,z=c(2,5,6))
> class(df$x)
[1] "character"
> class(df$y)
[1] "integer"
> class(df$z)
[1] "numeric"
> str(df)
'data.frame':   3 obs. of  3 variables:
 $ x: chr  "a" "b" "c"
 $ y: int  1 2 3
 $ z: num  2 5 6

· view函数、head函数和tail函数可以查看数据框的基本情况

> df <- data.frame(x=c("a","b","c"),y=1:3,z=c(2,5,6))
> View(df)
> head(df)
  x y z
1 a 1 2
2 b 2 5
3 c 3 6
> head(df,1)
  x y z
1 a 1 2
> tail(df)
  x y z
1 a 1 2
2 b 2 5
3 c 3 6
> tail(df,5)
  x y z
1 a 1 2
2 b 2 5
3 c 3 6

· 可以通过符号$和[]来取数据框某一列的内容

> df <- data.frame(x=c("a","b","c"),y=1:3,z=c(2,5,6))
> df$x
[1] "a" "b" "c"
> df[,1]
[1] "a" "b" "c"
> df[,c(1,2)]
  x y
1 a 1
2 b 2
3 c 3
> df[,"x"]
[1] "a" "b" "c"
> df[,c("x","z")]
  x z
1 a 2
2 b 5
3 c 6

> df
  x y z
1 a 1 2
2 b 2 5
3 c 3 6
> df[1,2]
[1] 1
> df[1,"x"]
[1] "a"
> df[1,x]
Error in `[.data.frame`(df, 1, x) : undefined columns selected

· 获取数据框的行数、列数、行名和列名

> df <- data.frame(x=c("a","b","c"),y=1:3,z=c(2,5,6))
> nrow(df)
[1] 3
> ncol(df)
[1] 3
> dim(df)
[1] 3 3
> rownames(df)
NULL
> colnames(df)
[1] "x" "y" "z"
> rownames(df) <- c("A","B","C")
> View(df)
> df["A",]
  x   y   z 
"a" "1" "2" 
> df[1,]
  x   y   z 
"a" "1" "2" 
> colnames(df) <- c("X","Y","Z")
> View(df)

· 3. 矩阵：也可以看做多个向量的合集，但这些向量必须是相同类型的。矩阵的操作和数据框差不多，但不能用符号$来提取列的内容

> df <- data.frame(x=c("a","b","c"),y=1:3,z=c(2,5,6))
> class(df)
[1] "data.frame"
> df <- as.matrix(df)
> class(df)
[1] "matrix" "array"
> df[,1]
[1] "a" "b" "c"
> df[1,]
  x   y   z 
"a" "1" "2" 
> df[1,1]
  x 
"a" 
> class(df[1,1])
[1] "character"
> df[,c(1,2)]
     x   y  
[1,] "a" "1"
[2,] "b" "2"
[3,] "c" "3"

· 4. 列表：由分量组成的集合，这些分量可以是向量、数据框或矩阵。

> dat <-list( c(1,2) , data.frame(number=c(1,2),aplha=c("a","b")),
matrix(c(1,2,3,4),nrow = 2))
> View(dat)
> dat[[1]]
[1] 1 2
> dat[[2]]
  number aplha
1      1     a
2      2     b
> dat[[3]]
     [,1] [,2]
[1,]    1    3
[2,]    2    4