R语言数据结构主要有以下四种：
1.向量
2.数据框
3.矩阵
4.列表
- 最好理解的是数据框，数据框约等于“表格”
第一个约等于：数据框是R语言里的一个数据，没办法用其它软件去打开一个R语言内部的数据，通常的表格是一个文件，可以用R语言或是Excel去处理。数据可以导出变成一个表格文件，但它本身并不是一个表格文件，而是一个R语言内部的数据。
第二个约等于：数据框比表格多一个要求，每一列只能有一种数据类型，不能是掺杂的。
- 数据框单独拿出来的一列是向量，视为一个整体。
向量：一串相同类型的数据，不限于数字，字符，逻辑都可以，单独拿出来的一列。什么是看做一个整体，一个向量里有若干个数据，它们组成一个整体之后，可以拥有一个共同的名字。
- 一个向量只能有一种数据类型，可以有重复值。
以下主要讲向量：
1.向量
1.1 向量的生成
1.2 对单个向量进行的操作
1.3 对两个向量的操作
1.4 向量筛选(取子集)：[ ]
1.5 修改向量中的某个/某些元素
1.6 简单向量作图
1.7 两个非常重要的函数：order()函数 和 match()函数
1.1 向量的生成
向量就是一串数据，串联在一起，组成一个整体，向量由元素组成。
1.1.1 用c()函数逐一放到一起
c(1,3,5,8,10,4,6)
#[1] 1 3 5 8 10 4 6
##生成数值型向量
c('hello','a','b','well','to')
#[1] "hello" "a" "b" "well" "to"
##生成字符型向量，每一个元素都要用引号括起来，并用逗号隔开。
1.1.2 连续的数字用冒号:
很长的向量要么从数据框提取一列，或是有规律地生成，如连续的数据：
1:10
#[1] 1 2 3 4 5 6 7 8 9 10
##生成1到100，或是1到1000
1.1.3 有重复的用rep()，有规律的序列用seq()，随机数用rnorm()
###rep():重复生成
rep("5",times=3)
#[1] "5" "5" "5"
##"5"为字符串，times=3为rep()的参数，重复生成3次。可探索，把5换成hao，注意不能少引号，times=5，看看变化。
##可以写成rep("5",3)
###seq()：每隔几个数取一个数
seq(from=2,to=18,by=4)
#[1] 2 6 10 14 18
##from=2,to=18是参数，从2开始到18结束，by=4为步长，每隔4取一个数
##seq()函数不能用tab补全参数，很多函数是可以用tab键补全参数的，所以要做注意。
##可以写成seq(2,18,4)
###rnorm()：随机生成函数，
#规律性不强，随便钻一组数据。对于一些很大数据，每跑一次会花很长时间。先调试生成一些示例和模拟的数据来试试做图函数或代码是否有问题，再去跑大数据。
rnorm(n=3)#第一次运行
#[1] -0.5318562 -0.8356833 -0.8779566
rnorm(n=3)#第二次运行
#[1] 0.7178552 -0.7849374 0.4154913
rnorm(n=3)#第三次运行
#[1] 0.09768904 0.12753825 -0.14526579
##每次运行出来的结果会发生变化，
rnorm(n=1)
#[1] 0.873337
rnorm(n=0)
#numeric(0)
1.1.4 通过组合，产生更为复杂的向量：paste0函数
paste0函数连接两个向量，逗号,前后各有一个向量，如字符型和数值型向量。
paste0(rep("x",times=3),1:3)
#[1] "x1" "x2" "x3"
##rep("x",times=3)是一个函数，单独运行，1:3是一个向量。paste0()函数把逗号前后的向量一对一的连结起来。
##括号前面是函数。
#生成1到30之间所有4的倍数
##from=1,to=30，不对，注意是4的倍数，改为从from=4,to=30才对
seq(from=4,to=30,by=4)
#生成sample4，sample8，sample12…sample28
length(seq(from=4,to=30,by=4))
#7
##先统计长度，确定rep的times参数是多少
paste0(rep('sample',times=7),seq(from=4,to=30,by=4))
#[1] "sample4" "sample8" "sample12" "sample16" "sample20"
#[6] "sample24" "sample28"
##在rep('sample',times=7）中，times=7，7变为任何数字都不会报错，只是结果有差异，涉及到一个概念为循环补齐。
##探索
x=seq(from=4,to=30,by=4)
##第一种写法
paste0(rep("sample",times=length(x)),x)
##第二种写法
paste0("sample",x)
##最简化，但是初学者还是模仿写全，不要简化
- paste0和paste有什么区别或是联系。
a=c("a","b","c")
#注意("a","b","c") 括号前的字母一定是c，C()是生成向量的函数
paste0(rep("x",times=3),a)
#[1] "xa" "xb" "xc"
##两个向量的元素无缝连接
paste(rep("x",times=3),a)
##[1] "x a" "x b" "x c"
##两个向量的元素连接有空格
y<-c(2,3,3,5,5,9,3,3,8)
x<-c(2,4,6,8,9,1,5,3,8)
paste0(x,y)
#[1] "22" "43" "63" "85" "95" "19" "53" "33" "88"
paste(x,y,sep ="" )
#[1] "22" "43" "63" "85" "95" "19" "53" "33" "88"
paste(x,y,sep ="'" )
#[1] "2'2" "4'3" "6'3" "8'5" "9'5" "1'9" "5'3" "3'3" "8'8"
paste(x,y,sep ="///" )
#[1] "2///2" "4///3" "6///3" "8///5" "9///5" "1///9" "5///3"
#[8] "3///3" "8///8"
?paste
?paste0
##paste()函数有默认参数，默认参数可以设置。
##paste0()函数没有默认参数，无缝连接。
paste0和paste的区别是：
paste0函数把两个向量的元素一一对应进行无缝连接，而paste函数把两个向量的元素一一对应进行空格连接。paste函数有默认值为空格，在空格处把空格去掉sep=""引号里把默认的空格去掉，即什么没有，就变成无缝连接，也可以用其它的符号连接sep="/"，sep="_"等。
数据类型转换的优先顺序
数值型、字符型、逻辑型：只要有字符型在，用c()生成向量为字符型。只有逻辑型和数值型，用c()生成向量为数值型。
c()函数生成向量时，要求为生成同一种数据类型
##（1）把数值型和字符型放在一起
c(3,6,9,'normal')
#[1] "3" "6" "9" "normal"
##根据返回结果，把数值型和字符型放在一起，数值型会变成字符型，以此来满足向量里只有一种数据类型的结构。
##（2）把逻辑型和字符型放在一起
c(FALSE,'fail')
#[1] "FALSE" "fail"
##根据返回结果，把逻辑型和字符型放在一起，逻辑型会变为字符型
##（3）把逻辑型和字符型放在一起
c(TRUE,FALSE,2,5,8)
#[1] 1 0 2 5 8
##根据返回结果，把逻辑型和字符型放在一起，逻辑型变为数值型。
##把三种数据类型。
c(TRUE,258,FALSE,"failure")
##[1] "TRUE" "258" "FALSE" "failure"
##以上的数据类型转换时默认的，强制的规则。
1.2 对单个向量进行的操作
1.2.1 赋值给一个变量名
##(1)随意的写法：=
x=c(2,4,6,8,9,1,5,3,8)
##把向量赋值给x
x
#[1] 2 4 6 8 9 1 5 3 8
##再单独运行x才能看到x里的内容
#（2）规范的赋值符号：<-
##<- 与c()函数之间没有空格
x
#[1] 5 2 8 3 7
注意的地方：
变量名：c()为生成向量函数，一般除字母c外，取单个字母或是单词及缩写，组成变量名的字母之间不要有空格，不能以数字为变量名或是以数字开头，变量名不能是中文名，特殊符号等。
<-与c()函数之间没有空格。
x<-c()
<-的快捷键输入：
mac电脑：option 和-；
windows电脑：Alt和-
=在任何情况下可替代<- ，但是=除了赋值，还有其它用法，比如函数里参数用法。<- 不能在任意情况下代替=。
赋值+输出一起执行的两种操作：
- （1）用括号，中间为赋值语句，比较规范的写法
(x <- c(2,5,8))
##用括号括起来，不需要另外再输入x，
- （2）两句代码写在一行，中间用分号
；隔开，宽泛的写法
x <- c(3,6,9);x
##用分号连接两句代码，同步输入
rep("5",times=3);rnorm(n=1)
#[1] "5" "5" "5"
#[1] 0.3446658
1.2.2 向量的简单计算
强大的计算是体现在批量计算上，先把一些数据组成一个整体，
x <- c(2,1,5,8);x
#[1] 2 1 5 8
###以x为单位计算：
x+1
#[1] 3 2 6 9
##向量里的每个元素都加1
log(x)
#[1] 0.6931472 0.0000000 1.6094379 2.0794415
sqrt(x)
#[1] 1.414214 1.000000 2.236068 2.828427
1.2.3 根据某条件进行判断，生成逻辑值向量
还是以向量x为单位进行
x <- c(2,1,5,8);x
#[1] 2 1 5 8
##以x为单位进行，对里的每个元素依次与条件比较
x>3
#[1] FALSE FALSE TRUE TRUE
x==5
#[1] FALSE FALSE TRUE FALSE
##返回的逻辑值个数与向量里元素的数量是一致的，一一对应，有天然的等位关系。
1.2.4 向量初级统计
max(x) #最大值
min(x) #最小值
mean(x) #均值
median(x) #中位数
var(x) #方差
sd(x) #标准差
sum(x) #总和length(x) #长度
unique(x) #去重复
duplicated(x) #对应元素是否重复
table(x) #重复值统计
sort(x)#排序
其中五个重要函数，一定要掌握。
能用函数代替的东西，坚决不用手和眼睛去数，比如length()统计向量元素个数。
x <- c(3,2,5,8,8,9,5,3);x
length(x)
#8
#长度，向量里有多少个元素。8个元素
unique(x)
#[1] 3 2 5 8 9
##去重复，当一个元素第一次出现时被保留下来，不管后面出现多少次都不会保留。只出现一次会保留下来。
duplicated(x)
#[1] FALSE FALSE FALSE FALSE TRUE FALSE TRUE TRUE
##对应元素是否重复，判断x里的每个元素是否发生重复，第一次出现，不管后面有或是没有，统一称为没有重复，为FALSE。后面出现重复的元素返回TRUE，后面出现的8，5，3重复。
!duplicated(x)
#[1] TRUE TRUE TRUE TRUE FALSE TRUE FALSE FALSE
###!duplicated(x) 与duplicated(x) 相反，注意！的位置
table(x)
#x
#2 3 5 8 9
#1 2 2 2 1
#重复值统计，取值的统计，相同的数据算一个取值。统计取值以及取值重复多少次，取值按小到大排序。返回的结果，第一行为取值，取值从小到大排序，第二行，统计每个取值的出现的次数。
sort(x)
#[1] 2 3 3 5 5 8 8 9
#排序，默认升序，从小到大排序
?sort
##查看帮助文档里的Usage，会介绍该函数的参数的用法。默认思想就写在帮助文档里：sort(x, decreasing = FALSE）
sort(x,decreasing = T)
##逻辑值有FALSE和TRUE两选项，两个是相反的结果。
##函数rev()
rev(sort(x))
##把sort(x)倒着来
rev(x)
##把x的顺序倒着写，rev(x)从最后一个数开始往前排，不是按数值大小
1.2.5 补充知识点：
- unique(x)与x[!duplicated(x)]
x=c(1,3,5,1)
unique(x)
#[1] 1 3 5
x[duplicated(x)]
#[1] 1
x[!duplicated(x)]
#[1] 1 3 5
x[!duplicated(x)]
#[1] 1 3 5
unique(x)==x[!duplicated(x)]
#[1] TRUE TRUE TRUE
结论：unique(x)与x[!duplicated(x)]函数相同
- identical()函数
用identical()可以判断两个函数是否相同（数据结构与数据类型是否完全相同）
x=c(1,3,5,1)
y1=unique(x);y1
#[1] 1 3 5
y2=x[!duplicated(x)];y2
#[1] 1 3 5
identical(y1,y2)
#[1] TRUE
- round() 函数：round()是保留小数
a=rnorm(7);a
#[1] -1.88973351 -0.28202626 0.33448671 0.69462120 0.00982272
[6] -1.27716641 -0.41109351
a=round(a,2);a
#[1] -1.89 -0.28 0.33 0.69 0.01 -1.28 -0.41
##round(a,2),a向量里的数值保留两位小数
sort(a[a<0])
#[1] -1.89 -1.28 -0.41 -0.28
sort(a)[a<0]##这句代码是错的，先sort(a)是不对的
#[1] -1.89 -1.28 0.33 0.69
1.3 对两个向量的操作
1.3.1 逻辑比较，生成等长的逻辑向量
y<-c(2,3,3,5,5,9,3,3,8)
x<-c(2,4,6,8,9,1,5,3,8)
#两个向量逻辑比较
x==y
#[1] TRUE FALSE FALSE FALSE FALSE FALSE FALSE TRUE TRUE
##判断两个等长向量的元素是否一一对应相等。
x%in%y
#x的每个元素在y中存在吗
#[1] TRUE FALSE FALSE TRUE TRUE FALSE TRUE TRUE TRUE
##对x里的每个元素判断，在y里面判断有没有和x相同的元素，’群殴‘x的一个打y里的9个元素，在y里面，只要有和x的元素相同为TRUE，y的一个元素和x里的元素一一对应比较，但返回不是一一对应的位置，x%in%y不讲位置，但凡有相同的就可以。
重点和难点：
x==y：x和对应位置的y相等吗？（x和y里的元素，按顺序一一对应比较，讲究位置对应，两者里第一个元素相同就返TRUE，比较完两个向量的第一位置上的元素，接着比较两个向量第二个位置元素...到两个向量最后）。
x和y不一样长：理解“循环补齐”
x<-c(2,4,6,8,9,1,5,3,8)
y<-c(2,7,5,3,8)
x==y
#[1] TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
##返回9个逻辑值
#Warning message:
#In x == y : longer object length is not a multiple of shorter object length
length(x)
#[1] 9
length(y)
#[1] 5
##y的5个元素和x的5个元素比之后，y的5个元素再被拿去和x剩下的4个元素比较。
##修改x的后4个元素的值，和没修改的逻辑值比较，就能很好理解
x<-c(2,4,6,8,9,2,7,3,8)
y<-c(2,7,5,3,8)
x==y
#[1] TRUE FALSE FALSE FALSE FALSE TRUE TRUE FALSE FALSE
x<-c(2,8,3)
y<-c(2,6,3,5,8,9,3,8,3)
x==y
#[1] TRUE FALSE TRUE FALSE TRUE FALSE FALSE TRUE TRUE
##返回逻辑与长向量的元素个数一致，循环补齐。
##利用循环补齐简化代码
paste0(rep('x',3),1:3)
#[1] "x1" "x2" "x3"
##rep函数里的“times=”可以省略
paste0('x',1:3)
#[1] "x1" "x2" "x3"
##含1个元素的向量和3个元素的向量比较，返回是3个逻辑值，循环补齐。
结论：如果x与y的向量元素长度不相等，以长度向量说了算，不是由在==前的向量决定。
x%in%y：x的每个元素在y中存在吗？（x的元素挨个到y里和所有元素比较，在y里有的相同的返回TRUE，不讲究位置，有就是TRUE，没有为FALSE）。比如y向量加了一个元素2，返回还是9个逻辑值，返回的逻辑值是与x一一对应，和y没有关系。
x<-c(2,4,6,8,9,1,5,3,8)
y<-c(2,3,3,5,5,9,3,3,8)
x%in%y
[1] TRUE FALSE FALSE TRUE TRUE FALSE TRUE TRUE TRUE
y<-c(2,3,3,5,5,9,3,3,8,2)
##y向量末尾加上一个元素2，元素个数为10
x%in%y
[1] TRUE FALSE FALSE TRUE TRUE FALSE TRUE TRUE TRUE
##返回9个逻辑值
x<-c(2,4,6,8,9,1,5,3,8,2)
##x向量末尾加元素2，元素个数为10
x%in%y
# [1] TRUE FALSE FALSE TRUE TRUE FALSE TRUE TRUE TRUE
#[10] TRUE
##返回10个逻辑值
##总结，使用%in%比较两个向量时，返回逻辑的个数与%in%前（左边）向量的元素个数一致。
1.3.2 数学计算
加减乘除，两个向量直接可以进行，等位运算。前提是两个向量必须等长，即元素个数一样。
x<-c(2,4,6,8,9,1,5,3,8)
y<-c(2,3,3,5,5,9,3,3,8)
x+y
#[1] 4 7 9 13 14 10 8 6 16
1.3.3 连接
x<-c(2,4,6,8,9,1,5,3,8)
y<-c(2,3,3,5,5,9,3,3,8)
paste(x,y,sep=",")
#[1] "2,2" "4,3" "6,3" "8,5" "9,5" "1,9" "5,3" "3,3" "8,8"
##sep=",")，两个向量的元素一一对应以逗号为连接符。
paste(x,y,sep="/")
##[1] "2/2" "4/3" "6/3" "8/5" "9/5" "1/9" "5/3" "3/3" "8/8"
##sep="")两个向量的元素一一对应以/为连接符。
paste0(x,y)
#[1] "22" "43" "63" "85" "95" "19" "53" "33" "88"
##paste0(x,y)为无缝连接，把两个向量x和y的元素一一对应进行无缝连接
?paste
##paste(x,y,sep=" ")，paste函数的连接符默认为空格。
用paste0或是paste连接两个向量，两个向量的长度（元素个数）不一致，循环补齐。
1.3.4 交集、并集、差集
intersect(x,y)#交集
union(x,y)#并集
setdiff(x,y)#差集
setdiff(y,x)#差集,x与y顺序,setdiff()与%in%有点儿相似
intersect(x,y)，union(x,y)，setdiff(x,y)，setdiff(y,x)，x与y顺序颠倒（setdiff()与%in%有点儿相似）。
x<-c(2,4,6,8,9,1,5,3,8)
y<-c(2,3,3,7,5,9,3,3,8)
intersect(x,y)
#[1] 2 8 9 5 3
union(x,y)
#[1] 2 4 6 8 9 1 5 3
setdiff(x,y)
#[1] 4 6 1
setdiff(y,x)
#[1] 7
1.4 向量筛选(取子集)：[ ]
[]：取子集符号，将TRUE对应的值挑选出来，FALSE丢弃.
例：在13个数中，取出大于7的数，首先把13个数值组成一个向量x，x>7返回是逻辑值。
x <- 8:12;x
#[1] 8 9 10 11 12
1.4.1 根据逻辑值取子集
取值子集的对象放在中括号的外面，取子集的逻辑值向量放在中括号里面。
x[x==10]
#[1] 10
###取等于10的数字
x[x<12]
#[1] 8 9 10 11
##取小于12的数
x[x %in% c(9,13)]
#[1] 9
##c(9,13)可以赋值给y，取在y里有相同元素的数
单独运行中括号里的向量，中括号里各种条件的返回结果有共同的规律，是一个与x等长的逻辑值向量。
1.4.2 根据位置取子集（下标或是索取）
下标：代表在哪个位置上。
x <- 8:12;x
#[1] 8 9 10 11 12
x[2:4]
#[1] 9 10 11
##取向量的第2到第4个元素
x[c(1,5)]
#[1] 8 12
##取向量里的第1个，第5个。不是连续在一起的向量，用c()函数组合起来
##反选
x[-4]
#[1] 8 9 10 12
#把第四个元素11剔除掉，4是下标，第4个元素。
x[-(2:4)]
#[1] 8 12
##去掉第2到第4个，一定要加括号，不然优先顺序不对。与正取的顺序不一样
1.4.3 向量取子集总结：
符号：[]
按照逻辑值：中括号里是与x等长的逻辑值向量
按照位置：中括号里是由x的下标组成的向量（支持反选）
思考：从13个彩色（绿，蓝，黄）球中，选出属于蓝色和绿色的：
使用x %in% y还是x ==y，用x %in% y，不是等位循环补齐运算，%in%比较灵活，可以在很多场景中使用，如3选2，50选2，50选20等。
13个球的颜色赋值给向量x，蓝色和绿色赋值给y。
x %in% y
x[x %in% y]
1.5 修改向量中的某个/某些元素
1.5.1 取子集+赋值
修改向量的元素，修改x里的第四个元素
x <- 8:12;x
#[1] 8 9 10 11 12
##（1）改一个元素
##把数值11换成40
x[4] <- 40;x
#[1] 8 9 10 40 12
##利用下标，把x向量里的第4个元素赋值修改
##（2）改多个元素
x[c(1,5)] <- c(80,20);x
#[1] 80 9 10 11 20
##修改x里的第1个和第5个向量，以向量的方式修改
注意：R于语言里所有的修改，都要赋值，没有赋值就是没有发生过
1.6 简单向量作图
k1 = rnorm(12);k1
##生成12个随机数
k2 = rep(c("a","b","c","d"),each = 3);k2
##
plot(k1)
##一张平面图，需要横，纵坐标。k1向量作图，k1为纵坐标，横坐标为Index（坐标）。只拿了一个向量就得到一张平面图，说明plot这个函数，在只给它一个向量的时候，它会把向量当做纵坐标，然后自动生成一个横坐标，这个横坐标刚好是k1向量的下标。
boxplot(k1~k2)
##箱线图，给它提供一个数值型向量和一个有重复值的字符型向量，就可以作图。
##课后试着搜索boxplot表达什么意思
把随机函数生成的数永远为一组数据：用随机函数生成向量，后运行set.seed(10086)
b <- rnorm(n=10,mean=0,sd=18);b
#[1] -10.751826 6.361791 -1.405914 13.091608 -5.657507
#[6] 17.566128 -40.944886 28.116723 14.500479 -5.465456
set.seed(10086)
b <- rnorm(n=10,mean=0,sd=18);b
#[1] 9.896206 -49.409265 10.196236 8.738621 -11.273729
#[6] 4.586289 14.487501 19.459153 5.822140 -6.640898
b <- rnorm(n=10,mean=0,sd=18);b
#[1] 37.899977 44.838591 -32.795516 -3.927949 10.522299
# [6] -29.136604 25.589576 -14.547134 -16.036787 3.983615
set.seed(10086)
b <- rnorm(n=10,mean=0,sd=18);b
#[1] 9.896206 -49.409265 10.196236 8.738621 -11.273729
#[6] 4.586289 14.487501 19.459153 5.822140 -6.640898
##在随机函数代码前加上set.seed(10086)，每次运行随机函数生成向量前都要加这句代码
1.7 两个非常重要的函数
?order
?match
x[match(y,x)]和x[order(x)]
1.7.1 order()函数
排序，如何调整元素顺序
x <- c("A","B","C","D","E");x
#[1] "A" "B" "C" "D" "E"
x[c(2, 4, 5, 1, 3)]
#[1] "B" "D" "E" "A" "C"
##调下标顺序
- sort-排序函数
scores = c(100,59,73,95,45);scores
#[1] 100 59 73 95 45
sort(score)
#[1] 45 59 73 95 100
##sort排序是默认升序，sort(score)与scores的关系，内容相同但是顺序不同的向量。
##用向量取子集的方式，怎么得到相同(sort(score))的结果。
scores[c(5,2,3,4,1)]
#[1] 45 59 73 95 100
##用下标的方法对向量scores操作得到与sort(score)相同的结果，排序
order(scores)
#[1] 5 2 3 4 1
##数量少用眼睛可以数出来下标，对于数量多，就用order()函数
结论：sort(x)等于x[order(x)]，背诵下来
x = c(100,59,73,95,45);x
#[1] 100 59 73 95 45
sort(x)
#[1] 45 59 73 95 100
##给向量x的元素从小到大排序
order(x)
##[1] 5 2 3 4 1
##给向量元素从小到大排序，但返回是元素的下标。
x[order(x)]
#[1] 45 59 73 95 100
##x[],向量x取子集，按order(x)给的坐标取子集
sort(x) == x[order(x)]
#[1] TRUE TRUE TRUE TRUE TRUE
- order函数有什么用？
scores = c(100,59,73,95,45);scores
#scores依次属于以下几个小朋友
kids = c("jimmy","nicker","Damon","Sophie","tony")
#如何按照分数从低到高给小朋友的名字排序？
kids[order(scores)]
#[1] "tony" "nicker" "Damon" "Sophie" "jimmy"
##排分数用sort函数，排名字用order函数，名字排序order不能换成sort
##scores和kids并没有默认为统一的，主观规定两个向量的元素内容对应写
两个向量没有做关联的操作，可以用order函数排序对应信息
1.7.2 match()函数
向量匹配排序-match，match函数是连线用的
x <- c("A","B","C","D","E");x
#x[c(2, 4, 5, 1, 3)]
y <- c("B","D","E","A","C")
##x和y是内容相同，但顺序不同的两个向量。
match(y,x)
#[1] 2 4 5 1 3
##返回是x的下标，当x按照这组下标取子集时候就会变得和y一模一样的东西，为什么不要x=y？
##这么操作的目的是，当x按照y作为榜样/模版去调整自己的顺序去取子集的时候，它可以取得和y一模一样。
x[match(y,x)]
#[1] "B" "D" "E" "A" "C"
x[match(y,x)]的以后用法：以y作为模版，给x调顺序。
match：谁在中括号外面，谁就在后面，x[match(y,x)]，以y作为模板，用x作为原料去取子集，按照一个顺序取子集，取出来的子集和y一样。
需要背诵的两个用法：x[match(y,x)]和x[order(x)]
- match有大用处
练习题：在以下x和y表格里如何将y的列名一对一替换为ID
##方法1
load('matchtest.Rdata')
a=colnames(y)
b=x$file_name
a[match(b,a)]
b[match(a,b)]
identical(b[match(a,b)],a)
##identical()函数判断两个数据的结构，类型，顺序是否相同
##返回TRUE就是一样的。
##找到b对应的每个ID，b=x$file_name在与ID同在一个数据框，有对应的关系，可以通过下标去找
x$ID[match(a,b)]
##获得与调整之后，也就是a一一对应的ID
colnames(y)=x$ID[match(a,b)]
##方法2
rm(list = ls())
load('matchtest.Rdata')
a=colnames(y)
b=x$file_name
a[match(b,a)]
y2=y[,match(b,a)]
#列的顺序和列名一一对应，y的列和a是对应的，
identical(colnames(y2),b)
x$ID
colnames(y2)=x$ID
1.8 补充知识：中文注释出现乱码
切换Rproj的时候出现弹窗：是否将工作空间保存到.Rdata？
答案是：不保存，之前单独保存好脚本和图片，这里出现的提示是否临时保存，不需要保存。
.Rdata？是什么：
以.开头的文件，通常用作配置，系统默认隐藏这类文件
.Rdata是保存工作空间的默认文件
.History是保存历史命令的默认文件
如果打开Rstudio特别慢，可能是因为.Rdata保存了很大的变量，可以找到.Rdata文件将其删除。
在Rproj右下角打开脚本时，编辑器脚本的中文注释出现乱码，解决如下：
说明
以上内容是听生信技能树小洁老师的R语言线上课，根据自己的理解记录下来，小洁老师授课非常细心，对不同水平的同学都照顾到，并且补充很多技巧以及注意事项。
之前学习过R语言，那时对向量认识不够深，也没有重视，数据框的列单独拿出来就是一个向量。认真听小洁老师的讲解以及最近跑几个GEO数据集发现学会对向量的熟练操作以及熟练一些重要的函数，在实战过程中会顺利些。