R学习笔记

封面作者:NOEYEBROW

简介

R是一种用于统计计算和图形绘制的编程语言和软件环境. 它广泛应用于数据分析、统计建模和可视化等领域; 可以在官网下载和安装R

基础语法

# 文件命名
# xxx.R

# 注释
# R的注释同Python一样使用#号

# 变量
# 1. 变量名可以包含字母(区分大小写)、数字、下划线、点
# 2. 变量名不能以数字、下划线开头; 如果以点开头, 后面必须跟字母
# 3. 变量名不能是R的保留字, 如TRUE、FALSE、NULL等
name <- "Leaf"
age <- 30
is_student <- is_boy <- TRUE # 批量赋值
# 也可以使用 = 进行赋值, 但不推荐
# 还可以把箭头反向
TRUE -> is_bnuer

# 打印
name # 自动打印, 仅在顶层可用
print(name) # 使用print()函数

# 全局变量 (定义在脚本顶层的变量)
# 由于R不区分变量声明和变量赋值, 所以要在函数中修改一个全局变量需要显式声明
var <- 0
print_global_var <- function() {
    print(var)
}
print_global_var() # 0
print_local_var <- function() {
    var <- 1 # 局部变量
}
print_local_var()
print(var) # 0 (没有被修改)
modify_global_var <- function() {
    var <<- 2
}
modify_global_var()
print(var) # 2

数据类型

R是一种动态类型语言, 变量可以在运行时改变类型; 使用 class() 函数可以查看变量的类型

基础类型

# 数字 numeric
x <- 1.5
y <- 2
z <- x + y

# 整数 integer (用L后缀表示)
a <- 1L
b <- 2L
c <- a + b

# 复数 complex
d <- 1 + 2i
e <- 3 + 4i
f <- d + e

# 字符 character (string)
g <- 'Hello' # 单引号
h <- "World" # 双引号
i <- paste(g, h, sep = ", ") # 字符串拼接, 不可以使用+号
intro <- 'I am a student,
learning \'R\' programming.' # 多行字符串
cat(intro) # cat()函数专用于打印字符串, 可以在控制台显示多行文本 (而不是\n); 还可以传入多个参数 (类似 paste())
nchar(intro) # 计算字符串长度
grepl("student", intro) # 检查字符串中是否包含"student"

# 逻辑 logical (boolean)
j <- TRUE
k <- FALSE
j & k # 逻辑与, 结果为FALSE
j | k # 逻辑或, 结果为TRUE
!j # 逻辑非, 结果为FALSE

R的与/或逻辑运算符有 & 和 | , 以及它们的短路版本 && 和 ||; 前者在处理向量时会逐元素比较, 返回新的逻辑向量, 如 c(TRUE, FALSE) & c(TRUE, TRUE) 返回 c(TRUE, FALSE); 后者则在第一个元素确定结果后不再计算第二个元素, 如 c(TRUE, FALSE) && c(TRUE, TRUE) 返回 TRUE。

向量

向量 Vector 是R语言中最基本、最重要的数据结构之一, 类似于一维数组

所有元素必须是相同类型, 如果传入不同类型, 会按照 logical → integer → numeric → character 的优先级进行隐式类型转换

str_vector <- c("apple", "banana", "cherry")
num_vector <- c(1, 2, 3)
class(num_vector) # "numeric" # 向量的类型
class(str_vector) # "character"
length(num_vector) # 3 # 向量的长度
sort(num_vector) # 排序, 返回新的向量, 不修改原向量

# 向量拼接
new_vector <- c(c(1, 2), c(3, 4))

# !!!特别注意: R中的向量元素索引从1开始
vec <- c(10, 20, 30, 40, 50)
vec[1]        # 第1个元素 → 10
vec[1] <- 5   # 修改元素
vec[c(1,3)]   # 第1和第3个 → c(10, 30)
vec[1:3]      # 前3个 → c(10,20,30)
vec[-1]       # 除了第1个 → c(20,30,40,50)
vec[vec > 30] # 逻辑索引：大于30的元素 → c(40,50)

# 使用 : 或 seq() 便捷地创建数字向量
1:5 # 1, 2, 3, 4, 5
5:1 # 5, 4, 3, 2, 1
1.5:5.0 # 1.5, 2.5, 3.5, 4.5
seq(1, 5) # 1, 2, 3, 4, 5
seq(5, 1) # 5, 4, 3, 2, 1
seq(1, 5, by = 2) # 1, 3, 5
seq(5, 1, by = -1) # 5, 4, 3, 2, 1

# 使用 %in% 运算符判断一个元素是否在某个向量中
1 %in% c(1, 2, 3) # TRUE
4 %in% c(1, 2, 3) # FALSE

# 使用 rep() 重复元素
rep(1, times = 3) # 1, 1, 1
rep(c("a", "b"), times = 2)  # "a","b","a","b"
rep(c("a", "b"), each = 2)   # "a","a","b","b"

# 可以给向量的元素命名
ages <- c("Alice" = 25, "Bob" = 30, "Charlie" = 35)
# 或
ages <- c(25, 30, 35)
names(ages) <- c("Alice", "Bob", "Charlie")
# 使用元素的名称提取值
ages["Alice"]  # 25

列表

列表 List 是一种可以包含不同类型元素的集合, 类似于Python中的列表或JavaScript中的数组

# 创建列表
my_list <- list("leaf", "pink", 18)
length(my_list) # 3
"leaf" %in% my_list # TRUE
class(my_list) # "list"

# 添加项目
num_list <- list(1, 2, 3)
new_list <- append(num_list, 4) # 返回新的列表, 不修改原列表
print(num_list) # 1, 2, 3
print(new_list) # 1, 2, 3, 4
append(num_list, 4, after = 2) # 1, 2, 4, 3

# 删除项目
num_list <- list(1, 2, 3, 4)
num_list[-2] # 删除第2个元素, 返回新的列表, 不修改原列表

# 索引
my_list <- list("leaf", "pink", 18)
my_list[1] # "leaf"
my_list[1:2] # "leaf", "pink"
my_list[c(1, 3)] # "leaf", 18
my_list[c(TRUE, FALSE, TRUE)] # "leaf", 18

# 拼接
c(my_list, list("red", "blue")) # "leaf", "pink", 18, "red", "blue"

# 可以给列表的元素命名
my_list <- list(
    name = "leaf",
    color = "pink",
    age = 18
)
# 或
my_list <- list("leaf", "pink", 18)
names(my_list) <- c("name", "color", "age")
# 使用元素的名称提取值
my_list$name # "name" 只会被当作字面量处理; 提取单个值
my_list[["color"]] # 等价于 $, 但可以使用变量索引; 提取单个值
my_list[c("name", "age")] # 单括号用于提取多个值, 返回列表

# 循环
for (item in my_list) {
    print(item)
}
for (n in names(my_list)) {
    print(my_list[[n]])
}

矩阵

矩阵 Matrix 是具有列和行的二维数据集

# 创建矩阵
num_matrix <- matrix(1:6, nrow = 2, ncol = 3)
# !!!注意: 数据是按 1,1 - 2,1 - 1,2 - 2,2 - 1,3 - 2,3 的顺序填充的 (即竖向填充)
str_matrix <- matrix(c("apple", "banana", "cherry", "orange"), nrow = 2, ncol = 2)
"banana" %in% str_matrix # TRUE
dim(num_matrix) # 2 3
length(num_matrix) # 6
nrow(num_matrix) # 2
ncol(num_matrix) # 3

# 访问数据
num_matrix[1, 2] # 第1行第2列 → 3
num_matrix[2,] # 第2行 -> 2, 4, 6
num_matrix[,2] # 第2列 -> 3, 4
num_matrix[1, c(2,3)] # 第1行第2和第3列 -> 3, 5
num_matrix[,c(2,3)] # 第2列和第3列 -> matrix(3, 4, 5, 6, nrow = 2, ncol = 2)

# 添加行和列
new_matrix <- rbind(num_matrix, c(7, 8, 9)) # 添加新行, 不修改原矩阵
new_matrix <- cbind(new_matrix, c(10, 11)) # 添加新列, 不修改原矩阵

# 删除行和列
new_matrix <- new_matrix[-1, ] # 删除第1行, 不修改原矩阵
new_matrix <- new_matrix[, -c(2,3)] # 删除第2列和第3列, 不修改原矩阵

# 遍历
for (i in 1:nrow(new_matrix)) {
    for (j in 1:ncol(new_matrix)) {
        print(new_matrix[i, j])
    }
}

# 组合矩阵
matrix1 <- matrix(c(1,2,3,4), nrow = 2, ncol = 2)
matrix2 <- matrix(c(5,6,7,8), nrow = 2, ncol = 2)
combined_matrix <- rbind(matrix1, matrix2)
dim(combined_matrix) # 4 2
combined_matrix <- cbind(matrix1, matrix2)
dim(combined_matrix) # 2 4

# 矩阵转置
num_matrix <- matrix(1:6, nrow = 2, ncol = 3)
dim(t(num_matrix)) # 3 2

# 矩阵加减
num_matrix + 1 # 每个元素加1
num_matrix - 1 # 每个元素减1

# 矩阵乘法
num_matrix %*% t(num_matrix) 

# 矩阵求逆 (矩阵必须是方阵、可逆)
solve(matrix(1:9, nrow = 3, ncol = 3))

数组

数组 Array 是一种可以包含多维数据的集合

# 创建数组
my_array <- array(1:24, dim = c(2, 3, 4)) # 2x3x4, 3维数组
25 %in% my_array # FALSE
dim(my_array) # 2 3 4
length(my_array) # 24

# 访问数据
my_array[1, 2, 3] # 15
my_array[2, , 1] # 2 4 6
my_array[, 2, 2] # 9 10
my_array[c(1, 2), c(2, 3), 1] # 3 5, 4 6

# 循环
for (i in 1:dim(my_array)[1]) {
    for (j in 1:dim(my_array)[2]) {
        for (k in 1:dim(my_array)[3]) {
            print(my_array[i, j, k])
        }
    }
}
for (item in my_array) {
    print(item)
}

数据框

数据框 DataFrame 是一种表格数据结构, 由多列组成, 每列可以包含不同类型的数据

# 创建数据框
my_df <- data.frame(
    name = c("Alice", "Bob", "Charlie"),
    age = c(25, 30, 35),
    is_student = c(TRUE, FALSE, TRUE)
) # 注: name、age、is_student 分别都是一列
summary(my_df) # 进行描述统计
str(my_df) # 获取数据框的元素及其类型等信息
dim(my_df) # 3 3
nrow(my_df) # 3
ncol(my_df) # 3
length(my_df) # 3 (列数)

# 访问数据
my_df$name # "Alice", "Bob", "Charlie"
my_df[["name"]] # "Alice", "Bob", "Charlie"
my_df[1] # 单括号访问将返回新的数据框, 和上面列表的逻辑相同; 提取第一列 (name)
my_df[1, ] # 提取第一行 (name)
my_df[, 1] # 提取第一列 (name)
my_df[c(1, 3), c("name", "age")] # 第一和第三行的姓名和年龄

# 添加行和列
my_df <- rbind(my_df, data.frame(name = "David", age = 40, is_student = FALSE))
my_df <- cbind(my_df, height = c(160, 175, 180, 170))

# 删除行和列
new_df <- my_df[-1, ] # 删除第一行
new_df <- my_df[, -3] # 删除第三列
new_df <- my_df[-c(1, 2), ] # 删除第一和第二行
new_df <- my_df[-1,-3] # 删除第一行和第三列

# 循环
for (i in 1:nrow(my_df)) {
    print(my_df[i, ])
}
for (i in 1:ncol(my_df)) {
    print(my_df[, i])
}

# 组合
rbind(my_df, data.frame(
    name = "Eve",
    age = 28,
    is_student = FALSE
)) # 行绑定
cbind(my_df, data.frame(
    height = c(160, 175, 180, 170)
)) # 列绑定

因子

因子 Factor 是一种用于表示分类数据的数据结构

# 创建因子
my_factor <- factor(c("male", "female", "female", "others", "male"))
my_factor
# [1] male   female female others male
# Levels: female male others
levels(my_factor) # "female", "male", "others"
length(my_factor) # 5
nlevels(my_factor) # 3

# 在创建因子时指定分类值
my_factor <- factor(
    c("male", "female", "female", "others", "male"),
    levels = c("female", "male", "others", "unknown")
)
nlevels(my_factor) # 4

# 访问元素
my_factor[1] # "male"
my_factor[2] # "female"
my_factor[c(1, 2)] # "male", "female"
my_factor[1] <- "unknown" # 如果值不包含在 levels 里, 会报错

类型转换

# 转换为数字
as.numeric("123") # 123
as.numeric("abc") # NA (非数字字符串)
# 特别的, class(as.numeric("abc"))结果是"numeric", 类似于JavaScript对NaN的处理
as.numeric(1L) # 1
as.numeric(TRUE) # 1
as.numeric(FALSE) # 0

# 转换为整数
as.integer(1.5) # 1 (即直接截断)

# 转换为复数
as.complex("1+2i") # 1+2i
as.complex(1) # 1+0i

# 转换为字符
as.character(123) # "123"
as.character(TRUE) # "TRUE"

# 转换为逻辑
as.logical(1) # TRUE
as.logical(0) # FALSE
as.logical("TRUE") # TRUE
as.logical("FALSE") # FALSE

# 转换为高级类型
as.factor(my_list)
as.vector(my_factor)
as.list(my_factor)
as.data.frame(cbind(a=1:2,b=3:4))

类型检查

函数	描述
is.numeric()	检查是否为数字
is.integer()	检查是否为整数
is.character()	检查是否为字符
is.logical()	检查是否为逻辑值
is.factor()	检查是否为因子
is.vector()	检查是否为向量
is.list()	检查是否为列表
is.data.frame()	检查是否为数据框
is.null()	检查是否为NULL

数学运算

# 基本运算
1 + 1 # 加法 =2
2 - 1 # 减法 =1
3 * 2 # 乘法 =6
4 / 2 # 除法 =2
5 ^ 2 # 乘方 =25
5 %% 2 # 取余 =1
5 %/% 2 # 整除 =2
sqrt(16) # 4
abs(-5) # 5
ceiling(4.2) # 5
floor(4.8) # 4

# 四舍五入
# !!!特别注意: R的四舍五入是"向最近的偶数舍入", 目的是减少统计偏差
round(4.5) # 4
round(5.5) # 6
round(3.14159, digits = 2) # 3.14

# 比较
1 == 1 # TRUE
1 != 2 # TRUE
1 < 2 # TRUE
1 > 2 # FALSE
1 <= 1 # TRUE
1 >= 1 # TRUE

# 内置函数
sort(c(2, 1, 3)) # 1 2 3
max(c(1, 2, 3)) # 3
which.max(c(1, 3, 2)) # 2 (索引)
min(c(1, 2, 3)) # 1
which.min(c(1, 2, 3)) # 1 (索引)
sum(c(1, 2, 3)) # 6
mean(c(1, 2, 3)) # 2
median(c(1, 2, 3, 4)) # 2.5
quantile(c(1, 2, 3, 4), c(0.25, 0.5, 0.75)) # 1.25 2.00 3.00

可以直接对向量和矩阵等进行逐元素计算

x <- c(1, 2, 3)
y <- c(4, 5, 6)

x + y        # c(5, 7, 9)
x * 2        # c(2, 4, 6)
sqrt(x)      # c(1.0, 1.41, 1.73)

# 如果长度不匹配，会循环补齐
c(1, 2, 3) + c(1, 2) # 2 4 4
# 解释：c(1,2,3) + c(1,2,1) → 因为 1,2 被重复补齐

m <- matrix(1:6, nrow = 2)
m + 1

条件和循环

# if ... else ...
if (x > y) {
  print("x is greater than y")
} else if (x < y) {
  print("x is less than y")
} else {
  print("x is equal to y")
}

# while
i <- 1
while (i <= 5) {
  print(i)
  i <- i + 1
}
j <- 1
while (j <= 5) {
    j <- j + 1
    if (j == 3) {
        next # 跳过本次循环, 同其他语言的 continue
    }
    if (j == 5) {
        break # 终止循环
    }
    print(j)
} # 打印: 2、4

# for
for (i in 1:5) { # 遍历向量
  print(i)
}
for (i in list("a", "b", "c")) { # 遍历列表
  print(i)
}
# for 同样可以使用 next 和 break

函数

# 定义函数
add <- function(x, y) {
  return (x + y) # R中的 return 更像一个函数调用而不是语句
}

# R会对参数数量进行检查, 如果调用时参数数量不匹配, 会报错
add(1, 2) # 3
add(1)    # 错误: 参数数量不匹配

# 默认参数
add_with_default <- function(x, y = 2) {
  return (x + y)
}
add_with_default(1) # 3

# 具名调用
add_with_default(y = 3, x = 1) # 4
add_with_default(y = 3) # 报错
# 具名调用和按顺序调用可以混用, 类似 Python

内置函数补充

# warning(): 用于发出警告信息, 不会中断程序
warning("This is a warning message")

# stop(): 用于发出错误信息, 会终止程序
stop("This is an error message")

绘图 🚧