2019-07-21日学习总结

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

> 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"   

数据处理

集合操作

image.png

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 返回不匹配的部分

`