R语言基础语法+数据结构学习总结

R语言Outline

Basic syntax

清屏: option+command+L
赋值:

> x <- rnorm(5)  ###R中赋值不常用=号

也可以反转赋值符号：

> rnorm(5) -> x  ###与上面等价

可以使用函数c()以向量的形式输入月龄和体重数据，此函数可将其参数组合成一个向量或列表。然后用mean()、sd()和cor()函数分别获得体重的均值 和标准差，以及月龄和体重的相关度。最后使用plot()函数，从而用图形展示月龄和体重的关系，这样就可以用可视化的方式检查其中可能存在的趋势。函数q()将结束会话并允许你退出R。

> age <- c(1,3,5,2,11,9,3,9,12,3)
> weight <- c(4.4,5.3,7.2,5.2,8.5,7.3,6.0,10.4,10.2,6.1) > mean(weight)
[1] 7.06
> sd(weight)
[1] 2.077498
> cor(age,weight)
[1] 0.9075655
> plot(age,weight)
> q()

• Hint: demo()可以显示出各种示例

R语言编程中的常见错误

有一些错误是R的初学者和经验丰富的R程序员都可能常犯的,如果程序出错了，请检查以下几方面:

1. 使用了错误的大小写。help()、Help()和HELP()是三个不同的函数(只有第一个是 正确的)。
2. 忘记使用必要的引号。install.packages(“gclus”)能够正常执行，然而 Install.packages(gclus)将会报错。
3. 在函数调用时忘记使用括号。例如，要使用help()而非help。即使函数无需参数，仍 需加上()。
4. 在Windows上，路径名中使用了\。R将反斜杠视为一个转义字符。 setwd(“c:\mydata”)会报错。正确的写法是setwd(“c:/mydata”)或 setwd(“c:\mydata”)。
5. 使用了一个尚未载入包中的函数。函数order.clusters()包含在包gclus中。如果还 没有载入这个包就使用它，将会报错。

赋值

1.vector

a <- c(1, 2, 5, 3, 6, -2, 4)  
b <- c("one", "two", "three")  
c <- c(TRUE, TRUE, TRUE, FALSE, TRUE, FALSE)

这里，a是数值型向量，b是字符型向量，而c是逻辑型向量

2.Matrix

矩阵是一个二维数组，只是每个元素都拥有相同的模式(数值型、字符型或逻辑型)。可通 过函数matrix()创建矩阵。一般使用格式为:

myymatrix <- matrix(vector, nrow=number_of_rows, ncol=number_of_columns,
 byrow=logical_value, dimnames=list(
char_vector_rownames, char_vector_colnames))

其中vector包含了矩阵的元素，nrow和ncol用以指定行和列的维数，dimnames包含了可选 的、以字符型向量表示的行名和列名。选项byrow则表明矩阵应当按行填充(byrow=TRUE) 还是按列填充(byrow=FALSE)，默认情况下按列填充。代码清单2-1中的代码演示了matrix 函数的用法。

>cells <- c(1,26,24,68)
> rnames <- c("R1","R2")
> cnames <- c("C1","C2")

> M1 <- matrix(cells,nrow=2,ncol=2,byrow=TRUE,dimnames=list(rnames,cnames))
> M1
   C1 C2
R1  1 26
R2 24 68

• 必须注意逻辑判断语句“TRUE”必须大写

M2 <- matrix(cells,2,2,TRUE,list(rnames,cnames))
> M2
   C1 C2
R1  1 26
R2 24 68

• 熟练以后可以简写

数组

数组(array)与矩阵类似，但是维度可以大于2。数组可通过array函数创建，形式如下:

myarray <- array(vector, dimensions, dimnames)
下表给出了一个创建三维（2x3x4）数值型数组的示例：

> dim1 <- c("A1","A2")  ###命名步骤
> dim2 <- c("B1","B2","B3")
> dim3 <- c("C1","C2","C3","C4")  
z <- array(1:24,c(2,3,4),dimnames=list(dim1, dim2, dim3))  ###数组赋值
> z
, , C1

   B1 B2 B3
A1  1  3  5
A2  2  4  6

, , C2

   B1 B2 B3
A1  7  9 11
A2  8 10 12

, , C3

   B1 B2 B3
A1 13 15 17
A2 14 16 18

, , C4

   B1 B2 B3
A1 19 21 23
A2 20 22 24

从数组中选取元素的方式与矩阵相同。上例中，元素 z[1,2,3]为15。

数据框

数据框可通过函数data.frame()创建:
mydata <- data.frame(col1, col2, col3,...)
其中的列向量col1、col2、col3等可为任何类型(如字符型、数值型或逻辑型)。

> patientID <- c(1,2,3,4)
> age <- c(25,34,28,52)
> diabetes <- c("Type1","Type2","Type1","Type1")
> status <- c("Poor","Improved","Excellent","Poor")
> patientdata <- data.frame(patientID, age, diabetes, status)
> patientdata
  patientID age diabetes    status
1         1  25    Type1      Poor
2         2  34    Type2  Improved
3         3  28    Type1 Excellent
4         4  52    Type1      Poor

选取数据框元素的方式

• attach() & with()函数

函数attach()可将数据框添加到R的搜索路径中。R在遇到一个变量名以后，将检查搜索路 径中的数据框。

summary(mtcars$mpg)
plot(mtcars$mpg, mtcars$disp)
plot(mtcars$mpg, mtcars$wt)

可以用attach写成：

attach(mtcars)
  summary(mpg)
  plot(mpg, disp)
  plot(mpg, wt)
detach(mtcars)

*函数attach()和detach()最好在你分析一个单独的 数据框，并且不太可能有多个同名对象时使用。否则会出现问题。
另一种方式是使用函数with()：

 with(mtcars, {
      print(summary(mpg))
      plot(mpg, disp)
      plot(mpg, wt)
})

函数with()的局限性在于，赋值仅在此函数的括号内生效:

> with(mtcars, {
	stats <- summary(mpg)  
	stats
  })
 Min. 1st Qu. Median Mean 3rd Qu. Max.
10.40 15.43 19.20 20.09 22.80 33.90 
> stats
Error: object 'stats' not found

如果你需要创建在with()结构以外存在的对象，使用特殊赋值符<<-替代标准赋值符(<-)
即可，它可将对象保存到with()之外的全局环境中。

因子

函数**factor()**以一个整数向量的形式存储类别值：
举例来说，假设有向量:

diabetes <- c("Type1", "Type2", "Type1", "Type1")

语句diabetes <- factor(diabetes)将此向量存储为(1, 2, 1, 1)，并在内部将其关联为 1=Type1和2=Type2(具体赋值根据字母顺序而定)。
针对向量diabetes进行的任何分析都会将其作为名义型变量对待.
要表示有序型变量，需要为函数factor()指定参数ordered=TRUE。给定向量:

status <- c("Poor", "Improved", "Excellent", "Poor")

语句status <- factor(status, ordered=TRUE)会将向量编码为(3, 2, 1, 3)，并在内部将这些值关联为1=Excellent、2=Improved以及3=Poor。
另外，针对此向量进行的任何分析都会将 其作为有序型变量对待.

对于字符型向量，因子的水平默认依字母顺序创建。这对于因子status是有意义的，因为 “Excellent”“Improved”“Poor”的排序方式恰好与逻辑顺序相一致。如果“Poor”被编码为 “Ailing”，会有问题，因为顺序将为“Ailing”“Excellent”“Improved”。
可以通过指定levels选项来覆盖默认排序：

status <- factor(status, order=TRUE,
       levels=c("Poor", "Improved", "Excellent"))

各水平的赋值将为1=Poor、2=Improved、3=Excellent

summary()显示连续型变量age的最小值、最大值、均值和各四分位数;并显示类别型变量的频数值。

1. Basics

rm(list=ls())
getwd()
setwd()

2. Matrix

cell <- c(seq(1,25))
rname <- paste(‘row’,1:5)
cname <- paste(‘col’,1:5)
mymatrix <- matrix(cell,5,5,byrow=T,list(rname,cname))

2.1 添加行列

Col_Sum <- apply(mymatrix,1,sum)
Col_Mean <- apply(mymatrix,1,mean)
cbind(mymatrix,Col_Sum,Col_Mean)

3. Dataframe

3.1 从已有表中创建

library(‘MASS’)
varname <- c(‘crim’,‘age’,‘lstat’,‘medv’)
mydataframe <- Boston[varname]
head(mydataframe)

3.2 添加行或者列

mydataframe <- cbind(mydataframe,‘rad’=Boston$rad)
head(mydataframe)
str(mydataframe)
colnames(mydataframe)

A data.frame: 6 × 5

	
crim
age
lstat
medv
rad
	
<dbl>
<dbl>
<dbl>
<dbl>
<int>


	
1
0.00632
65.2
4.98
24.0
1
	
2
0.02731
78.9
9.14
21.6
2
	
3
0.02729
61.1
4.03
34.7
2
	
4
0.03237
45.8
2.94
33.4
3
	
5
0.06905
54.2
5.33
36.2
3
	
6
0.02985
58.7
5.21
28.7
3





    'data.frame':	506 obs. of  5 variables:
     $ crim : num  0.00632 0.02731 0.02729 0.03237 0.06905 ...
     $ age  : num  65.2 78.9 61.1 45.8 54.2 58.7 66.6 96.1 100 85.9 ...
     $ lstat: num  4.98 9.14 4.03 2.94 5.33 ...
     $ medv : num  24 21.6 34.7 33.4 36.2 28.7 22.9 27.1 16.5 18.9 ...
     $ rad  : int  1 2 2 3 3 3 5 5 5 5 ...




'crim'
'age'
'lstat'
'medv'
'rad'




```R
### 3.3 从dataframe中提取特定的观测
### 例如我想要取crim>0.2的所有观测
mydataframe_crim <- data.frame(mydataframe[mydataframe[1] > 0.2,])
### 再利用order()从高到低显示
head(mydataframe_crim[order(-mydataframe_crim$crim),])

A data.frame: 6 × 5

	crim	age	lstat	medv	rad
381	88.9762	91.9	17.21	10.4	24
419	73.5341	100.0	20.62	8.8	24
406	67.9208	100.0	22.98	5.0	24
411	51.1358	100.0	10.11	15.0	24
415	45.7461	100.0	36.98	7.0	24
405	41.5292	85.4	27.38	8.5	24

### 4. Factor
### 举个例子：我想把crim分为4档，然后用高中低表示
mytable <- cbind(Boston$crim,NA)
i=0
for (x in Boston$crim){
    i=i+1
    if (x <= 0.1){
        mytable[i,2]='Low'
    }else if(2 >= x){
        mytable[i,2]='Medium'
    }else if(10 >= x){
        mytable[i,2]='High'
    }else if(x >= 10){
        mytable[i,2]='Very Dangerous'
    }

}
myfactor <- factor(mytable[,2],
                  levels=c('Low','Medium','High','Very Dangerous'))
summary(myfactor)

Low

153

Medium

203

High

96

Very Dangerous

54

---

Getting started

working directory

利用getwd(),setwd()设置工作路径
利用source(‘Hello.R’)从cwd中找到文件

保存/加载工作空间:
• File-> Load/Save Workspace #菜单栏的形式操作，保存当前工作空间
• save.image(“xxx.RData) ###保存当前workspace,下次启动R自动加载
• 等价于save(list=ls(all=TRUE),file=“xxx.RData”)
• save(object, file=“xxx.RData”) ### save particular objects

Packages

• 除了R中默认安装的包，使用必须加载:
• library(nlme) ——加载相应包
• require(nlme) ——加载相应包（有返回值T/F）
• detach(package:nlme) ——移除包
• search() ——目前加载了哪些包
• .packages(all.available=TRUE) ——目前安装了哪些包

####require() & library()
利用x <- require(xxx)如果包不存在x=F，存在x=T

###获取帮助

• help.start() 帮助菜单
• help(xxx) / ?xxx 解释xxx这个函数
• example(xxx) xxx的运行示例

数据输入&输出

eg1:
计算体重均值、标准差、体重与年龄的相关系数并作出体重与年龄的散点图：

age <- c(1,3,5,2,11,9,3,9,12,3)
weight <-c(4.4,5.3,7.2,5.2,8.5,7.3,6.0,10.4,10.2,6.1)
mean(weigt)
sd(weight)
cor(age,weight)
plot(age,weight)
q()

Object

R中的数据都以’对象’保存，在R中一切都是’Objects’。

age <- c(1,3,5,2,11,9,3,9,12,3)
weight <-c(4.4,5.3,7.2,5.2,8.5,7.3,6.0,10.4,10.2,6.1)
###创建了两个object, named as 'age', 'weight' respectively

1. object命名规则

• 字母，数字，下划线_，点.都可以作为名称，不能包含运算符；

• 名字由字母或者点开始 不能用数字开头

• 避免使用保留名：pi, NA, NaN…

• objects() / ls() ### 当前工作空间中的所有对象

• ls(pat=“m”) ### 名字包含m的所有对象

• ls(pat=“^m”) ### 名字以m开头的所有对象

• ls.str() ##将会展示所有对象的详细信息

• rm(xxx) #删除某个xxx对象

• rm(list=c(“xx”,”yy”)) #删除对象 xx,yy

• rm(list=ls()) ### 删除(几乎)一切对象

在每个R脚本的开头，可以加上：

setwd("/Users/pzh/Documents/Sophomore 2nd/R/R Workplace")
rm(list=ls())

1.1 Object的属性

• 对象=数据，由元素组成，元素有其数据类型
• 字符Character:‘china’,‘1’
• 实数Numeric: 3.14
  …

对象的属性可以用mode(),is.xxx查看:

> x<-1
> mode(x)
[1] "numeric"
> is.integer(x)
[1] FALSE
> is.numeric(x)
[1] TRUE
> y <- is.numeric(x)
> mode(y)
[1] "logical"
> is.integer(y)

1.2 Object的类别

• 向量：c(),vector()
  最基本的数据结构，向量必须来自同一元素:
  例如我可以x <- c(0.1,0,3) 但不能够 x <- c(TRUE,0.3)

---

逻辑向量:
any()#只要有一个逻辑为True，返回Ture
all()#所有逻辑均为TRUE返回TRUE

逻辑运算：

• !(非）
• &（与）
• ｜（或）

---

• 矩阵：
• 数组
• 数据库
• 列表
  …

可以用class()判断数据类型

• 区分class()和mode()的不同：mode表示数据储存类型，class表示抽象的类别，例如data.frame键入mode()就会显示‘list’,但是键入class()会显示‘data.frame’

类型转换：as.xxx()

> x <- 0:6 或者x<- c(0,1,2,3,4,5,6) > mode(x)
[1] "numeric"
> as.logical(x)
[1] FALSE TRUE TRUE TRUE TRUE TRUE TRUE
> as.character(x)
[1] "0" "1" "2" "3" "4" "5" "6"

强制转换不一定成功，如果它失败了就会返回NA，所有无意义的强制转换都会导致NA值:

> x <- c('a','b','c')
> as.numeric(x)
[1] NA NA NA

缺失数据

• NA: 缺失数据
• NaN: 无意义的数，比如sqrt(-2) • Inf: 正无穷大，例如 1/0
• -Inf:负无穷大,例如 -1/0
• is.na() #每个元素分别判断
• is.nan() #每个元素分别判断
• A NaN value is also NA but the converse is not true

Matrix

m <- matrix(cell,nrow=2,ncol=3) ###Vector -> Matrix
v <- as.vector(m) ###Matrix -> Vector

注意R中矩阵按列形成与拆分

可以使用cbind(),rbind()对列、行进行组合适用于矩阵

> x=1:3
> cbind(1,x)
[1,] 1 1
[2,] 1 2
[3,] 1 3
> z=1:2
> cbind(z,x)
[1,] 1 1
[2,] 2 2
[3,] 1 3
###当cbind,rbind函数中的两个向量长度不一样时:R自动重复短的向量

当我们使用cbind或rbind进行矩阵的合并时，数据格式将被转换为最低的类别(实数/字符)，这会造成很多不方便

数据框 Data Frames

Data Frame不同列可以是不同数据类型，并且可以通过data.matrix()/as.matrix()转化为matrix; 也可以用as.data.frame将矩阵转化为数据框
并且我们可以通过dim(),nrow(),ncol()检查其属性

> x <- data.frame(foo=1:4,bar=c(T,T,F,F))
> x
  foo   bar
1   1  TRUE
2   2  TRUE
3   3 FALSE
4   4 FALSE
> dim(x)
[1] 4 2
> nrow(x)
[1] 4
> ncol(x)
[1] 2

列表List

列表是一种广义的向量，可以包含多种属性类型的对象

• 列表的每个位置上是任意的R对象，甚至是一个列表

元素的索引

> m <- matrix(1:16,4,4)
> m
     [,1] [,2] [,3] [,4]
[1,]    1    5    9   13
[2,]    2    6   10   14
[3,]    3    7   11   15
[4,]    4    8   12   16
> m[c(1:3),c(2)]
[1] 5 6 7

也可以用-来剔除部分变量

> m <- matrix(1:16,4,4)
> m
     [,1] [,2] [,3] [,4]
[1,]    1    5    9   13
[2,]    2    6   10   14
[3,]    3    7   11   15
[4,]    4    8   12   16
> m[-c(1:3),c(3)]
[1] 12
> m[-c(1:2),-c(2:4)]
[1] 3 4

### 1. Logical Calculation
for(x in seq(-1,2,by=0.5)){
if(any(x>1,x<0,x==0.5)){
    print(x)}
    }
cat('------\n')
for(x in seq(-1,2,by=0.5)){
if(all(x>-1,x<1.5,x!=0.5)){
    print(x)}
    }

[1] -1
[1] -0.5
[1] 0.5
[1] 1.5
[1] 2
------
[1] -0.5
[1] 0
[1] 1

---

下标的提取

利用逻辑值来进行筛选：

> x <-seq(1,100,by=pi)
> x[x<40 & x>7] ###提取大于7小于40的元素
 [1]  7.283185 10.424778 13.566371 16.707963 19.849556 22.991149 26.132741 29.274334
 [9] 32.415927 35.557519 38.699112

应用：去除缺失数值

> age <- c(1,3,NA,2,NA,9)
> badindex=is.na(age)
> badindex
[1] FALSE FALSE  TRUE FALSE  TRUE FALSE
> badindex2=!is.na(age)
> badindex2
[1]  TRUE  TRUE FALSE  TRUE FALSE  TRUE
> age[badindex2]
[1] 1 3 2 9
> age[!is.na(age)]
[1] 1 3 2 9

注意： ！表示逻辑值反转

• 去除多个向量中的缺失数据：

> age <- c(1,3,NA,2,NA,9)
> weight <- c(4.4,5.3,NA,NA,5.2,8.5)
> goodindex <- complete.cases(age,weight)
> goodindex
[1]  TRUE  TRUE FALSE FALSE FALSE  TRUE

矩阵的元素引用

> x <- matrix(1:16,4,4)
> x
     [,1] [,2] [,3] [,4]
[1,]    1    5    9   13
[2,]    2    6   10   14
[3,]    3    7   11   15
[4,]    4    8   12   16
> x[2,2]
[1] 6
> x[2,]
[1]  2  6 10 14
> x[,2]
[1] 5 6 7 8
> x[3] ###不加逗号会按照竖排顺序引用
[1] 3
> x[c(1,2),c(3,4)] ###利用向量提取子阵
     [,1] [,2]
[1,]    9   13
[2,]   10   14

读取data.frame

利用attach,detach 加上相应名字即可
或者:DataFrameName$ColName

读取列表

> x <- list(foo=1:4,bar=matrix(1:6,2))
> x
$foo
[1] 1 2 3 4

$bar
     [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    6

> x[[1]]
[1] 1 2 3 4
> x$foo
[1] 1 2 3 4
> x[[2]]
     [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    6
> x$bar
     [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    6

基本同data.frame()

下标运算总结

正的下标：提取对应元素；负的下标：去除对应元素；逻辑运算：提取T的元素
example:矩阵的逻辑提取

> x<-matrix(1:25,5,5)
> x
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    6   11   16   21
[2,]    2    7   12   17   22
[3,]    3    8   13   18   23
[4,]    4    9   14   19   24
[5,]    5   10   15   20   25
> x[2,x[3,]>8]
[1] 12 17 22
> x[-2,x[3,]>8]
     [,1] [,2] [,3]
[1,]   11   16   21
[2,]   13   18   23
[3,]   14   19   24
[4,]   15   20   25

运算

向量运算

• 加减乘除向量长度必须一样，每个分量分别去做
  which(x==3):提取3的下标（所有，与*python不同）

> x<-c(-1,-2,0,4,5)
> x[which(x>0)]
[1] 4 5

常用向量运算函数

+, -, *, /, ^, %%, %/%
< > <= >= == ==… !=…
sin,cos,tan,asin,log,log10,exp
max(x),min(x),range(x)##返回c(min(x),max(x))
sum(x)
diff(x) ##差分

> x<-c(1,2,3,6,76,10)
> diff(x)
[1]   1   1   3  70 -66

prod(x) ##连乘
abs(x) ##绝对值
sqrt(x)=x^0.5

矩阵运算

> x <- matrix (1:4,2,2)
> y <- matrix(rep(10,4),2,2)
> x * y ###各个分量单独做乘法
     [,1] [,2]
[1,]   10   30
[2,]   20   40
> x %*% y ###矩阵乘法
     [,1] [,2]
[1,]   40   40
[2,]   60   60

rownames(x) <- c(‘row1’,‘row2’);colnames <- c(‘col1’,‘col2’) 命名
as.vector(x) 矩阵拉直
apply(x,2,sum) 按列求和
apply(x,1,sum) 按行求和

> x <- matrix(1:50,5,5)
> x
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    6   11   16   21
[2,]    2    7   12   17   22
[3,]    3    8   13   18   23
[4,]    4    9   14   19   24
[5,]    5   10   15   20   25
> apply(x,1,sum)
[1] 55 60 65 70 75
> apply(x,1,diff)
     [,1] [,2] [,3] [,4] [,5]
[1,]    5    5    5    5    5
[2,]    5    5    5    5    5
[3,]    5    5    5    5    5
[4,]    5    5    5    5    5

• 我们可以在apply中应用任何函数apply(x,2,'MyFunction')

其他矩阵计算函数

t(x) 转置
diag(x) 对角阵/元素

> x
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    6   11   16   21
[2,]    2    7   12   17   22
[3,]    3    8   13   18   23
[4,]    4    9   14   19   24
[5,]    5   10   15   20   25
> diag(x)
[1]  1  7 13 19 25
> diag(diag(x))
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    0    0    0    0
[2,]    0    7    0    0    0
[3,]    0    0   13    0    0
[4,]    0    0    0   19    0
[5,]    0    0    0    0   25

solve(a,b) 运算a %*% x=b得到x
solve(a)矩阵的逆

因子

• Factors: categorical varable属性变量
• 主要目的是用来分类，计算频数和频率

factor(x=character(),levels,labels=levels)
gl(n,k,length=n*k,labels=1:n,ordered=FALSE) ###n：水平数；k：每个因子重复次数；length：总长度(类似rep中each和times）

> gl(3,2,18)
 [1] 1 1 2 2 3 3 1 1 2 2 3 3 1 1 2 2 3 3
Levels: 1 2 3

字符串

• 用于大规模执行、成批量输出时进行文件命名

paste可以将多个字符串连接成一个向量
paste(...,sep=' ',collapse=NULL,recycle0=FALSE) ###默认分隔为空格

> paste(“hello”,“world”,“!”)###默认空格分隔
[1] "hello world !“
> paste(“Lec”,1,“.txt”,sep=“”)###用sep=“”调整分隔
[1] "Lec1.txt"
> paste("Lec",1,".txt",sep="*")
[1] "Lec*1*.txt"

• 合并字符型向量

x <- c("a","b", "c", "d", "e")
y <- c("A", "B", "C", "D","E")
> paste(x, y, sep = "-")
[1] "a-A" "b-B" "c-C" "d-D" "e-E"
> paste(x, y, sep = "") 
[1] "aA" "bB" "cC" "dD" "eE“
> paste(4:9, rep("th", 6), sep = "") ##会先把字符转化为字符串
[1] "4th" "5th" "6th" "7th" "8th" "9th"

• collapse
  可以将返回的所有向量都连成一个字符串，可以用collapse参数实现

> paste(x, y, sep = "-", collapse = "*") 
[1] "a-A*b-B*c-C*a-D*b-E"

字符串的其他函数

1. strsplit()
   strsplit(*str,sep='')
2. grep()
   grep(pattern, *str, ignore.case = FALSE, value = FALSE)
   pattern: 正则表达式
   ignore.case=T/F: T为忽略大小写
   value=T/F: T为返回值，F为返回位置

数据的外部输入和外部输出

外部文件输入read.table/scan/csv()

read.table()

• read.table(file,header,sep,…)

file: 文件路径
header=T/F: 识别标题
sep=’’: 分隔符
StringAsFactor=T/F: 是否想要把字符变成因子

scan()

• scan(file,what,sep,…)
  what:指定变量名和类别

得到一个列表list；可以读进不规则的数值文档

read.csv

read.csv((file,header,sep,quote='\'',dec='.',...)
quote:换行符
dec=’’: 小数点字符

• 一般无表头，空格分隔的txt用read.table;有表头，用逗号分隔的csv用read.csv

数据输出

write.table()

write.table(data,file='',quote=T,sep='',eol='\n',na='NA',...)

• data:矩阵或者数据库，写到文件 name.txt
• quote:如果quote为TRUE，字符和因子列就会被 ("")所包围;
• sep是字段分隔符;
• eol为尾行分隔符;
• na为缺失值字符串;

cat()[重点]

cat(..., file=”", sep=” “, append=FALSE)
append:指明输出结果是否加入到原有文件
注意：使用cat()时要自己加上换行符’\n’

dataframe重点内容

1. names()
   names(object)[] <- c(‘newname’,…)

> mydata
  cell1 cell2 cell3
1     0     3     6
2     1     4     7
3     2     5     8
4     3     6     9
> names(mydata) <-c('col1','col2','col3')
> mydata
  col1 col2 col3
1    0    3    6
2    1    4    7
3    2    5    8
4    3    6    9
> names(mydata)[1] <- 'col4'
> mydata
  col4 col2 col3
1    0    3    6
2    1    4    7
3    2    5    8
4    3    6    9

2. 元素索引

###切片和名称索引都被允许
> mydata[1:2]
  col4 col2
1    0    3
2    1    4
3    2    5
4    3    6
> mydata['col2']
  col2
1    3
2    4
3    5
4    6
###也支持'$'符号索引
> mydata$col2
[1] 3 4 5 6

attach(),detach()或是with(mydata{})可以辅助索引

Review 数据操作

1. 向量: 正的下标提取对应元素，负的下标去除对应元素；可以用逻辑判断提取切片
2. 数据框: 用名字配合attach() or $
3. 列表: 一种非常灵活的数据格式，往往返回值是列表

x <- list(foo = 1:4, bar = matrix(1:6,nrow=2))
x
x[[1]] ### a vector 
x$foo ### a vector 
x[[2]] ### a matrix 
x$bar ### a matrix

4. Factor因子: 用来分类，计算频数和频率
   factor(x=character(),levels,labels=levels)
   gl()
   function (n, k, length = n * k, labels =1:n, ordered = FALSE)

> gl(3,5)
 [1] 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3
Levels: 1 2 3
> gl(3,1,20)  ### n:水平数;k:每个因子重复的次数;length:结果总长度
 [1] 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2
Levels: 1 2 3

5. paste()可以将多个字符串拼接为一个向量
   paste(…,sep=’’,collapse=NULL,recycle0=FALSE)
   方便批量处理文件，输出文件名称

6. read.table() --txt --输出dataframe
   read.table(file,header=F,sep=’’,quote=’’’,dec=’.’,nrows=-1,skip=0,comment.char=’#’)

7. scan() --复杂文档–输出list
   可以通过what语句控制读取具体格式:

mydata <- scan('data.txt',what=list(Sex='',Weight=0,Height=0)

8. read.csv() --csv
   file,header,sep…

9. write.table()

• data:矩阵或者数据库，写到文件 name.txt
• quote:如果quote为TRUE，字符和因子列就会被 ("")所包围;
• sep是字段分隔符;
• eol为尾行分隔符;
• na为缺失值字符串;

10. cat()
    cat(…,file=’’,sep=’’,append=F);
    append表示是否需要在原文件末尾添加

时间与日期

Date

R区分了日期（年月日）和时间（时分秒）

日期

日期由Date类来表示

t <- Sys.time()
> t
[1] "2021-03-25 13:53:46 CST" ###CST表示时区

日期不包括时间，只表示某年某月某日。
• 内部日期是以1970年1月1日至今的天数来存储
• 日期作为Date类对象来存储，在R里的工作方式是输入一 个字符串, 比如1970-01-01，然后用as.Date()函数转换成日期。
• as.Date默认: 年(4位) -月(2位)-日(2位)
• 或者年(4位)/月(2位)/日(2位)

>x=as.Date('1915-6-16');mode(x);class(x)  
[1] "numeric"  
[1] "Date"  
> y=as.Date('1990/02/17');mode(y);class(y)
[1] "numeric"
[1] "Date"

非默认格式的as.Date:

as.Date('4/26/2001',format='%m/%d/%Y')

具体对照表格:

1. %d – 01~31
2. %a – Mon
3. %A – Monday
4. %m – 00~12
5. %b – Jan
6. %B – Janurary
7. %y – 07
8. %Y – 2007
9. 分隔符具体对应

时间

strptime():
strptime(x,format,tz=’’)

> strptime('October-7-2015 10:40:30',format='%B-%d-%Y %H:%M:%S')
[1] "2015-10-07 10:40:30 CST"

strptime会具体把时间储存为POSIXlt，作为list存储在内存里;

时间操作

去格式化后可以对时间进行操作：

> x$hour
[1] 10
> x$min
[1] 40
> x$sec
[1] 30
> x$mday 
[1] 7
> x$year 
[1] 115

R中时间有两种格式，一种是POSIXlt，另一种是POSIXct；
POSIXlt把时间作为list来存储；而POSIXct把时间作为一个整数（1970年1月1日至今的秒数来表示），因此如果需要把时间存储在数据框中会很有用。

>x<-strptime("October-7-201510:40:30","%B-%d-%Y%H:%M:%S")
>x
[1] "2015-10-07 10:40:30 CST“
> y<- as.POSIXct(x)
>y
[1]"2015-10-0710:40:30CST"
> class(y) #查看类型
[1]"POSIXct""POSIXt"
>mode(y)#查看属性
[1]"numeric"
> unclass(y)
[1]1444185630#1970年1月1日至今的秒数

日期和时间的运算

> x <- as.Date("2015-10-07")
> y <- strptime("9 Jan 2011 11:34:21", "%d %b %Y %H:%M:%S")
> class(x);class(y)
[1] "Date"
[1] "POSIXlt" "POSIXt"
> x-y
Error in x - y : 二进列运算符中有非数值参数
此外: Warning message:不可兼容的方法("-.Date", "-.POSIXt")和"-" 
> x <- as.POSIXlt(x)
> x
[1] "2015-10-07 UTC"
> x-y
Time difference of 1731.851 days

注意不能用POSIXlt与Date做加减，但是可以用POSIXct与Date做加减运算

R里日期和时间运算的好处在于它们能自动处理好一些问题:
• 例如闰年、闰秒、夏令时以及时区
• 以下以2012年为例，2012是闰年，所以它有2月29号，3 月1日和2月28之间的差实际上是2天，而不是像平年那 样相差1天

> x <- as.Date("2012-03-01")
> y <- as.Date("2012-02-28")
> x-y
Time difference of 2 days

小结

• R里有一些特殊的类型用来表示日期和时间，从 而可以对它们进行数值或统计计算;
• 日期用Date类;
• 时间则是POSIXct或是POSIXlt类;
• 字符串可以被转换成日期或时间类型，只要使用 strptime()、as.Date()、as.POSIXlt()或者as.POSIXct() 即可。

控制流

基本概念

1. 语句statement

花括号里的语句

x=1#一条语句
{x=1;print(x);y=sin(x)}
#一组语句 
{
	x=1
	print(x) #一组语句
	y=sin(x)
}

2. 表达式expr

能求值的语句

1+1
2^3
Y='abc'
'ABC'=='ABC' ###返回值为T/F的expr被称为条件cond

3. 序列（seq）是一个向量

1:4
seq(1,10,0.1)
c(1,5,7,9)

条件执行

if结构

R中非零数字的逻辑值均为T

switch结构

switch根据一个表达式的取值选择语句执行,类似于菜单.
语法为: switch(expr,命令1，命令2，…,命令M)

• expr为表达式，其值或为一个整数值或为一个字符串
• 如果expr的值在1…M之间，则执行相应的命令
• 如果expr的值不在1…M之间，返回值为NULL
• 如果命令是有名称的，则当expr等于其中一个命令名 称时，执行相应的命令;否则返回NULL

> x <-2
> switch(x,2+2,mean(1:10),'ABC')
[1] 5.5

>y<-"fruit" 
switch(y,fruit="banana",vegetable="carrot",meat="beef")
[1]"banana“

for循环

重复循环
for(var in seq){statement}

while循环

条件循环
while(cond){statement}

### e.g.1000以内的斐波那契数列

#### repeat
简单重复同一个表达式，通常配合if+break使用，否则会死循环

## Function
### 自定义函数

myfunction <- function(x,y,z){
statements
return(object)
}

## 有关统计分布的函数
R一共提供了4类有关统计分布的函数——
```r
###对于正态分布：
dnorm()——密度函数
rnorm()——*随机数
pnorm()——计算累计分布
qnorm()——计算分位数
###其他分布一样在前缀加上d、r、p、q即可

set.seed()
在很多情况下，我们的确需要同样的随机数出现多次，以便其他人重现我们的结果。

特别是，当我们做的东西里有一些错误或者问题，想要准确追溯到产生那些问题的地方，此时设定一个种子就能追溯问题并且得到相同的结果。

sample()

sum

1. 使用R从指定概率分布中随机取样;
2. sample()从任意向量中进行随机取样;
3. set.seed()随机数生成器;

统计分析

统计数据的四种计量尺度

1. 定类尺度

将对象的某种属性划分为若干类的一种测度；
性别、籍贯、民资等；
对应名义变量，不能计算；

2. 定序尺度

可以分类，可以比较大小；
对应次序变量；
不能加减乘除；

*. 绝对零点/相对零点

绝对零点：零点是客观存在的，例如质量的零点就是0kg;
相对零点：这个零点不是客观存在的，而是人为规定的，例如0度、年份;

3. 定距尺度

间隔尺度，例如温度，年份等；
能分类、计算差距或是比较大小；
定义了相对零点，对应定距变量；
数值，可以加减、不能乘除；

4. 定比尺度

例如成绩（0-100），年龄，利润等；
存在绝对零点，0表示没有/不存在，对应定比变量；
数值，可以加减乘除；

• 定性分析–由定类和定序尺度形成，称为属性数据；（条形图、饼图）
• 定量数据–由定距和定比尺度计算而成，反映事物的数量特征；（直方图、线图、茎叶图）