array与循环
array
数组是矩阵的集合
array(data = NA, dim = length(data), dimnames = NULL)
维度：二维或以上
依据维度，“[]”和“,”合作进行索引[2,3,4][]中的三个数字分别代表几行，几列，几层。
循环：apply(z,1,mean)apply(z,2,mean)apply(z,3,mean)1、2、3分别代表行、列、层三个维度。（apply循环只能对全部行，全部列，全部层进行操作）
apply循环
形式：apply(X, MARGIN, FUN, ...)
运用于规整的格式：array和dataframe
可以从维度方向考虑
apply(x,mar,FUN)
lapply与sapply循环（对list进行操作）
list无法给定维度，所以list循环要用lapply与sapply
lapply(X, FUN, ...)
sapply(X, FUN, ..., simplify = TRUE, USE.NAMES = TRUE)
作用于list，即对list的每一个数据结构进行操作，将每一个数据结构当做一个元素
从输入输出格式进行考虑
x <- list(1:10,2:8,5:7)
lapply返回结果为list
> x <- list(1:10,2:8,5:7)
> lapply(x,mean)###将list看做一个向量，lapply对list中的每一个元素（即数据结构）进行操作。[[1]]即为第一个元素。
[[1]]
[1] 5.5
[[2]]
[1] 5
[[3]]
[1] 6
> class(lapply(x,mean))
[1] "list"
> mean(x[[2]])
[1] 5
>## length(x)
> ###for循环
> #for()自己补上
> unlist(lapply(x,mean))###unlist将list转换为向量
[1] 5.5 5.0 6.0
用for循环操作
> ###for循环
> for (i in 1:length(x)) {
+ print(mean(x[[i]]))
+ }
[1] 5.5
[1] 5
[1] 6
sapply返回结果默认为矩阵
> y<- sapply(x,fivenum)
> class(y)
[1] "matrix"
lapply与sapply的区别，就在于返回形式不一样，若在sapply中设置‘simplify = FALSE’则与lapply结果一致
sapply(x,mean,simplify = FALSE)
function()函数
function.name<-function(x){ }
> y <- function(x){
+ x+1-10
+ }
function.name 为函数的名称，如‘y’、‘f’等；
x为指定参数，可以随意指定，如‘x’、‘b’、‘c’，指定参数为什么，在后面使用函数时出现指定参数为什么；
{ }为指定具体操作。
apply（有维度）和lapply的区别
apply对有维度的数据结构进行操作（矩阵和数据框），lapply与sapply对没有维度的数据结构进行操作（列表和向量）。
lapply还可对向量操作，每个元素即为单个数值/字符。
lapply不仅生成数值，还可以创建文件。
因子（factor）
组成
level:相当于通讯录中的分组，“家人”、“朋友”、“同学”；
基本元素
image.png
正如上图，level是元素的unique
◆factor（ ）###创建一个factor
◆无序因子和有序因子-ordered
◆factor的意义：用于分组计算
◆可直接由label对因子进行更改
◆所有factor必须是level中的元素
◆因子顺序可决定绘图顺序
> topleft1 <- factor(topleft,ordered = TRUE)###创建factor
> topleft1
[1] black red green blue blue red white black blue blue white
[12] red blue white green blue black red green white orange red
[23] blue green white white white red blue white green red red
[34] white blue blue blue red gold green red white blue blue
[45] white white red white green blue gold red blue green green
[56] white white white white blue blue red green red black black
[67] red white blue white red red blue red red black black
[78] blue white red blue orange red green red green blue green
[89] red gold white black red black red green red red green
[100] blue green blue red white black blue red green white blue
[111] green red green blue red red white red green blue blue
[122] red white white blue orange green white blue red red red
[133] white white red red red blue white green red white blue
[144] red white green green green red green red blue blue orange
[155] white red red gold white green blue blue red green blue
[166] blue red red blue green red red white white red red
[177] white white red black white white white blue red black gold
[188] gold red blue blue green green green
Levels: black < blue < gold < green < orange < red < white###显示了其level
> class(topleft1)
[1] "ordered" "factor" ###有序的因子
> levels(topleft1)###查看level
[1] "black" "blue" "gold" "green" "orange" "red" "white"
设定level
把原来的level顺序打乱
> levels <- sample(levels(topleft1),length(levels(topleft1)))
> levels
[1] "green" "gold" "black" "red" "blue" "white" "orange"
sample()随机抽样函数
> topleft2 <- factor(topleft,levels=levels,ordered = TRUE)##顺序代表一定意义
> levels(topleft2)
[1] "green" "gold" "black" "red" "blue" "white" "orange"
在因子中添加元素
必须要先在level中添加，才能在factor中添加元素；添加的元素若不在level中会生成NA。
> levels(topleft3)<- c(levels(topleft3),'pink')
> topleft3[1] <- 'pink'
删掉冗余的level
如果对某一因子进行改变，导致某一level没了，则可通过droplevels这一函数删除这一level,而非直接对level操作。
> topleft3[1] <- 'black'
> unique(topleft3)
[1] black red green blue white orange gold
Levels: black blue gold green orange red white pink
> topleft3<- droplevels(topleft3)
> levels(topleft3)
[1] "black" "blue" "gold" "green" "orange" "red" "white"
通过对label进行设定，可直接更改factor
> topleft4 <- factor(topleft,levels=levels,labels=seq(1,length(levels),1))###设置levels
> topleft4
[1] 3 4 1 5 5 4 6 3 5 5 6 4 5 6 1 5 3 4 1 6 7 4 5 1 6 6 6 4 5 6 1 4 4 6 5 5 5 4 2 1 4
[42] 6 5 5 6 6 4 6 1 5 2 4 5 1 1 6 6 6 6 5 5 4 1 4 3 3 4 6 5 6 4 4 5 4 4 3 3 5 6 4 5 7
[83] 4 1 4 1 5 1 4 2 6 3 4 3 4 1 4 4 1 5 1 5 4 6 3 5 4 1 6 5 1 4 1 5 4 4 6 4 1 5 5 4 6
[124] 6 5 7 1 6 5 4 4 4 6 6 4 4 4 5 6 1 4 6 5 4 6 1 1 1 4 1 4 5 5 7 6 4 4 2 6 1 5 5 4 1
[165] 5 5 4 4 5 1 4 4 6 6 4 4 6 6 4 3 6 6 6 5 4 3 2 2 4 5 5 1 1 1
Levels: 1 2 3 4 5 6 7
> levels(topleft4)
[1] "1" "2" "3" "4" "5" "6" "7"
拆分与循环（split与tapply）
◆分组计算，结合因子使用(将因子拆分成不同小组，分组计算)
◆因子与待拆分内容应长度一致
◆不同因子用list进行承载
拆分（split）
split(x, f, drop = FALSE, ...)
◆分组，结合因子f使用
◆因子f与待拆分x内容应长度一致
◆不同因子用list进行承载
◆drop表示，是（TRUE）否（FALSE）弃掉不存在的level
> total_s<- split(flag,flag$topleft)
> class(flag$topleft)
[1] "character"
flag是待分组数据，flag$topleft是分组依据,split函数会自动把分组依据转化为factor
> class(total_s)返回结果为列表
[1] "list"
> length(total_s)
[1] 7
返回结果为列表（每个分组中各元素数量不一致）
split还可以这样用，可以是独立的长度一致的数据（不一定非得是同一数据文件里的列）
> split(flag$landmass,flag$topleft)
> split(1:10,rep(1:2,times=5))
$`1`
[1] 1 3 5 7 9
$`2`
[1] 2 4 6 8 10
list将多个分类因子结合起来（即依据多个因子对数据进行分组，如依据性别和年龄，将性别和年龄组合起来，“男性20岁以下的”）
> unique(flag$zone)
[1] 1 3 2 4
> unique(flag$topleft)
[1] "black" "red" "green" "blue" "white" "orange" "gold"
> split(flag$landmass,list(flag$zone,flag$topleft))
$`1.black`
[1] 5 3 3 3 5 4 4
$`2.black`
[1] 4 6
$`3.black`
integer(0)
$`4.black`
[1] 1 2 1
$`1.blue`
[1] 3 5 4 4 3 3 5 3 5 6 6 5 5 6 3 4 3 5 3
$`2.blue`
[1] 4 6 6 4
$`3.blue`
[1] 6 2 2 2 6
$`4.blue`
[1] 1 1 1 1 1 1 2 1 1 3 4 1 1 1 1
unlist将列表转化为向量
> split(1:10,rep(c(1,2),times=5))
$`1`
[1] 1 3 5 7 9
$`2`
[1] 2 4 6 8 10
> unlist(split(1:10,rep(c(1,2),times=5)),use.names = F)
[1] 1 3 5 7 9 2 4 6 8 10
> unlist(split(1:10,rep(c(1,2),times=5)))
11 12 13 14 15 21 22 23 24 25
1 3 5 7 9 2 4 6 8 10
tapply函数，在split基础上兼容了函数的操作(在分组内容里进行)
> tapply(flag$landmass,flag$topleft,mean)
black blue gold green orange red white
3.416667 3.255814 2.500000 3.625000 4.500000 3.982143 3.414634
> tapply(flag$landmass,flag$topleft,fivenum)
$black
[1] 1.0 2.5 3.5 4.5 6.0
$blue
[1] 1 1 3 5 6
$gold
[1] 1 2 2 3 5
$green
[1] 1.0 3.5 4.0 4.0 5.0
$orange
[1] 4.0 4.0 4.5 5.0 5.0
$red
[1] 1 3 4 5 6
$white
[1] 1 2 3 5 6
while
break 跳出当前循环，传递至该循环的上一级（无上一级即直接跳出）；
next 停止执行当前循环，执行下一次循环；
break 和 next 均嵌套于循环之内；
熟悉会产生什么结果，创建相应大小的数据结构(向量或矩阵)
> i <- 1### i 代表的是个数
> #####熟悉会产生什么结果，创建相应大小的数据结构
> tmp <- c()##创建一个向量
> tmp <- matrix(NA,20,10)###创建相应行列的矩阵
> while (i <=6) {
+ tmp[i]<- letters[i]
+ i = i+1####要有这种设置，才会对i产生改变，才不会是死循环
+ }
break 满足条件跳出循环
> a<-while (i <= 6) {
+ if (i==4)
+ print(letters[i])
+ i = i+1
+ }
[1] "a"
[1] "b"
[1] "c"
next 挑出当前执行下一数值操作
> x <- 1:5
> for (val in x) {
+ if (val == 3){
+ next
+ }
+ print(val)
+ }
[1] 1
[1] 2
[1] 4
[1] 5
ifelse
if(cond) expr
if(cond) cons.expr else alt.expr 处理的是一个逻辑值，得到一个输出
ifelse(cond, cons.expr, alt.expr) 处理一串逻辑值，得到一串输出
if(cond) cons.expr else alt.expr 处理的是一个逻辑值，得到一个输出
> a <- 1:10
> if (a<5) {
+ print('small')
+ }else if (a>5&a<=7) {
+ print('medium')
+ }else {
+ print('big')}###只对第一个逻辑值起作用
[1] "small"
Warning message:
In if (a < 5) { :
the condition has length > 1 and only the first element will be used
felse(cond, cons.expr, alt.expr) 处理一串逻辑值，得到一串输出
> ifelse(a<5,'small','big')
[1] "small" "small" "small" "small" "big" "big" "big" "big" "big" "big"
生成1:20的数据，使用ifelse循环，x<=8输出‘small’，8<x<=15输出‘medium’，15<x<=20输出“big”
> tmp <- 1:20
> b <- ifelse(tmp<=8,'small',ifelse(tmp<=15,'medium','big'))
> b
[1] "small" "small" "small" "small" "small" "small" "small" "small" "medium"
[10] "medium" "medium" "medium" "medium" "medium" "medium" "big" "big" "big"
[19] "big" "big"
数据处理
集合操作
setdiff(A,B)取A中有B中没有的
setdiff(B,A)取B中有A中没有的
排序
◆sort 直接返回排序结果
◆rank 返回向量中对应元素的秩(rank)即排名（返回默认为从小到大排序后的对应元素的排名）
◆order 返回的是升序或降序对应的排列，可作用于多个向量（位置）（返回默认为从小到大排序后对应元素在原来未排序之前的数据中的位置）
> tmp
[1] 5 6 8 4 2
> sort(tmp)###排序方式默认为从小到大
[1] 2 4 5 6 8
> rank(tmp)###原数据中各对应元素的排名
[1] 3 4 5 2 1
> order(tmp)###该元素按默认从小到大排序后在原数据中的位置
[1] 5 4 1 2 3
order中让其按降序排列的话就用“-”
order(-iris$Sepal.Length)###另类的设置方式
f<- sample(1:20,7)
sort(f)###返回的是排序后的数值
order(f)###返回的是，output中的数据应来源于input的哪个位置
rank(f)###返回的是input的排名
依据两个向量排序
>order(iris$Species,iris$Sepal.Length)###两个字段排序,以iris$Species进行排序，再在iris$Species范围内按从小到大或从大到小排序。
>order(iris$Species,-iris$Sepal.Length)###‘-’代表降序
如何生成按要求排序后的数据(索引+order)
> a<- iris[order(iris$Species,iris$Sepal.Length),]
> a
Sepal.Length Sepal.Width Petal.Length Petal.Width Species
14 4.3 3.0 1.1 0.1 setosa
9 4.4 2.9 1.4 0.2 setosa
39 4.4 3.0 1.3 0.2 setosa
43 4.4 3.2 1.3 0.2 setosa
42 4.5 2.3 1.3 0.3 setosa
4 4.6 3.1 1.5 0.2 setosa
7 4.6 3.4 1.4 0.3 setosa
23 4.6 3.6 1.0 0.2 setosa
48 4.6 3.2 1.4 0.2 setosa
3 4.7 3.2 1.3 0.2 setosa
30 4.7 3.2 1.6 0.2 setosa
12 4.8 3.4 1.6 0.2 setosa
13 4.8 3.0 1.4 0.1 setosa
rank
> rep(1,10)
[1] 1 1 1 1 1 1 1 1 1 1
> rank(rep(1,10),ties.method='average')###取rank的平均值
[1] 5.5 5.5 5.5 5.5 5.5 5.5 5.5 5.5 5.5 5.5
> rank(rep(1,10),ties.method='first')###按出场先后顺序
[1] 1 2 3 4 5 6 7 8 9 10
> rank(rep(1,10),ties.method='last')###按出场顺序逆序
[1] 10 9 8 7 6 5 4 3 2 1
> rank(rep(1,10),ties.method='min')###取最小的排序位置
[1] 1 1 1 1 1 1 1 1 1 1
字符操作
正则表达式
正则表达式(regular expression)描述了一种字符串匹配的模式（pattern），可以用来检查一个串是否含有某种子串，将匹配的子串替换或者从某个串中取出符合某个条件的子串等。
常用字符含义
a <- c('Hello','somebody',
'say','The',
'4 new','cars',
'parked','in','the',
'garage','oops','cat',' ')
grep('[^c]ar',a)###[^]取反
grep('[^c]ar',a,value = T)
grep('[^T]he',a,value = T)
grep('o',a,value = T)
grep('o{2}',a,value = T)###{}匹配次数设置
grep('oo',a,value = T)
grep('o{1,2}',a,value = T)
grep('s',a,value = T)
grep('s$',a,value = T)##前面字符位于字符尾部
grep('t',a,value = T)
grep('^t',a,value = T)###后面字符位于字符首位
grep('\\d',a,value = T)###\d表示数字
grep('\\D',a,value = T)###\D表示非数字
grep('\\w',a,value = T)###\w表示字母、数字、下划线[A-Za-z0-9_]
grep('\\W',a,value = T)###\W表示匹配非字母、数字、下划线
grep('\\s',a,value = T)###\s匹配空白字符
grep('\\S',a,value = T)###\S匹配非空白字符
字符操作
grep返回位置
grepl返回逻辑值
gsub进行全局替换（global）
sub只替换第一个
nchar 进行字符的长度统计
substr 进行字符内容的替换
strsplit 字符拆分
✓ pattern 正则表达式代表的内容或字符串
✓ x 字符向量
✓ replacement 用来替换的内容
✓ value=T 返回匹配结果，否则返回位置信息
✓ fixed pattern非正则表达式内容
✓ invert 返回不匹配的部分
`
