R语言基础汇总

%>%是管道符的意思，把左边的输出（不包括 <-之前的）当成右边的输入。

怎么分辨是列表，还是向量，还是数组，还是矩阵，还是数据框？

数组和矩阵和数据框有维度，dim()一下有结果。
向量、列表dim()一下都是NULL,没结果。

R语言里编写函数的时候，返回值要带括号。要写return(...)，少了括号会报错。

对样本数据进行标准化处理并转化为数据框的格式存储

df = data.frame(scale(df[,2:7]))

发现Rstudio 和vscode的一些功能是一样的：

都可以shift + alt + 上下：快速复制粘贴
alt + 上下：移动行
ctrl + alt + 上下：多重光标

快速注释：

首先选中要注释掉的行，然后按Ctrl+shift+C ，这样就注释掉了。

查看当前版本

sessionInfo()

查看包安装路径

.libPaths()
一篇关于包的博客

更新R语言

library(installr)
updateR()

R的开源社区和论坛

COS中文论坛统计之都旗下的论坛网站(d.cosx.org),它和其主站(cosx.org)一起，是一个致力于推广与应用统计学知识的网站和社区。

查看帮助文件

1 help("t.test")
2 ?t.test
3 help.search("t.test")
4 apropos("t.test")
5 RGui>Help>Html help
6 查看R包pdf手册

三个有用系统命令

getwd() 显示工作目录
setwd() 设定工作目录
list.files() 列出目录或文件夹下的文件

程序包和功能函数的演示

demo( ) 显示R的基本程序包
example( ) 显示在线帮助的例子
example(barplot)

命令保存

可以把若干行命令保存在一个文本文件（比如Eg3.R）中，然后用source函数来运行整个文件： source("E:/R demo/Chapter1-Eg3.R")

简单统计量

sum, mean, var, sd, min, max, range, median, IQR（四分位间距）等为统计量， sort，order，rank与排序有关，其它还有ave，fivenum，mad，quantile， stem等

优先级的问题

-1:1/0 当中/是优先级靠后的操作。相当于c(-1,0,1)/0

画图一些参数：

x1<-0:10
x2<-x1*2*pi/10
y=sin(x2)
plot(x2,y,type='l')
plot(x2,y,type='s',main='Practice',sub='Please practice more',xlab='x axis',ylab = 'y axis')

修改列名：

names(df) <- c("male", "female", "unknown")

访问行名和列名

对于矩阵，我们可以使用属性rownames和colnames来访问行名和列名。
我们也可以先定义矩阵x然后再为dimnames(x)赋值：

x <- matrix(1:6, ncol=2,byrow=T) 
rownames(x) <- c("第一行", "第二行", "第三行") 
colnames(x) <- c("第一列", "第二列") 
或者用： 
dimnames(x)=list(c ("第一行", "第二行", "第三行"), c("第一列", "第二列") )

常量：

数值型数据：1.2345e30
复数常量就用3.5-2.1i
缺失值：NA（Not Available）

任何数与缺失值的运算结果仍为缺失值。

是否含有缺失值：

is.na(c(1, NA, 3)) 
[1] FALSE TRUE FALSE

NaN表示不确定的数
• NaN属于NA的一种
• NA不是NaN
注意下面例子的比较 :

x<-c(0/1, 0/0, 1/0, NA); x 
[1] 0 NaN Inf NA 
is.nan(x) 
[1] FALSE TRUE FALSE FALSE 
is.na(x) 
[1] FALSE TRUE FALSE TRUE 
is.finite(x) 
[1] TRUE FALSE FALSE FALSE 
is.infinite(x) 
[1] FALSE FALSE TRUE FALSE

assign赋值变量：

assign("x1", c(1, 2))

运算：

两个向量的运算是对应分量的运算，一般要求它们的长度相同，否则，短的会被循环使用
%/%表示整数除法（比如5 %/% 3为1）
%%表示求余数（如5 %% 3为2）
如果求var(x)而x是矩阵，则结果为样本协方差阵。 (行向量为观测值，列为指标变量)
负数开根号要补充成复数形式：

sqrt(-4) 
[1] NaN （not a number） warning:…… 
sqrt(-4+0i)
[1] 2i

向量排序

sort(x)返回x的元素从小到大排序的结果向量。
x=c(2,10,6,8,4,5); sort(x) [1] 2 4 5 6 8 10  order(x)返回使得x从小到大排列的元素下标向量(x[order(x)]等效于sort(x))。

order(x)
[1] 1 5 6 3 4 2 
x[order(x)] 
[1] 2 4 5 6 8 10

等差数列函数:

seq(from=0, to=2, by=0.7)
seq(from=10, length=5)

rep(x,3)
rep(x, each=3)

初始化向量：

此外numeric(n)可以产生一个长度为n的零向量（numeric(n)是一个很好用的外部存储器）

逻辑判断：

判断一个逻辑向量是否都为真值的函数是all，如： 
all(log(10*x) > x) 
[1] FALSE 判断是否其中有真值的函数是any，如： 
any(log(10*x) > x)

逻辑值强制转换为整数值

age=c(89,20,10,66);  c('young', 'old')[(age>65)+1]
[1] "old" "young" "young" "old"
当年龄大于65时age>65等于TRUE，加1则把TRUE转换为数值型的1，
结果得2，于是返回第二个下标处的“old”。否则等于0+1 下标处的“young”。

paste函数

paste函数用来把它的自变量连成一个字符串，中间用空格分开

paste(c("X", "Y"), "=", 1:4)
"X = 1" "Y = 2" "X = 3" "Y = 4"   短的重复使用匹配多的

paste('result.', 1:5, sep= "")
"result.1" "result.2" "result.3" "result.4" "result.5"  取消多余的空格

paste(c('a', 'b'), collapse='.')  采用特定连接符
'a.b'

paste("Today is", date())
[1] "Today is Wed Sep 27 19:20:35 2017"  

for(j in 1:length(scope)) {
  print(paste("j=",j,sep='')) 记录循环到哪里了
}

filename=paste("Simulation Results for dataset", j, ".xls", sep='') 快速生成文件名
write.table(res,filename,row.names=F,col.names=F,sep='\t')  写到文件里

复数向量：

Re( )计算实部，Im( )计算虚部， Mod( ) 计算复数模，Arg( )计算复数幅角。

complex(2,4,6) 
[1] 4+6i 4+6i

取负整数值的下标向量:

v为一个向量，取值在－length(x)到－1之间，表示扣除相应位置的元素。例如:

x[-(1:2)] 
[1] 6.25
x[-3] 
[1] 1.00 125.00

要把向量所有元素赋为一个相同的值而又不想改变其长度，

可以用x[]的写法：

x[ ] = 0

R的对象还有一种特殊的空值型(null)

比较下面的两个命令： 
a=NA; a=c(a, 1:5); a 
[1] NA 1 2 3 4 5
 a=NULL; a=c(a, 1:5); a 
[1] 1 2 3 4 5

NULL变量也是常用的外部存储器，当存储变量的容量大小未知时，可以用NULL变量在外部占位存储:

goodID=NULL
for(i in 1:length(ID)) {
  if(score[i]>=90) {
    goodID=c(goodID,i)
  }
}
goodID=ID[score>=90] （等价于这个）

固有属性：

R的对象有两个基本的属性：类型属性(mode)和长度属性(length)。
长度为零的向量 numeric( ) 或者 numeric(0) character( ) 或者 character(0)

强制转换对象的类型

x<-as.character(x); x 
[1] “1” “4” “6.25” 
x<-as.numeric(x); x 
[1] 1.00 4.00 6.25

特有属性：attributes()/attr( )

attributes()返回对象除了mode和length以外的特有属性，如果没有特有属性，则返回NULL

fruit<-c(apple=1, orange=2); fruit 
[1] apple orange 
    1      2 

mode(fruit) 
[1] "numeric" 

attributes (fruit) 
$ names 
[1] "apple" "orange" 

attributes (x)    没有特有属性
[1] NULL

attr( )可以对对象的特有属性进行赋值

attr(fruit, "names") <- c("peanut", "almond"); 
fruit 
[1] peanut almond 
    1       2 

attr(fruit, "type") <- "nut"; 
fruit; 
[1] peanut almond 
     1     2 
attr(,"type") 
[1] "nut" 

attributes(fruit) 
$ names 
[1] "peanut" "almond" 
$ type 
[1] "nut"

多维数组 (array) 和矩阵(matrix)

数组(array): 带多个下标的类型相同的元素的集合，

array(x, dim=length(x), dimnames=NULL)

向量只有定义了维数向量(dim属性)后才能被看作是数组
维数向量的每一个元素指定了该下标的上界，下标的下界总为1
数组元素的排列次序缺省情况下是采用第一下标变化最快，最后下标变化最慢的顺序存放的；对于矩阵（二维数组）则是按列存放。

a=1:24  
is.vector(a);  T
is.array(a);   F
dim(a)<-c(6,4);  对a赋予dim以后，a也是数组了，按列的顺序

z<- array(x, dim=c(2,2), dimnames=list(c("row1","row2"), c("col1", "col2")));

函数matrix()：用于构造二维数组，即矩阵

matrix(data = NA, nrow = 1, ncol = 1, byrow = FALSE, dimnames = NULL)

在有数据的情况下只需指定行数或列数之一。指定的数据个数允许少于所需的数据个数，这时循环使用提供的数据。例如：

b <- matrix(1, nrow=3, ncol=4) #生成3行4列 的矩阵, 元素都是1。 
b<-matrix(c(1, 3), nrow=3, ncol=4); 
    [,1] [,2] [,3] [,4] 
[1,] 1 3 1 3 
[2,] 3 1 3 1 
[3,] 1 3 1 3

数组四则运算

解释为数组对应元素的四则运算
形状不一致的向量和数组也可以进行四则运算，一般的规则是数组的数据向量对应元素进行运算，把短的循环使用来与长的匹配，并尽可能保留共同的数组属性
数组的外积a%o%b —— b%o%a==t(a%o%b)（dim(d)=c(dim(a), dim(b))）

外积运算：

outer(a, b, f)是一个一般性的外积函数，它可以把a的任一个元素与b的任意一个元素搭配起来作为f的自变量计算得到新的元素值，
d <- outer(a, b, '*') 注意，外积是两个元素相乘的情况。函数当然也可以是加、减、除，或其它一般函数。比如outer(a,b,"+")。当函数为乘积时可以省略不写。

矩阵运算

函数t(A)返回矩阵A的转置、nrow(A)为矩阵A的行数，ncol(A)为矩阵A的列数。
要进行矩阵乘法，使用运算符%*%
内积最好还是用crossprod(x)来计算，要表示nn阵，可以用“cbind(x) %% x”或“x %*% rbind(x) ”。
函数crossprod(X, Y)表示一般的交叉乘积（内积），即X的每一列与Y的每一列的内积组成的矩阵（X和Y的行数必须相同）
其它矩阵运算还有solve(A,b)解线性方程组，solve(A)求方阵 A的逆矩阵，svd( )计算奇异值分解，qr( )计算QR分解， eigen( )计算特征向量和特征值

矩阵拉直为向量：

as.vector(a)
c(A,B)表示把A按列次序拉直为向量并与把B按列次序拉直为向量的结果连接起来。一定注意拉直时是按列次序拉直的。

画三维图：

x <- seq(-2, 2, length=20) 
y <- seq(-pi, pi, length=20) 
f <- function(x, y) cos(y)/(1+x^2)
z <- outer(x, y, f) 
persp(x,y,z)

table()函数来计算每一个值的出现次数（频数）

f <- table(y);
plot(as.numeric(names(f)), f, type="h", xlab="行列式值", ylab="频数")
plot(as.numeric(names(f)),f/10000,type='h',xlab='行列式值',ylab='频率')

apply函数

apply(X, MARGIN, FUN, ...)

其中X为一个数组，MARGIN是固定哪些维不变，FUN是用来计算的函数。
例如，设a是n*m 矩阵，则apply(a, 1, sum)的意义是对a的各行求和（保留第一维即第一个下标不变），结果是一个长度为n的向量（与第一维长度相同），
而apply(a, 2, sum)意义是对a的各列求和，结果是一个长度为m的向量（与第二维长度相同）

数组的广义转置

aperm(a, perm)函数把数组a的各维按perm中指定的新次序重新排列。
a <- array(1:24, dim=c(2,3,4)) #2行3列4层
b <- aperm(a, c(2, 3, 1)) #3行4列2层
结果a的第2维变成了b的第1维，a的第3维变成了b的第2维，a的第1维变成了b的第3维
对于矩阵a，aperm(a, c(2,1))恰好是矩阵转置。对于矩阵转置可以简单地用t(a)表示。

因子：

函数factor( )用来把一个向量编码成为一个因子。

factor(x, levels = sort(unique(x), na.last = TRUE), labels, exclude = NA, ordered = FALSE)

可以用is.factor()检验对象是否因子，用as.factor()把一个向量转换成一个因子。

可以自行指定各离散取值水平（levels），不指定时由x的不同值来求得。
• labels可以用来指定各水平的标签，不指定时用各离散取值的对应字符串。
• exclude参数用来指定要转换为缺失值（NA）的元素值集合。
• ordered取真值时表示因子水平（Levels）是有次序的

x<-c(4, 2, 2, 3); 
y<- factor(x); y; 
[1] 4 2 2 3 
Levels: 2 3 4 

factor (x, ordered=T); 
[1] 4 2 2 3 
Levels: 2 < 3 <4 # Levels 会有序排列 

factor(x, label=c("red", "black","white")) 
[1] white red red black # red代表2，black代表3，white代表4 Levels: red black white 

factor(x, label=c("red","black","white"), ordered=T); 
[1] white red red black 
Levels: red < black < white 

factor(x, exclude=3, ordered=T); 
[1] 4 2 2  
Levels: 2 < 4

x<- c(1,0,1,1,0); 
y=factor(x, levels=sort(unique(x), decreasing=T), labels=c("男", "女"), order=F); 
y

x<-c(1,0,1,1,0,2);
y=factor(x, levels=c(1,0), labels=c("男", "女"), order=F) 
y

用函数levels()可以得到因子的水平
因子的基本统计是频数统计，用函数table()来计数。

sex = factor(c("男", "女", "男", "男", "女")) ; 
res.tab <- table(sex) ; 
res.tab
mode(res.tab);

交叉分类：

job=factor(c("teacher", "worker","worker", "worker","teacher"));
sex = factor(c("男", "女", "男", "男", "女"));
table(sex, job);

tapply() 分类统计：

因子可以用来作为另外的同长度变量的分类变量，使用tapply() 函数可以完成分类统计

sex = factor(c("男", "女", "男", "男", "女")) ; 
h <- c(165, 170, 168, 172, 159) 
tapply(h, sex, mean)； # 可以求按性别分类的身高平均值。
tapply(h, sex, mean, simplify=F)；

tapply (X, INDEX, FUN = NULL, ..., simplify = TRUE );
- X是向量
- INDEX是和X同等长度的因子
- FUN是要执行的函 数
- simplify取默认的TRUE，返回一个标量，取FALSE时， 返回一个列表list。

列表：

元素也由序号（下标）区分，但是各元素的类型可以是任意对象，不同元素不必是同一类型。元素本身允许是其它复杂数据类型，比如，列表的一个元素也允许是列表。
列表元素用列表名[[下标]]的格式引用。
列表不同于向量，我们每次只能引用一个元素，如rec[[1:2]]的用法是不允许的。
两重记号取出列表的一个元素，结果与该元素类型相同；一重括号，是列表的一个子列表

rec = list(name="李明", age=30, scores=c(85, 76, 90))
rec[1] 
$name 
[1] "李明" 

rec[[1]] 
[1] "李明" 

rec[2] 
$age 
[1] 30 

rec[[2]] 
[1] 30 

rec[3] 
$scores 
[1] 85 76 90 

rec[[3]] 
[1] 85 76 90 

rec[[3]][1:2] 
[1] 85 76 

mode(rec[1]) 
[1] " list " 

mode(rec[[1]])

几个列表可以用连接函数c( )连接起来，结果仍为一个列表，其元素为各自变量的列表元素

5. 字符数统计和字符翻译

nchar()这个函数简单，统计向量中每个元素的字符个数
tolower()和toupper()可以进行大小写字母的转换
chartr()把字符串里的元素，按要求进行转换

chartr("Tt", "Uu", DNA) # 把DNA序列里面的“T”变成“U”、“t”变成“u”

拆分字符串用strsplit()函数,strsplit得到的结果是列表，后面的处理要调用列表

strsplit(x, split, fixed = FALSE, perl = FALSE, useBytes = FALSE)
- 参数x为字串向量，每个元素都将单独进行拆分。 参数split为拆分位 置的字串向量，默认为正则表达式匹配（fixed=FALSE）。如果你没 接触过正则表达式，设置fixed=TRUE，表示使用普通文本匹配或正 则表达式的精确匹配。普通文本的运算速度快
- perl=TRUE/FALSE的设置和perl语言版本有关，如果正则表达式很长， 正确设置表达式并且使用perl=TRUE可以提高运算速度。
- 参数useBytes设置是否逐个字节进行匹配，默认为FALSE，即按字符 而不是字节进行匹配。

text <- "Hello Adam!\nHello Ava!" 
strsplit(text, " ")
strsplit(text, "\\s") # \s是正则表达式的语法，这里表示空白字符，不含换行 符\n
strsplit(text, "")

6. 程序设计

R是一个表达式语言(expression language)

其任何一个语句都可以看成是一个表达式。
表达式之间以分号分隔或用换行分隔。
表达式可以续行，只要前一行不是完整表达式，则下一行为上一行的继续。

for语句：

for (name in values) {expressions}
for ( i in 1:100){ sum <- sum+i; i <- i+1; }

8.统计分析举例

线性回归模型：
lm()函数的返回值叫做模型拟合结果对象，本质上是一个列表，有model 、coefficients、residuals等成员。lm()的结果显示十分简单，为了获得更多的拟合信息，可以使用对lm类对象有特殊操作的通用函数，这些函数包括：

add1 coef effects kappa predict residuals alias deviance family labels print summary anova drop1 formula plot proj

加号+或者减号－，表示在模型中加入一项或去掉一项，第一项前面如果是加号可以省略

anova(对象1，对象2) 把一个子模型与原模型比较，生成方差分析表。
coefficients(对象) 返回回归系数（矩阵）。可简写为 coef(对象)。
deviance(对象) 返回残差平方和，如有权重则加权。 formula(对象) 返回模型公式。
plot(对象) 生成两张图，一张是因变量对拟合值的图形，一张是残差绝对值对拟合值的图形。
predict(对象, newdata=数据框) predict.gam(对象, newdata=数据框) 有了模型拟合结果后对新数据进行预报。指定的新数据必须与建模时用的数据具有相同的变量结构。函数结构为对数据框中每一观测的因变量预报结果（为向量或矩阵）。
predict.gam()与predict()作用相同但适用性更广，可应用于lm、glm和 gam的拟合结果。比如，当多项式基函数用了正交多项式时，加入了新数据导致正交多项式基函数改变，用predict.gam() 函数可以避免由此引起的偏差 print(对象) 简单显示模型拟合结果。一般不用 print()而直接键入对象名来显示。
residuals(对象) 返回模型残差（矩阵），若有权重则适当加权。可简写为resid(对象)。
summary(对象) 可显示较详细的模型拟合结果。

print()函数

在非交互运行（程序）中应使用print()来输出。
• digits参数指定每个数输出的有效数字位数；
• quote 参数指定字符串输出时是否带两边的撇号；
• print.gap参数指定矩阵或数组输出时列之间的间距

print("ABC", quote=F); 
[1] ABC 
print("ABC", quote=T); 
[1] "ABC"

cat()函数:

也用来输出，但它可以把多个参数连接起来再输出（具有paste() 的功能）。例如：

i =1; 
cat("i = ", i, "\n")   #自己加上换行符“\n”，中间以空格连接

cat(c("AB", "C"), c("E", "F"), "\n", sep=",")  #自定义的分隔符
[1]AB,C,E,F
cat(c("AB", "C"), c("E", "F"), sep="-")  
[1] AB-C-E-F

cat("i = ", 1, "\n", file="d:\\result.txt") #指定file=文件名，把结果写到指定的文件中

cat("i = ", 2, "\n", file="d:\\result.txt", append=TRUE) #末尾附加

外部数据读取：

read.table() 函数或read.csv()函数读取外部txt或csv格式的文件。 txt文件，制表符间隔 csv文件，逗号间隔一些R程序包（如foreign）也提供了直接读取 Excel, SAS, dbf, Matlab, spss, systat, Minitab文件的函数

read.table(file, header=F, sep="", row.names, col.names, skip=0 …)

其中file是读取的文件名；
header表示第一行是否作为变量名，默认值是FALSE；
sep是数据分隔符，默认是空格（也有是制表符的），可以根据实际的文 档定义分隔符；
row.names和col.names分别定义了行和列的名字，可以缺省；
skip表示跳过的行数，默认是0；其他还有很多可设置的参数，详见帮助文件。

read.table(file=file.choose(),header=T) 可以弹出对话框，选择文件

- forbes <- read.table("d:/forbes.txt", header=T, sep='\t'); 
forbes 
is.data.frame(forbes); 
[1] TRUE

数据量较大时用read.table函数从外部txt文件读取第1步将Excel中的数据另存为.txt格式（制表符间隔）或.csv格式。第2步用read.table()或read.csv()函数将数据读入R工作空间，并赋值给一个对象。

scan( )函数的基本用法

直接从命令行输入数据 
x <- scan() 
1: 1 2 2 4: 
Read 3 items 
x
[1] 1 2 2

文档weight.txt 75.0 64.0 47.4 66.9 62.2 62.2 58.7 63.5 66.6 64.0 57.0 69.0 56.9 50.0 72.0
w<- scan("d:/weight.txt")

# 若数据有不同的属性，例如在"height and weight.txt"文档中，奇数列是height， 偶数列是weight 
h_w <- scan("d:/height and weight.txt", sep='\t', what=list(height=0, weight=0)) 
# 参数what是按行读入，一个height，一个weight顺序存放

读取文件：

读取SPSS数据文件
read.spss("目录/file.sav", to.data.frame=TRUE)
读取SAS数据文件
read.xport("目录/file.xpt") # 读入以后是个数据框
读取excel数据文件，R里面没有提供直接读取excel数据文件的命令，Microsoft的文件背后究竟是个什么谁也不知道。但可以调用RODBC这个package，我们不推荐。具体可以采用下面两种常用的方法：

将excel的内容复制粘贴到txt文档，用read.table( )读取；

另存为csv格式，用read.csv( )读取

写数据文件:

write.table (x, file="目录/file name.txt", sep="", append=FALSE, row.names=TRUE, col.names=TRUE);

data <- data.frame(Name=c("Li Lei", "Han Meimei", "Lucy"), Gender=c("M", "F", "F"), 
Age=c(30, 28, 29), Height=c(178, 160, 150), Weight=c(70, 55, 53)) ; 

write.table(data, "D:/New comer.txt", sep='\t');
write.csv(data, "D:/New comer.csv")

字符数统计

nchar()统计向量中每个元素的字符个数
注意这个函数和length函数的差别：nchar是向量元素的字符个数，而length是向量长度（向量元素的个数）

x <- c("Hellow", "World", "!")
nchar(x) 
[1] 6 5 1 

length("") 
[1] 1 

nchar("") 
[1] 0

大小写字母的转换

tolower()和toupper()可以进行大小写字母的转换

chartr()把字符串里的元素，按要求进行转换

DNA = "AtGCtttACC"
chartr("Tt", "Uu", DNA) # 把DNA序列里面的“T”变成“U”、“t”变成“u”
[1] "AuGCuuuACC"

字符串拆分

strsplit()得到的结果是列表。

strsplit(x, split, fixed = FALSE, perl = FALSE, useBytes = FALSE)

- 参数x为字串向量，每个元素都将单独进行拆分。 参数split为拆分位 置的字串向量，默认为正则表达式匹配（fixed=FALSE）。如果你没 接触过正则表达式，设置fixed=TRUE，表示使用普通文本匹配或正 则表达式的精确匹配。普通文本的运算速度快
- perl=TRUE/FALSE的设置和perl语言版本有关，如果正则表达式很长， 正确设置表达式并且使用perl=TRUE可以提高运算速度。
- 参数useBytes设置是否逐个字节进行匹配，默认为FALSE，即按字符 而不是字节进行匹配。

text <- "Hello Adam!\nHello Ava!" 
strsplit(text, " ")  # strsplit得到的结果是列表，后面的处理要调用列表
[[1]] 
[1] "Hello" "Adam!\nHello" "Ava!"

strsplit(text, "\\s") # \s是正则表达式的语法，这里表示空白字符，不含换行符\n
[[1]] 
[1] "Hello" "Adam!" "Hello" "Ava!"

strsplit(text, "") # 第二参数长度为0，得到一个一个的字符
[[1]] 
[1] "H" "e" "l" "l" "o" " " "A" "d" "a" "m" "!" "\n" "H" "e" 
[15] "l" "l" "o" " " "A" "v" "a" "!"

字符串查询

grep()和grepl()

grep(pattern, x, ignore.case = FALSE, ...) grepl(pattern, x, ignore.case = FALSE, ...)

- 参数pattern是要匹配的类型。参数x是进行操作的字符串向量。
- grep仅返 回匹配项的下标，
- grepl返回所有的查询结果，并用逻辑向量表示 有没有找到匹配

用grep()和grepl()查找exe文件

files <- list.files("c:/windows") # 列出指定盘符下的所有文件 
grep("*.exe", files); 
[1] 8 28 30 35 36 58 69 99 100 102 111 112 115 117 

grepl("*.exe", files);
[1] FALSE FALSE FALSE FALSE FALSE FALSE FALSE TRUE FALSE FALSE FALSE [12] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE [23] FALSE FALSE FALSE FALSE FALSE TRUE FALSE TRUE FALSE FALSE FALSE [34] FALSE TRUE TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE [45] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE [56] FALSE FALSE TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE [67] FALSE FALSE TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE [78] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE [89] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE TRUE [100] TRUE FALSE TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE [111] TRUE TRUE FALSE FALSE TRUE FALSE TRUE FALSE

下面这两个表达式的功能是一样的
files[grep("*.exe", files)]
files[grepl("*.exe", files)] 
[1] "bfsvc.exe" "explorer.exe" "HelpPane.exe" "hh.exe" "[email protected]" "regedit.exe" [7] "notepad.exe" "splwow64.exe" "winhlp32.exe" "write.exe"

用regexpr()、gregexpr()和regexec()三个函数包含了匹配的具体位置和字符串长度信息，可以用于字符串的提取操作。

text <- c("Hellow, Adam!", "Hi, Adam!", "How are you, Adam.")

regexpr("Adam", text) 
[1] 9 5 14 # 给出了Adam在text的每个分量的起始位置 
attr(,"match.length") 
[1] 4 4 4 # 给出了text的每个分量的长度 
attr(,"useBytes") 
[1] TRUE 

gregexpr("Adam", text)
regexec("Adam", text) # 把regexpr()运行的结果，以列表的形式呈现

字符串替换

sub()和gsub()
但严格地说R语言没有字符串替换的函数，因为R语言不管什么操作对参数都是传值不传址，区别如下：

text 
[1] "Hellow, Adam!" "Hi, Adam!" "How are you, Adam." 

sub(pattern = "Adam", replacement = "world", text) 
[1] "Hellow, world!" "Hi, world!" "How are you, world."

text 
[1] "Hellow, Adam!" "Hi, Adam!" "How are you, Adam."
可以看到：虽然说是“替换”，但原字符串并没有改变，要改变原 变量我们只能通过再赋值的方式

sub()和gsub()的区别是前者只做一次全部替换（只满足一种条件），而gsub把满足条件的匹配都做替换

sub(pattern = "Adam|H", replacement = "world", text) 
[1] "worldellow, Adam!" "worldi, Adam!" "worldow are you, Adam." 

gsub(pattern = "Adam|H", replacement = "world", text) 
[1] "worldellow, world!" "worldi, world!" "worldow are you, world."

- sub命令中，遇到H就换成world了，再遇到Adam就没有反应了 
- gsub命令中，遇到H或者Adam的地方，全都换成world了

字符串的提取

用substr()和substring()可以通过位置进行字符串拆分或提取，两者的参数设置基本相同：

substr(x, start, stop) 
substring (x, first, last=1000000L)

- x为要拆分的字符串向量；
- start/first为截取起始位置的向量； 
- stop/last为截取字符串终止位置的向量。

这两个命令在返回字符串的个数上有区别:
subtr()返回的字符串个数等于x向量的length；
substring()返回的字符串个数等于三个参数中最长的那个，长度不匹配时，短的循环使用。

注意比较下面的例子： 
x <- "123456789" 
substr(x, c(2, 4), c(4, 5, 8)) 
[1] "234" 
substring(x, c(2, 4), c(4, 5, 8)) 
[1] "234" "45" "2345678" 

y <- c("123456789", "abcdefghijklmnopq") 
substr(y, c(2, 4), c(4, 5, 8)) 
[1] "234" "de" 
substring(y, c(2, 4), c(4, 5, 8)) 
[1] "234" "de" "2345678"

用substring函数可以很方便地把DNA/RNA序列进行三联拆分（用于蛋白质翻译）：

bases <- c("A", "T", "G", "C") 
DNA <- paste(sample(bases, 12, replace = T), collapse = "") 
DNA 
[1] "GCAGCGCATATG" 

substring(DNA, seq(1, 10, by = 3), seq(3, 12, by = 3)) 
[1] "GCA" "GCG" "CAT" "ATG"

抽样函数

sample(bases, 12, replace = T)

字符串的修剪

strtrim()函数可以用于将字符串修剪到特定的显示宽度通过位置进行字符串拆分或提取：

strtrim (x, width)

x为要修剪的字符串向量；width是修剪以后字符串的宽度。
因为是“修剪”，所以只能去掉多余的字符不能增加其他额外的字符
如果字符串本身的长度小于width，得到的是原字符串，不要指望它会用空格或其他什么字符补齐。

strtrim(c("abcdef", "abcdef", "abcdef"), c(1, 5, 10)) 
[1] "a" "abcde" "abcdef" 

strtrim(c(1, 123, 1234567), 4) 
[1] "1" "123" "1234"

日期的表示和运算

1.取出当前日期 
Sys.Date() 
[1] "2019-11-06"

date() #注意：这种方法返回的是字符串类型 
[1] "Mon Nov 06 15:17:03 2019" 
注：在R中日期实际是double类型，是从1970年1月1日以来的天数 

2、转换为日期 用as.Date()可以将一个字符串转换为日期值，默认格式是yyyy-mm-dd。 
as.Date("2007-02-01") 
[1] "2007-02-01" # 显示为字符串，但实际是用double存储的 

as.double(as.Date("1970-01-01"))
[1] 0 #结果为0，是从1970年1月1日以来的天数。

as.Date ("2007年2月1日", "%Y年%m月%d日") 
[1] "2007-02-01" # 可以把定制的日期字符串转换为日期型

3.把日期值输出为字符串 
today = as.Date("2019-10-29") 

format(today, "%Y年%m月%d日") # format函数可以对日期型数据进行 格式化
[1] "2019年10月29日" 

format(today, "%Y年%b%d日")
[1] "2019年10月29日" 

format(today, "%Y年%B%d日") 
[1] "2019年十月29日"

在R中自带的日期形式为：as.Date(), 以数值形式存储；
标准格式：年-月-日或者年/月/日；(如果不是以上二种格式，则会提供错误；对于规则的格式，则不需要用 format指定格式；如果输入的格式不规则，可以通过format指定的格式读入)

as.Date('23-2013-1') 
错误于charTo按照Date(x) : 字符串的格式不够标准明确 

as.Date('23-2013-1',format='%d-%Y-%m') 
[1] "2013-01-23" 

as.Date('23-2013-1月',format='%d-%Y-%b') 
[1] "2013-01-23" 

as.Date('23-13-一月',format='%d-%y-%B') 
[1] "2013-01-23"

5.计算日期差：

由于日期内部是用double存储的天数，所以是可以相减的。

today = Sys.Date();
gtd = as.Date("2011-07-01");
today - gtd 
[1] Time difference of 2320 days

用difftime()函数可以计算相关的秒数、分钟数、小时数、天数、周数

difftime(today, gtd, units="weeks") #还可以是“secs”, “mins”, “hours”, “days” 
- Time difference of 3340800 weeks 

difftime(today, gtd, units="hours") 
difftime(today, gtd, units="mins")

6、日期对象查询周次、月份、季度

weekdays ( )取日期对象所处的周几；
months ( )取日期对象的月份；
quarters ( )取日期对象的季度；

weekdays(as.Date("2005-04-19")) 
[1] "星期二"

months(as.Date("2005-04-19")) 
[1] "四月" 

quarters(as.Date("2005-4-19")) 
[1] "Q2"

时间日期包：timeDate

library(timeDate) 
Dates = c("2009-09-28","2010-01-15")
Times = c( "23:12:55", "10:34:02") 
charvec = timeDate(paste(Dates, Times)) 
mode(charvec) # charvec是S4对象，在引用槽名（组件）的时候要用@ 
[1] "S4"

attributes(charvec)
charvec@Date 
[1] "2009-09-28 23:12:55 GMT" "2010-01-15 10:34:02 GMT"

Sys.timeDate ( ) #取系统的时间 
GMT # 默认是格林尼治时间 
[1] [2017-11-06 03:29:13] 

a= timeDate(Sys.time(), FinCenter = "Shanghai") ; a 
Shanghai 
[1] [2017-11-06 13:13:31] 

imeFirstDayInMonth(a) #一个月的第一天 
timeLastDayInMonth(a) #一个月的最后一天 
dayOfWeek(a) #一周当中第几天 
dayOfYear(a) #一年当中的第几天

产生日期序列

days.201711=timeSequence(from = "2017-11-01", to = "2017- 11-30", by = "day")
months.2017 = timeSequence(from = "2017-01-01", to = "2017-12-31", by = "month") # 按月产生每月第一天 
timeLastDayInMonth( moths.2017) # 每月最后一天 
timeLastNdayInMonth(moths.2017, nday=5) # 每月最后一周 的周五 nday=0:6 从周日到周六 
timeNthNdayInMonth(months.2017, nday=5, nth=3) # 每月 的第三个周五

查询工作日，假日，周末等

holidayNYSE() # 纽约证交所的假日 
holidayZURICH() # 苏黎世假日
isBizday(x, holidays = holidayNYSE(), wday = 1:5) 
isHoliday(x, holidays = holidayNYSE(), wday = 1:5) 
isWeekday(x, wday = 1:5) 
isWeekend(x, wday = 1:5) 
GoodFriday(2020) 
Easter(2020)

R是一个表达式语言(expression language)

for语句：

for (name in values) {expressions}
for ( i in 1:100){ sum <- sum+i; i <- i+1; }

统计分析举例

线性回归模型：

lm()函数的返回值叫做模型拟合结果对象，本质上是一个列表，有model 、coefficients、residuals等成员。
lm()的结果显示十分简单，为了获得更多的拟合信息，可以使用对lm类对象有特殊操作的通用函数，这些函数包括： add1 coef effects kappa predict residuals alias deviance family labels print summary anova drop1 formula plot proj
加号+或者减号－，表示在模型中加入一项或去掉一项，第一项前面如果是加号可以省略

- anova(对象1，对 象2) 把一个子模型与原模型比较，生成方 差分析表。 
- coefficients(对象) 返回回归系数（矩阵）。可简写为 coef(对象)。 
- deviance(对象) 返回残差平方和，如有权重则加权。 formula(对象) 返回模型公式。 
- plot(对象) 生成两张图，一张是因变量对拟合值 的图形，一张是残差绝对值对拟合 值的图形。
- predict(对象, newdata=数据框) predict.gam(对象, newdata=数 据框) 有了模型拟合结果后对新数据进行 预报。指定的新数据必须与建模时 用的数据具有相同的变量结构。函 数结构为对数据框中每一观测的因 变量预报结果（为向量或矩阵）。 
- predict.gam()与predict()作用相同但 适用性更广，可应用于lm、glm和 gam的拟合结果。比如，当多项式 基函数用了正交多项式时，加入了 新数据导致正交多项式基函数改变 ，用predict.gam() 函数可以避免由 此引起的偏差 print(对象) 简单显示模型拟合结果。一般不用 print()而直接键入对象名来显示。 
- residuals(对象) 返回模型残差（矩阵），若有权重 则适当加权。可简写为resid(对象)。
- summary(对象) 可显示较详细的模型拟合结果。

均值(mean)的基本用法：

mean(x, trim=0, na.rm=FALSE);
其中x是要计算均值的那个量，trim是计算均值前，去掉x两端观测值的比例， na.rm如果是TRUE，则表示删除NA再计算均值，允许缺失数据。
若x是个date frame, 可以用colMeans()和rowMeans()返回的是各列和各行的平均值

分位数：

quantile(x, probs=seq(0,1,0.25), na.rm=FALSE, names=TRUE, type=7, …)
probs给出相应的百分位数，默认值是0，0.25，0.5，0.75，1；na.rm是处理缺失数据的，na.rm=TRUE时，NA和NaN将从数据中移走，向量取值中若有NA或NaN，要添加这一参数，否则会出错；names若为TRUE，返回值当中有names这个属性"; type是取值1-9的整数，选择了九种分位数算法 (具体算法见帮助文件)中的一种。

w.quantile <- quantile(w); w.quantile 
0% 25% 50% 75% 100% 
47.40 57.85 65.50 66.75 75.00

attributes(w.quantile) 
$names 
[1] "0%" "25%" "50%" "75%" "100%" 

quantile(w, probs=seq(0,1, 0.2)) 
0% 20% 40% 60% 80% 100% 
47.4 56.98 62.20 64.00 67.32 75.00

数据的分布

数据的分布主要考察分布函数(p), 密度函数(d), 分位数函数(q)及产生随机数(r)
以正态分布为例：

data<-rnorm(100, mean=0, sd=1); 
dnorm(data, mean=0, sd=1, log=F);
pnorm(data, mean=0, sd=1, lower.tail=T, log.p=F); 
p<-c(0.975, 0.95) 
qnorm(p, mean=0, sd=1, lower.tail=T, log.p=F);

直方图

hist(x, breaks="Sturges", freq=NULL, probability=!freq,… )
break规定了直方图的组距(必须覆盖数据的范围)；freq是逻辑变量，TRUE是频率直方图， FALSE是密度直方图；probability和freq相反，TRUE是密度直方图，FALSE是频率直方图

R的图形函数分为两类：

高级图形函数――直接绘制图形并可自动生成坐标轴等附属图形元素；高级图形函数总是开始一个新图。
基础绘图工具——高级绘图函数：

最常用的高级绘图函数是plot()函数：

plot(x,y)（其中x，y是向量）对两个变量画散点图。
用plot(z) （其中z是一个定义了x变量和y变量的列表，或者一个两列的 矩阵）也可以达到同样目的。
如果x是一个普通向量，则plot(x)绘制x的值对其下标的散点图。 
如果u是复数向量,则plot(u)绘制虚部对实部的散点图。
如果f是一个因子，则plot(f)绘制f的条形图（每个因子水平的个数）。 
如果f是因子，y是同长度的数值向量，则plot(f,y)对f的每一因子水平绘 制y中相应数值的盒形图。 
如果d是一个数据框，则plot(d)对d的每两个变量之间作图（散点图等） 
如果X是一个数值型矩阵或数据框，用pairs(X)可以绘制每两列之间的 散点图矩阵。

协同图（coplot）是一种多变量的探索性分析图形。

其形式为 coplot(y ~ x | z)，其中x 和y是数值型向量，z是同长度的因子。对z的每一水平，绘制相应组的x和y的散点图

coplot(Weight ~ Height | Sex)

高级图形函数的常用共同选项

image.png

plot (cars, font.lab=2, main="主标题", sub="副标题", type="b", xlim=c(7,20), ylim=c(20,100)) 
plot (cars, font.lab=2, main="主标题", sub="副标题", type="b", xlim=c(7,20), ylim=c(20,100), axes=F)

plot(cars,font.lab=2,type="p") > plot(cars,font.lab=2,type="l") 
plot(cars,font.lab=2,type="b") > plot(cars,font.lab=2,type="o") 
plot(cars,font.lab=2,type="h") > plot(cars,font.lab=2,type="s") 
plot(cars,font.lab=2,type="S")

低级图形函数――可以修改已有的图形或者为绘图规定一些选择项。要在现有的图形上添加元素，或者自定义坐标轴，刻度，图例等，需要用低级图形函数命令。

基础绘图工具——低级绘图函数

基础绘图工具——其他常用绘图函数

image.png

plot(c(0, 100), c(0, 100), type="n", axes=F, xlab='', ylab='')
legend(10,90, as.character(0:9), pch=0:9)
legend(50,60, as.character(10:18), pch=10:18)

par(lwd=2,col="blue",lty=2)
x = (0:100)/100*2*pi
plot(x, sin(x), type="l", axes=F)
abline(h=0)
abline(v=0)

图形保存

输出到屏幕:windows, X11
windows()
X11()
输出到文件:pdf , postscript , xfig, bitmap, pictex, cairo_pdf, svg, png, jpeg, bmp, tiff

pdf("plot.pdf",width=4,height=4)
png("plot.png",width=400,height=600)
dev.off() #绘制完图形后关闭图形设备 
dev.list()

通过菜单命令保存图形

图形边空

R缺省的图形边空常常太大，以至于有时图形窗口较小时边空占了整个图形的很大一部分。

par()函数用来访问或修改当前图形设备的图形参数。

边空的大小由mai参数或mar参数控制，它们都是四个元素的向量，分别规定 下方、左方、上方、右方的边空大小，其中mai取值的单位是英寸，而mar的取值单位是文本行高度。例如：

par(mai=c(1, 0.5, 0.5, 0))
par(mar=c(4, 2, 2, 1))

通常我们可以取消右边空，并且在不用标题时可以大大缩小上边空。例如下例可以生成十分紧凑的图形：

par(mar=c(2,2,1,0.2)) 
plot(x,y)

在一个页面上画多个图时边空自动减半，但我们往往还需要进一步减小边空才能使多个图有意义。

一页多图:

R可以在同一页面开若干个按行、列排列的窗格，在每个窗格中可以作一幅图。每个图有自己的边空，而所有图的外面可以包一个“外边空”。
一页多图用mfrow参数或mfcol参数规定，如

par(mfrow=c(3,2)) 表示同一页有三行两列共六个图，而且次序为按行填放。类似地，
par(mfcol=c(3,2)) 规定相同的窗格结构，但是次序为按列填放，即先填满第一列的三个再填第二列

要取消一页多图只要再运行
par(mfrow=c(1,1))即可。
缺省时无外边空。为了规定外边空大小，可以用omi参数或oma参数。omi参数使用英寸为单位，oma参数以文本行高为单位，两个参数均为四个元素的向量，分别给出下、左、上、右方的边空大小。如：

par(oma=c(2,0,3,0))

添加文字标注:

函数mtext用来在外边空加文字标注。其用法为

mtext(text, side = 3, line = 0, outer = FALSE)

其中text为要加的文本内容，side表示在哪一边写（1为下，2为左，3为上， 4为右），line 表示边空从里向外数的第几行，最里面的一行是第0号， outer=TRUE时使用外边空，否则会使用当前图的边空。例如：

par(mfrow=c(2,2), oma=c(0,0,3,0), mar=c(2,1,1,0.1)) 
plot(Height) 
plot(Gender)
boxplot(Weight~Gender)
plot(Height,Weight)
mtext("Simulation Data", outer=T, cex=1.5)

跳到某一个窗格：

在多图环境中还可以用mfg参数来直接跳到某一个窗格，比如

par(mfg=c(2,2,3,2))

表示在三行两列的多图环境中直接跳到第二行第二列位置。mfg参数的后两个表示多图环境的行、列数，前两个表示要跳到的位置

任意位置产生一个窗格来绘图：

可以不使用多图环境而直接在页面中的任意位置产生一个窗格来绘图，参数为fig，如：

par(fig=c(4,9,1,4)/10)

此参数为一个向量，分别给出窗格的左、右、下、上边缘的位置，取值为占全页面的比例，比如上面的例子在页面的右下方开一个窗格作图。

dose <- c(20, 30, 40, 45, 60); 
drugA <- c(16, 20, 27, 40, 60); 
drugB <- c(15, 18, 25, 31, 40); 
opar <- par(no.readonly = TRUE); #将现有的图形设定保存于opar 
par(lwd = 2, cex = 1.5); 
par(cex.axis = 0.75, font.axis = 3); 
plot(dose, drugA, type = "b", pch = 19, lty = 2, col = "red"); 
plot(dose, drugB, type = "b", pch = 23, lty = 6, col = "blue", bg ="green"); 
par(opar)

levels返回null

先用as.factor()转化成因子。因为levels()函数里面必须是因子。

axis(1,at=dat$Genre,labels = F)报错：所有的位置值都是无限的

dat$Genre没有转化成因子形式，as.factor(dat$Genre)就可以了

axis(side, at = NULL, labels = TRUE, tick =TRUE, 
     line = NA, pos = NA, outer = FALSE, font = NA, 
     lty = "solid", lwd = 1, lwd.ticks = lwd, 
     col = NULL, col.ticks = NULL,tck=, las=，...)

##参数描述:
side    一个整数，表示在图形的哪边绘制坐标轴（1=下，2=左，3=上，4=右）
at  一个数值型向量，表示需要绘制刻度线的位置
labels  一个字符型向量，表示置于刻度线旁边的文字标签（如果为 NULL，则将直接使用 at 中的值
tick    一个逻辑值，指定是否应绘制刻度线和轴线
line    到轴线的行数距离
pos 坐标轴线绘制位置的坐标（即与另一条坐标轴相交位置的值）
outer   一个逻辑值，指示是否应在外部绘图边距而非标准绘图边距中绘制轴
font    文字的字体
lty 线条类型（默认为直线）
lwd， lwd.tick   轴线和刻度线的线宽.0或负数不会生成
col，col.tick    线条和刻度线的颜色
tck 刻度线的长度，以相对于绘图区域大小的分数表示（负值表示在图形外侧，正值表示在图形内侧，0 表示禁用刻度，1表示绘制网格线）；默认值为–0.01
las 标签是否平行于（=0）或垂直于（=2）坐标轴

R语言中使用text()函数给绘图添加文字

text(1:12,par("usr")[3]-0.6,labels = labels, srt = 45,pos = 1,xpd=T)

text(x, y = NULL, labels = seq_along(x$x), adj = NULL,
pos = NULL, offset = 0.5, vfont = NULL,
cex = 1, col = NULL, font = NULL, ...)

x和y为数值型向量，即要书写字符串的位置坐标。如果，x和y向量的长度不同，则短的将会被循环使用。
labels  字符串向量，要绘制的字符串。
adj 调整文字的位置。其值位于[0,1]之间。当adj为1个值时，是调整labels的x轴的位置，当是2个值时，第1个调整的是x轴的位置，第2个调整的是y轴的位置。
pos 调整文字的方向位置，如果给定了此值，将覆盖adj给定的值。1,2,3和4分别对应坐标的下，左，上和右。
offset 此参数需要与pos结合使用。当指定pos时，给出字符偏移量。
vfont NULL值为默认使用当前字体族。或者是一个长度为2的矢量字体字符向量。向量的第一个元素用于指定一种字体，第二个元素用于指定一种样式。如文本标签用表达式给出，则该项设置将被忽略。
cex 设置字体大小，如果为NA或NULL，则设置为1.
col 用于设置文本的颜色。
font 设置文字的格式，1是默认值，就是普通的文字，2代表加粗，3代表斜体， 4代表加粗+斜体， 5只有用来ADOBE的设备上时，才有用。

par()的用法：

usr :
设置图的坐标范围，usr = c(x1,x2,y1,y2)，即横坐标在x1到x2之间，纵坐标在y1到y2之间。若xlog或ylog参数为TRUE，则usr设置的点按10^c(x1,x2,y1,y2)使用。

内置序列生成：

> seq_along(1:10)
 [1]  1  2  3  4  5  6  7  8  9 10

重命名

names(df) = c("","",...)

查看前几行

head(df)

报错信息：incomplete final line found on 'D:/file.txt'

该消息表明文件的最后一行不以行尾 (EOL) 字符结尾（换行符 ( \n) 或回车 + 换行符 ( \r\n)）。此消息的初衷是警告您该文件可能不完整；大多数数据文件都有一个 EOL 字符作为文件中的最后一个字符。

grep()总是返回1

这是因为R读取文件的时候，是一整段character，所以它只会返回1，适当给他分一下段。

文本分析：

# 读取数据
dat = read.csv("D:/books.csv",fileEncoding = "UTF-8") 
View(dat)
table(dat$Genre)

# 箱线图
labels = levels(as.factor(dat$Genre))
bp = boxplot(log(dat$Height)~dat$Genre,col=rainbow(7,alpha=0.4),xlab="类型",ylab="log(Height)",xaxt="n")
axis(1,at=as.factor(dat$Genre),labels = F)
text(1:12,par("usr")[3],labels = labels, 
     srt = 45,pos = 1,offset = 1.5,xpd=T,cex = 0.5)

# 哑变量回归：
dat = within(dat,Genre<-relevel(as.factor(dat$Genre),
                                ref = "fiction"))
lm1=lm(Height~Genre,data = dat)
summary(lm1)

# 定长词语提取
head(dat$Title)
dat$Title.type=substr(dat$Title,1,4)
head(dat$Title.type)

dat$nonfiction = grepl("nonfiction",dat$Genre)
head(dat$nonfiction)


Title_subject1 = "Nature|Philosophy|Physics|Economic"
Title_subject2 = "Crime|Violence"
dat$Title.level= ifelse(grepl(Title_subject1,dat$Title),"学科","其他") 
dat$Title.level= ifelse(grepl(Title_subject1,dat$Title),"犯罪",dat$Title.level) 
cbind(head(dat$Title),head(dat$Title.level))

# 文本段落拆分
yitian = readLines("D:/倚天屠龙记.txt",encoding = "UTF-8")
# View(huawei)
para_head=grep("\\s+",huawei,perl=T) #perl=T表示使用正则表达式
para_head
cut_para1=cbind(para_head[1:(length(para_head)-1)],para_head[-1])
yitian_para = sapply(1:nrow(cut_para1),function(i)paste(yitian[cut_para1[i,1]:cut_para1[i,2]],collapse = ""))
cut_para1


roles=yitian
roles1 = paste0("(",gsub(" ",")|(", roles),")")

roles1=strsplit(roles," ")
role_para=sapply(roles,grepl,yitian_para)
colnames(role_para)=sapply(roles_1,function(x)x[1])
role_count=data.frame(role=factor(colnames(role_para),levels=colnames(role_para)[order(colSums(role_para),decreasing=T)]),count=colSums(role_para))

根据出场次序绘图
ggplot(role_count[1:5,],aes(x=role,y=count,fill=role))+
    geom_bar(stat="identity",width=0.75)+
    xlab("Kole")+
    ylab("count")+
    theme_grey(base_family="STKaiti")+
    theme(axis.text=element_text(size=24,angle=90),
    axis.title=element_text(size=24,face="bold"),
    axis.title.x=element_text(vjust=-2),
    legend.position="none")

计算各人物的出场顺序
#将出场顺序放入数据框中以便作图：
main roles=c("殷离","周若","赵敏","小昭","张无忌")
role_para_df=data.frame(role factor(rep(main_roles,
colSums(role_para)[1:51)),para which(role_para[,(1:5)],arr.ind T)[,1])
#提取出三个主角的出场顺序：
role_para_dfl=role_para_df[is.element(role_para_df$role,c"赵敏","周
芷若","张无忌")),]
                                        
#做出三个主角的出场顺序密度图
(p=ggplot(role_para_df1,aes(para,fill=role))+
geom_density(aes(y=..density..),alpha=I(0.3),color "white",size=0)+
labs(x="\n出场顺序"，y="密度\n")+
scale_fill_manual("角色"，values=terrain.colors(7)[3:l])+
theme_grey(base_family ="STKaiti")+
theme(plot.margin=unit(c(0,1,1,0),"cm"),
    axis.text=element_text(size =24),
    axis.title.x=element_text(vjust,2),
    axis.title =element_text(size =24,face ="bold"),
    panel.background=element_rect(fill ="white"),
    panel.grid.major=element_line(color ="white"),
    panel.grid.minor=element_line(color ="white"),
    axis.line=element_line(color="grey40"),
    legend.key.size unit(0.8,"cm"),
    legend.text=element_text(size=24),
    legend.title=element_text(size=24)))

## 计算亲密度逻辑值                       
co_para=crossprod(role_para)
## 将无意义的矩阵对角线元素化为0
diag(co_para)=0
## 构建前5个人物亲密度矩阵
temp=co_para[1:5,1:5]
## 调整数据组织形式以便画图
intimacy_main = melt(temp)
                           
# 绘制亲密度矩阵图
(p=ggplot(intimacy_main,aes(Var1,Var2,fill value))+
geom_tlle(color="32CD32"+
geom_text(data intimacy_main,aes(Var2,Var1,label value),size =13,
color "black")+
scale_fill gradient(low ="white",high ="#32CD32")+
xlab("")+ylab("")+
scalex_discrete(expand=c(0,0),limits=c('张无忌','赵敏','周芷若','殷离'
,'小昭'))+
seale_y_discrete(expand=c(0,0),limits=c('张无忌','赵敏','周芷若','殷离'
,'小昭')[5:1])+
theme_grey(base_family ="STKaiti")+
theme(axis.text element_text(size=24,angle =90),
    axis.title element text(size =24,face "bold"),
    axis.title.x element_text(vjust =-2),
    legend.position ="none"))

图像处理

library(knitr)
library(jpeg)
library(png)
library(EBImage)
library(RgoogleMaps)
library(magick)

data1 = readJPEG("D:/证件照.jpg")
dim(data1)

X1=readImage("D:/证件照.jpg")
n.size=300
X1=resize(X1,n.size,n.size)
X11=X1;X11[,,1]=0*X11[,,1];X11[,,2]=0*X11[,,2];
X12=X1;X12[,,1]=0*X12[,,1];X12[,,3]=0*X12[,,3];
X13=X1;X13[,,2]=0*X13[,,2];X13[,,3]=0*X13[,,3];
display(X11)
display(X12)
display(X13)
display(X11+X12)
display(X11+X13)
display(X12+X13)


gray_image = channel(data1,"gray") #用EBImage包转灰度
gray_image = RGB2GRAY(data1)  # 用RgoogleMaps包转灰度
display(gray_image)


#打网格
plot_jpeg = function(M,add = F)
{
  res = dim(M)[1:2]
  if (!add)
    plot(1,1,xlim = c(1, res[1]), ylim = c(1, res[2]), type = "n", asp = 1,
         xlab = '', ylab = '', bty = 'n', xaxs = 'i', yaxs = 'i', xaxt = 'n', yaxt = 'n')
  rasterImage(M,1,1,res[1],res[2])
  axis(1,at = (1:20)*30,tick=T);
  axis(2,at = (1:20)*30,tick=T);
  abline(h=(1:20)*30,v=(1:20)*30,col="yellow",lty=2)
}
plot_jpeg(gray_image)

## 实现马赛克
rsize=dim(data1)[1]
csize=dim(data1)[2]
cutlength=50
index_group1=cut(1:rsize,seq(0,rsize,length=cutlength))
index_group2=cut(1:csize,seq(0,csize,length=cutlength))
lev1=levels(index_group1)
lev2=levels(index_group2)
M1=matrix(0,nrow=length(lev1),ncol=length(lev2))
for(i in 1:length(lev1))
{
  for(j in 1:length(lev2))
  {
    M1[i,j] = mean(gray_image[index_group1 == lev1[i], index_group2 == lev2[j]])
  }
}
plot_Image(M1)
## 实现灰度
plot_Image = function(M,add=F)
{
  res = dim(M)[1:2]
  if (!add)
    plot(1,1,xlim = c(1, res[1]), ylim = c(1, res[2]), type = "n", asp = 1,
         xlab = '', ylab = '', bty = 'n', xaxs = 'i', yaxs = 'i', xaxt = 'n', yaxt = 'n')
  rasterImage(M,1,1,res[1],res[2])
}
plot_Image(gray_image)

逻辑回归的例子

rm(list=ls())
mydata = read.csv("https://stats.idre.ucla.edu/stat/data/binary.csv")
head(mydata)
#调用summary函数实现分类汇总
summary(mydata[admit==1,])
summary(mydata[admit==0,])
#同时也可以使用交叉表来实现分类型变量的数据统计
xtabs(~admit+rank,data=mydata)
#分类型变量因子化
mydata$rank=factor(mydata$rank)
mydata$rank
mylogit = glm(admit~gre+gpa+rank,data=mydata,family="binomial")
#summary中，回归系数的检验是怀特检验
summary(mylogit)
# 回归系数估计量
coef(mylogit)
#协方差矩阵
round(vcov(mylogit),3)
#置信区间
confint.default(mylogit)
#回归系数的似然比检验
anova(mylogit,test="Chisq")
# wald检验可以同时对rank的多个水平的差异性做检验
library(aod)
wald.test(b = coef(mylogit),Sigma = vcov(mylogit),Terms = 4:6)

new_data1 = with(mydata,data.frame(gre=mean(gre),gpa=mean(gpa),rank=factor(1:4)))
y_p=predict(mylogit,newdata=new_data1,type="response")
y_p