本文主要是为了从零开始学习和理解R语言，简要介绍了该语言的最重要部分，以快速入门。主要参考文章：

R-Tutorial

R语言程序的编写需要安装R或RStudio，通常是在RStudio中键入代码。但是RStudio个人感觉并不好用，因此本人编写的R语言程序都是在Jupyter Notebook平台使用。具体可以见在 Jupyter Notebook 中使用R语言。R语言和Python，matlab一样都是解释型语言，语法差别不大，容易入门。其他进阶内容见R语言个人笔记

文章目录

• 1 入门基础

• 1.1 基础使用
• 1.2 软件包的安装

• 2 复杂变量

• 2.1 向量基础
• 2.2 操纵向量
• 2.3 数据框dataframe

• 3 高级函数

• 3.1 paste函数
• 3.2 处理日期
• 3.3 制作列连表
• 3.4 列表
• 3.5 If-Else语句
• 3.6 for循环
• 3.7 apply类别函数
• 3.8 使用tryCatch()处理错误

• 4 参考

1 入门基础

1.1 基础使用

运算符

R语言程序都可以当成计算器使用，#在R语言中是注释符，R忽略#之后的一切。

2 + 3 # 加法 5
2 * 3 # 乘法 6
sqrt(36) # 开根号 6
log10(100) # 10为底的对数运算 2
10 / 3 # 除法 3.33333333333333
10 %/% 3 # 整除 3
10 %% 3 # 求余 1

5

6

6

2

3.33333333333333

3

1

赋值运算符

与大多数其他语言不同，R除了使用通常的=运算符赋值外，还使用<-或者->运算符。在R语言中<-或者->运算符就相当于=号，唯一的区别是<-和->指明了运算方向。==表示是否相等，=表示赋值。

a <- 10  # 把10赋值给a
a = 10  # 把10赋值给a
10 -> a  # 把10赋值给a
# 10 = a  # 出错

数据类型
R语言没有专门的步骤来定义变量的类型。R会在后台直观地进行判断变量的类型。我们可以通过class函数来查看变量的数据类型

class(a) # numeric类型
class(1.1) # numeric类型

‘numeric’

‘numeric’

根据分配给变量a的值，R决定将a分配为numeric类型。如果您选择将其更改为字符’10’而不是数字10，则可以执行以下操作：

a <- as.character(a) # 转换a为字符串
print(a)  # 打印a "10"
class(a)  # 数据类型 "character"

[1] "10"

‘character’

当然我们也可以将a从字符串变为数字

a <- as.numeric(a)
print(a)  # 打印a 10
class(a)  # 数据类型 "numeric"

[1] 10

‘numeric’

常用的R语言类如下
变量

• character 字符串
• integer 整数
• numeric 整数+分数
• factor 分类变量，其中每个级别都是一个类别
• logical 布尔
• complex 复数

数据类别

• vector 同类元素的集合
• matrix 矩阵
• data.frame 类似excel中的二维表
• list 列表

我们可以通过as.类型名来改变变量类型

a<-as.matrix(a)
print(a)
class(a)

[,1]
[1,]   10

‘matrix’

a<-as.logical(a)
print(a)
class(a)

[1] TRUE

‘logical’

1.2 软件包的安装

首次安装时，R附带有一组内置软件包，可以直接从R控制台调用它们。但是，由于R是一种开放源代码语言，因此任何人都可以通过编写软件包来为其功能做出贡献。多年来，这些贡献已导致超过5K软件包的清单不断增加。这是从R控制台中安装软件包的方法。注意不要在jupyter notebook中使用该代码，因为要选择cran镜像，很容易崩溃的。

#install.packages("car")  # install car package

现在已经安装了该软件包，您需要对其进行初始化，然后才能调用已安装的软件包随附的函数和数据集。

library(car)  # 初始化包
require(car)  # 另一种初始化方法
#library()  # 查看已经安装好的包
#library(help=car)  # 查看car包的帮助信息

Warning message:
"package 'car' was built under R version 3.6.1"
Loading required package: carData

Warning message:
"package 'carData' was built under R version 3.6.1"

对于R语言可以直接输入代码查询包和函数的介绍信息

#help(merge)  # 查看merge的帮助信息
#?merge  # 从安装包中查找merge信息,和help类似
#??merge  # 模糊搜索
example(merge)  # 展示示例代码

merge> authors <- data.frame(
merge+     ## I(*) : use character columns of names to get sensible sort order
merge+     surname = I(c("Tukey", "Venables", "Tierney", "Ripley", "McNeil")),
merge+     nationality = c("US", "Australia", "US", "UK", "Australia"),
merge+     deceased = c("yes", rep("no", 4)))

merge> authorN <- within(authors, { name <- surname; rm(surname) })

merge> books <- data.frame(
merge+     name = I(c("Tukey", "Venables", "Tierney",
merge+              "Ripley", "Ripley", "McNeil", "R Core")),
merge+     title = c("Exploratory Data Analysis",
merge+               "Modern Applied Statistics ...",
merge+               "LISP-STAT",
merge+               "Spatial Statistics", "Stochastic Simulation",
merge+               "Interactive Data Analysis",
merge+               "An Introduction to R"),
merge+     other.author = c(NA, "Ripley", NA, NA, NA, NA,
merge+                      "Venables & Smith"))

merge> (m0 <- merge(authorN, books))
      name nationality deceased                         title other.author
1   McNeil   Australia       no     Interactive Data Analysis         <NA>
2   Ripley          UK       no            Spatial Statistics         <NA>
3   Ripley          UK       no         Stochastic Simulation         <NA>
4  Tierney          US       no                     LISP-STAT         <NA>
5    Tukey          US      yes     Exploratory Data Analysis         <NA>
6 Venables   Australia       no Modern Applied Statistics ...       Ripley

merge> (m1 <- merge(authors, books, by.x = "surname", by.y = "name"))
   surname nationality deceased                         title other.author
1   McNeil   Australia       no     Interactive Data Analysis         <NA>
2   Ripley          UK       no            Spatial Statistics         <NA>
3   Ripley          UK       no         Stochastic Simulation         <NA>
4  Tierney          US       no                     LISP-STAT         <NA>
5    Tukey          US      yes     Exploratory Data Analysis         <NA>
6 Venables   Australia       no Modern Applied Statistics ...       Ripley

merge>  m2 <- merge(books, authors, by.x = "name", by.y = "surname")

merge> stopifnot(exprs = {
merge+    identical(m0, m2[, names(m0)])
merge+    as.character(m1[, 1]) == as.character(m2[, 1])
merge+    all.equal(m1[, -1], m2[, -1][ names(m1)[-1] ])
merge+    identical(dim(merge(m1, m2, by = NULL)),
merge+              c(nrow(m1)*nrow(m2), ncol(m1)+ncol(m2)))
merge+ })

merge> ## "R core" is missing from authors and appears only here :
merge> merge(authors, books, by.x = "surname", by.y = "name", all = TRUE)
   surname nationality deceased                         title     other.author
1   McNeil   Australia       no     Interactive Data Analysis             <NA>
2   R Core        <NA>     <NA>          An Introduction to R Venables & Smith
3   Ripley          UK       no            Spatial Statistics             <NA>
4   Ripley          UK       no         Stochastic Simulation             <NA>
5  Tierney          US       no                     LISP-STAT             <NA>
6    Tukey          US      yes     Exploratory Data Analysis             <NA>
7 Venables   Australia       no Modern Applied Statistics ...           Ripley

merge> ## example of using 'incomparables'
merge> x <- data.frame(k1 = c(NA,NA,3,4,5), k2 = c(1,NA,NA,4,5), data = 1:5)

merge> y <- data.frame(k1 = c(NA,2,NA,4,5), k2 = c(NA,NA,3,4,5), data = 1:5)

merge> merge(x, y, by = c("k1","k2")) # NA's match
  k1 k2 data.x data.y
1  4  4      4      4
2  5  5      5      5
3 NA NA      2      1

merge> merge(x, y, by = "k1") # NA's match, so 6 rows
  k1 k2.x data.x k2.y data.y
1  4    4      4    4      4
2  5    5      5    5      5
3 NA    1      1   NA      1
4 NA    1      1    3      3
5 NA   NA      2   NA      1
6 NA   NA      2    3      3

merge> merge(x, y, by = "k2", incomparables = NA) # 2 rows
  k2 k1.x data.x k1.y data.y
1  4    4      4    4      4
2  5    5      5    5      5

设置工作目录

工作目录是R可以直接访问以读取文件的参考目录。您可以在不使用完整文件路径的情况下直接将文件读取和写入文件到工作目录。目录名称应使用正斜杠/或反斜杠分隔\，对于Windows也应如此。

# getwd()  # 获得当前工作目录
# setwd(dirname)  # 设置工作目录

如何导入和导出数据

将数据引入R的最常见，最方便的方法是通过.csv文件。有一些软件包可以从excel文件（.xlsx）和数据库中导入数据，但此处不介绍。

a <- 1:3
b <- (1:3)/5
c <- c("row1", "row2", "row3")
# 建立dataframe
data <- data.frame(a, b, c)
data

A data.frame: 3 × 3

# 将data保存为csv文件
write.csv(data, file="d:/data.csv", row.names = FALSE)
# 将data保存为txt文件,sep表示用sep分割列
write.table(data, file ="d:/data.txt", sep =",", row.names =FALSE)

# 读取csv文件
data <- read.csv("d:/data.csv", header=FALSE)
data

A data.frame: 4 × 3

# 读取txt文件
data <- read.table(file ="d:/data.txt", header = TRUE, sep=",", colClasses=c("integer","numeric","character"))
data

A data.frame: 3 × 3

R将直观地找出应该为dataframe中的列分配哪种数据类型。如果要手动分配，则可以通过在read.csv或read.table中使用colClasses参数进行设置，实际上，建议这样做，因为它可以提高导入过程的效率。

2 复杂变量

2.1 向量基础

如何创建一个向量

可以使用Combine函数即c()创建向量。该向量中可以包含的所有类型元素。此外，向量只能保存一种类型的数据，例如字符，数字，逻辑。如果尝试在向量内创建数据类型的混合，例如字符和数字，所有数字都会自动转换为字符。因为数字都可以转换为字符，但是字符不都能转换为数字，如’a’。

vec1 <- c(10, 20, 15, 40)  # 数字向量
vec1
vec2 <- c("a", "b", "c", NA)  # 字符向量
vec2
vec3 <- c(TRUE, FALSE, TRUE, TRUE)  # 逻辑向量
vec3
vec4 <- gl(4, 1, 4, label = c("l1", "l2", "l3", "l4"))  # 因子向量
vec4
vec5 <- c(4111, "2", 4)  # 混合变量
vec5

1. 10
2. 20
3. 15
4. 40
5. 'a'
6. 'b'
7. 'c'
8. NA
9. TRUE
10. FALSE
11. TRUE
12. TRUE
13. l1
14. l2
15. l3
16. l4

Levels:

1. 'l1'
2. 'l2'
3. 'l3'
4. 'l4'
5. '4111'
6. '2'
7. '4'

如何引用向量的元素？

向量的元素可以使用其索引进行访问。向量的第一个元素的索引为1，最后一个元素的索引值为length(vectorName)。这一点和其他语言不一样，R语言索引从1开始。索引变量名[i,j]表示索引从i到j的值。

vec1
length(vec1)  # 4
print(vec1[1])  # 10
print(vec1[1:3])  # 10, 20, 15

1. 10
2. 20
3. 15
4. 40

4

[1] 10
[1] 10 20 15

此外有时候我们需要初始化一个定长的向量，做法如下。

# 生成长度为10的向量，用0填充
numericVector <- numeric(10)
numericVector

1. 0
2. 0
3. 0
4. 0
5. 0
6. 0
7. 0
8. 0
9. 0
10. 0

2.2 操纵向量

子集

vec1
logic1 <- vec1 < 16  # 创建一个逻辑向量，小于16为true，反之false
logic1

1. 10
2. 20
3. 15
4. 40
5. TRUE
6. FALSE
7. TRUE
8. FALSE

vec1[logic1]  # 读取位置为true的元素
vec1[1:2]  # 读取第一个和第二个元素
vec1[c(1,3)]  # 读取第一个和第三个元素
vec1[-1]  # 返回所有元素，除了第一个。-1表示排除第一个元素，和其他语言不一样。

1. 10
2. 15
3. 10
4. 20
5. 10
6. 15
7. 20
8. 15
9. 40

排序

sort(vec1)  # 从小到大排序
sort(vec1, decreasing = TRUE)  # 从大到小排序

1. 10
2. 15
3. 20
4. 40
5. 40
6. 20
7. 15
8. 10

排序也可以使用order()函数实现，该函数以升序返回元素的索引。

vec1[order(vec1)]  # 从小到大
vec1[rev(order(vec1))]  # 从大到小

1. 10
2. 15
3. 20
4. 40
5. 40
6. 20
7. 15
8. 10

创建向量序列和重复值

seq()和rep()函数用于创建自定义向量序列。rep()函数也可用于生成重复字符。

seq(1, 10, by = 2)  # 创建1到10的向量序列，步长为2
seq(1, 10, length=5)  # 创建1到10的向量序列，等间隔获得5个值
rep(1, 5)  # 重复1，次数5次
rep(1:3, 2)  # 重复1到3，次数两次
rep(1:3, each=2)  # 重复1到3，每个数字重复两次

1. 1
2. 3
3. 5
4. 7
5. 9
6. 1
7. 3.25
8. 5.5
9. 7.75
10. 10
11. 1
12. 1
13. 1
14. 1
15. 1
16. 1
17. 2
18. 3
19. 1
20. 2
21. 3
22. 1
23. 1
24. 2
25. 2
26. 3
27. 3

如何删除缺失值

可以使用is.na()函数来处理缺失值，该函数会在缺失值（NA）的位置返回逻辑值为TRUE的逻辑向量

vec2 <- c("a", "b", "c", NA)  # character vector
is.na(vec2)  # missing TRUE
!is.na(vec2)  # missing FALSE
vec2[!is.na(vec2)]  # 返回非NA的元素

1. FALSE
2. FALSE
3. FALSE
4. TRUE
5. TRUE
6. TRUE
7. TRUE
8. FALSE
9. 'a'
10. 'b'
11. 'c'

采样

set.seed(42)  # 设置随机数种子，以
vec1
sample(vec1)  # 随机从vec1中抽取所有数
sample(vec1, 3)  # 随机不放回从vec1中抽取3个数
sample(vec1, 5, replace=T)  # 随机放回从vec1中抽取5个数

1. 10
2. 20
3. 15
4. 40
5. 10
6. 40
7. 15
8. 20
9. 20
10. 40
11. 15
12. 10
13. 40
14. 15
15. 40
16. 15

2.3 数据框dataframe

创建数据框并访问行和列

数据框是执行各种分析的方便且流行的数据对象。诸如read.csv（）之类的导入语句会将数据作为数据帧导入R中，因此保持这种方式很方便。现在，使用我们之前创建的向量创建一个数据框。

vec1
vec2
vec3
vec4

1. 10
2. 20
3. 15
4. 40
5. 'a'
6. 'b'
7. 'c'
8. NA
9. TRUE
10. FALSE
11. TRUE
12. TRUE
13. l1
14. l2
15. l3
16. l4

Levels:

1. 'l1'
2. 'l2'
3. 'l3'
4. 'l4'

# 每一个向量组成一列
myDf1 <- data.frame(vec1, vec2)  
myDf1
myDf2 <- data.frame(vec1, vec3, vec4)
myDf2
myDf3 <- data.frame(vec1, vec2, vec3)
myDf3

A data.frame: 4 × 2

A data.frame: 4 × 3

A data.frame: 4 × 3

内置数据集和基本操作

R带有一组内置数据。为了进一步说明，我们将使用airquality数据集

library(datasets) # 初始化
#library(help=datasets) # 展示数据集信息
# 展示数据集头部六行
head(airquality)

A data.frame: 6 × 6

接来介绍数据集data.frame基础操作

class(airquality)  # dataframe类型
sapply(airquality, class)  # 获得dataframe每一列的类型
str(airquality)  # dataframe的结构

‘data.frame’

'integer' Solar.R 'integer' Wind 'numeric' Temp 'integer' Month 'integer' Day 'integer'

'data.frame': 153 obs. of  6 variables:
 $ Ozone  : int  41 36 12 18 NA 28 23 19 8 NA ...
 $ Solar.R: int  190 118 149 313 NA NA 299 99 19 194 ...
 $ Wind   : num  7.4 8 12.6 11.5 14.3 14.9 8.6 13.8 20.1 8.6 ...
 $ Temp   : int  67 72 74 62 56 66 65 59 61 69 ...
 $ Month  : int  5 5 5 5 5 5 5 5 5 5 ...
 $ Day    : int  1 2 3 4 5 6 7 8 9 10 ...

summary(airquality)  # 数据集各列总结
#fix(airquality)  # 类似excel的方式展示数据集

Ozone           Solar.R           Wind             Temp      
 Min.   :  1.00   Min.   :  7.0   Min.   : 1.700   Min.   :56.00  
 1st Qu.: 18.00   1st Qu.:115.8   1st Qu.: 7.400   1st Qu.:72.00  
 Median : 31.50   Median :205.0   Median : 9.700   Median :79.00  
 Mean   : 42.13   Mean   :185.9   Mean   : 9.958   Mean   :77.88  
 3rd Qu.: 63.25   3rd Qu.:258.8   3rd Qu.:11.500   3rd Qu.:85.00  
 Max.   :168.00   Max.   :334.0   Max.   :20.700   Max.   :97.00  
 NA's   :37       NA's   :7                                       
     Month            Day      
 Min.   :5.000   Min.   : 1.0  
 1st Qu.:6.000   1st Qu.: 8.0  
 Median :7.000   Median :16.0  
 Mean   :6.993   Mean   :15.8  
 3rd Qu.:8.000   3rd Qu.:23.0  
 Max.   :9.000   Max.   :31.0

rownames(airquality)  # dataframe行名
colnames(airquality)  # dataframe列名
nrow(airquality) # 行数
ncol(airquality) # 列数

1. '1'
2. '2'
3. '3'
4. '4'
5. '5'
6. '6'
7. '7'
8. '8'
9. '9'
10. '10'
11. '11'
12. '12'
13. '13'
14. '14'
15. '15'
16. '16'
17. '17'
18. '18'
19. '19'
20. '20'
21. '21'
22. '22'
23. '23'
24. '24'
25. '25'
26. '26'
27. '27'
28. '28'
29. '29'
30. '30'
31. '31'
32. '32'
33. '33'
34. '34'
35. '35'
36. '36'
37. '37'
38. '38'
39. '39'
40. '40'
41. '41'
42. '42'
43. '43'
44. '44'
45. '45'
46. '46'
47. '47'
48. '48'
49. '49'
50. '50'
51. '51'
52. '52'
53. '53'
54. '54'
55. '55'
56. '56'
57. '57'
58. '58'
59. '59'
60. '60'
61. '61'
62. '62'
63. '63'
64. '64'
65. '65'
66. '66'
67. '67'
68. '68'
69. '69'
70. '70'
71. '71'
72. '72'
73. '73'
74. '74'
75. '75'
76. '76'
77. '77'
78. '78'
79. '79'
80. '80'
81. '81'
82. '82'
83. '83'
84. '84'
85. '85'
86. '86'
87. '87'
88. '88'
89. '89'
90. '90'
91. '91'
92. '92'
93. '93'
94. '94'
95. '95'
96. '96'
97. '97'
98. '98'
99. '99'
100. '100'
101. '101'
102. '102'
103. '103'
104. '104'
105. '105'
106. '106'
107. '107'
108. '108'
109. '109'
110. '110'
111. '111'
112. '112'
113. '113'
114. '114'
115. '115'
116. '116'
117. '117'
118. '118'
119. '119'
120. '120'
121. '121'
122. '122'
123. '123'
124. '124'
125. '125'
126. '126'
127. '127'
128. '128'
129. '129'
130. '130'
131. '131'
132. '132'
133. '133'
134. '134'
135. '135'
136. '136'
137. '137'
138. '138'
139. '139'
140. '140'
141. '141'
142. '142'
143. '143'
144. '144'
145. '145'
146. '146'
147. '147'
148. '148'
149. '149'
150. '150'
151. '151'
152. '152'
153. '153'
154. 'Ozone'
155. 'Solar.R'
156. 'Wind'
157. 'Temp'
158. 'Month'
159. 'Day'

153

6

用cbind和rbind增加数据

myDf1
myDf2

A data.frame: 4 × 2

A data.frame: 4 × 3

cbind(myDf1, myDf2)  # 按列合并
rbind(myDf1, myDf1)  # 按行合并

A data.frame: 4 × 5

A data.frame: 8 × 2

dataframe索引

myDf1

A data.frame: 4 × 2

myDf1$vec1  # 提取列vec1
myDf1[, 2]  # 提取数据df[row.num, col.num]

1. 10
2. 20
3. 15
4. 40
5. a
6. b
7. c
8. <NA>

Levels:

1. 'a'
2. 'b'
3. 'c'

myDf1[, c(1,2)]  # 提取第一列和第二列
myDf1[c(1:5), c(1)]  # 提取第一列的1到5行，

A data.frame: 4 × 2

1. 10
2. 20
3. 15
4. 40
5. <NA>

subset和which函数

head(airquality)

A data.frame: 6 × 6

下面代码选择day==1的列，但结果不显示Temp列

subset(airquality, Day == 1, select = -Temp)

A data.frame: 5 × 5

which函数选择day==1的列的索引

which(airquality$Day==1)
airquality[which(airquality$Day==1), -c(4)]

1. 1
2. 32
3. 62
4. 93
5. 124

A data.frame: 5 × 5

采样

随机从dataframe里分割样本，比如分割训练集和测试集

set.seed(100)
trainIndex <- sample(c(1:nrow(airquality)), size=nrow(airquality)*0.7, replace=F)  # 获得验证集数据，比例0.7
trainIndex

1. 102
2. 112
3. 151
4. 4
5. 55
6. 70
7. 98
8. 135
9. 7
10. 43
11. 140
12. 51
13. 25
14. 2
15. 68
16. 139
17. 48
18. 32
19. 85
20. 91
21. 121
22. 16
23. 116
24. 93
25. 45
26. 30
27. 128
28. 130
29. 87
30. 95
31. 97
32. 124
33. 29
34. 92
35. 31
36. 54
37. 41
38. 105
39. 117
40. 24
41. 144
42. 145
43. 63
44. 65
45. 9
46. 153
47. 20
48. 14
49. 78
50. 88
51. 3
52. 36
53. 27
54. 46
55. 59
56. 100
57. 69
58. 47
59. 149
60. 96
61. 138
62. 12
63. 142
64. 132
65. 56
66. 22
67. 82
68. 53
69. 103
70. 5
71. 44
72. 28
73. 52
74. 141
75. 42
76. 15
77. 57
78. 79
79. 37
80. 26
81. 114
82. 120
83. 109
84. 122
85. 111
86. 35
87. 58
88. 74
89. 137
90. 123
91. 90
92. 118
93. 75
94. 127
95. 101
96. 18
97. 8
98. 99
99. 77
100. 143
101. 19
102. 119
103. 23
104. 72
105. 66
106. 84
107. 106

# 训练数据
nrow(airquality[trainIndex, ])
# 测试数据
nrow(airquality[-trainIndex, ])

107

46

合并数据

dataframe可以由公共列变量合并。在执行合并之前，不必对数据帧进行排序。如果“by”列具有不同的名称，则可以使用by.x和by.y指定它们。内部/外部联接、左联接和右联接可以使用merge()的all、all.x、all.y参数完成。在R控制台中查看更多关于example(merge)的信息。

myDf1
myDf2

A data.frame: 4 × 2

A data.frame: 4 × 3

merge(myDf1, myDf2, by="vec1")  # 以vec1合并

A data.frame: 4 × 4

3 高级函数

3.1 paste函数

paste()是一种拼接字符串并使用分隔符进行自定义的方法。有了清晰的理解，就可以方便地创建可以动态修改的长而复杂的字符串。

paste("a", "b")  # 拼接字符串'a'和'b'包含空格 "a b"
paste0("a", "b")  # 无空格拼接字符串'a'和'b', "ab"
paste("a", "b", sep="")  # sep设置拼接符是什么，类似paste0
paste(c(1:4), c(5:8), sep="")  # "15" "26" "37" "48"
paste(c(1:4), c(5:8), sep="", collapse="")  # "15263748"
paste0(c("var"), c(1:5))  # "var1" "var2" "var3" "var4" "var5"
paste0(c("var", "pred"), c(1:3))  # "var1" "pred2" "var3"
paste0(c("var", "pred"), rep(1:3, each=2))  # "var1" "pred1" "var2" "pred2" "var3" "pred3

‘a b’

‘ab’

‘ab’

1. '15'
2. '26'
3. '37'
4. '48'

‘15263748’

1. 'var1'
2. 'var2'
3. 'var3'
4. 'var4'
5. 'var5'
6. 'var1'
7. 'pred2'
8. 'var3'
9. 'var1'
10. 'pred1'
11. 'var2'
12. 'pred2'
13. 'var3'
14. 'pred3'

3.2 处理日期

dateString <- "07/02/2021"
myDate <- as.Date(dateString, format="%d/%m/%Y") # 设置字符串
class(myDate)  # 类别 "date"
myDate

‘Date’

2021-02-07

3.3 制作列连表

通过R语言的table函数可以制作列连表。

myDf1

A data.frame: 4 × 2

table(myDf1)

vec2
vec1 a b c
  10 1 0 0
  15 0 0 1
  20 0 1 0
  40 0 0 0

同样，对于dataframe，要在行中显示的变量将作为table()的第一个参数，而列变量将作为第二个参数。

table(airquality$Month[c(1:60)], airquality$Temp[c(1:60)])

56 57 58 59 61 62 64 65 66 67 68 69 72 73 74 75 76 77 78 79 80 81 82 84 85
  5  1  3  2  2  3  2  1  1  3  2  2  2  1  1  2  0  1  0  0  1  0  1  0  0  0
  6  0  0  0  0  0  0  0  1  0  1  0  0  1  2  1  1  4  3  2  2  2  0  2  1  1
   
    87 90 92 93
  5  0  0  0  0
  6  2  1  1  1

3.4 列表

列表非常重要。如果需要捆绑不同长度和类别的对象，则可以使用列表来实现。

myList <- list(vec1, vec2, vec3, vec4)
myList

1. 10
2. 20
3. 15
4. 40
5. 'a'
6. 'b'
7. 'c'
8. NA
9. TRUE
10. FALSE
11. TRUE
12. TRUE
13. l1
14. l2
15. l3
16. l4

Levels:

1. 'l1'
2. 'l2'
3. 'l3'
4. 'l4'

3.5 If-Else语句

if else语句结构如下

if(checkConditionIfTrue) {
  ....statements..
  ....statements..
} else {   # place the 'else' in same line as '}'
  ....statements..
  ....statements..
}

x<-2
if(x>1)
    {
    print(x)
}else
    {
    print("None")
}

[1] 2

3.6 for循环

格式如下

for(counterVar in c(1:n)){
  .... statements..
}

for (x in c(1:5))
    {
    print(x)
}

[1] 1
[1] 2
[1] 3
[1] 4
[1] 5

3.7 apply类别函数

apply

apply()：按数据行或矩阵按行或列应用函数。

myData <- matrix(seq(1,16), 4, 4)  # 生成一个矩阵
myData

A matrix: 4 × 4 of type int

apply(myData, 1, FUN=min)  # 1代表行，按行应用min函数
apply(myData, 2, FUN=min)  # 2代表列，按列应用min函数

1. 1
2. 2
3. 3
4. 4
5. 1
6. 5
7. 9
8. 13

apply(data.frame(1:5), 1, FUN=function(x) {x^2} ) # square of 1,2,3,4,5

1. 1
2. 4
3. 9
4. 16
5. 25

lapply()

lapply()：将函数应用于列表中的每个元素，或将其应用于数据框的列，并将结果作为列表返回

lapply(airquality, class)

'integer' $Solar.R 'integer' $Wind 'numeric' $Temp 'integer' $Month 'integer' $Day 'integer'

sapply

sapply()：将函数应用于列表的每个元素，或将其应用于dataframe的列，并将结果作为向量返回。

sapply(airquality, class)

'integer' Solar.R 'integer' Wind 'numeric' Temp 'integer' Month 'integer' Day 'integer'

3.8 使用tryCatch()处理错误

该trycatch()函数在花括号内编写了三个块，try()我们前面看到的函数一样，可以在第一组花括号内使用多行代码。如果在第一个块的任何一条语句中遇到错误，则生成的错误消息将存储在err错误处理函数使用的变量（请参见下面的代码）中。您可以选择打印出此错误消息，进行其他计算或执行任何所需的操作。您甚至还可以在此函数内执行一组完全不同的逻辑，而不涉及错误消息。最后一组finally而不管是否发生错误，都必须执行。您可以选择忽略将任何语句完全添加到此部分。

tryCatch(
    {1 <- 1; print("Lets create an error")
    }, # First block
error=function(err){
    print(err); print("Error Line")
},  # Second Block(optional)
finally = {
    print("finally print this")}
)# Third Block(optional)

<simpleError in 1 <- 1: (do_set)赋值公式左手不对>
[1] "Error Line"
[1] "finally print this"

4 参考

• R-Tutorial
• 在 Jupyter Notebook 中使用R语言
• R语言个人笔记