0. 变量名

R 语言的有效的变量名称由字母，数字以及点号 . 或下划线 _ 组成

1. 不能以数字和下划线 _开头
2. . 号开头后面不能跟着数字
3. 区分大小写
4. 不要使用保留名

1.基本数据类型

1.1 数值型

# 一般数值
x <- 10       # 整数(实际存储为浮点数)
y <- 3.14     # 浮点数
# 科学计数（e,E都可以使用）
large_num <- 2.5e6    # 等于 2.5 * 10^6，表示2500000
small_num <- 3.1E-4   # 等于 3.1 * 10^-4，表示0.00031

1.2 整型

和数值型整数的区别就是，整型占往往用的内存更少（4字节，数值型是8字节）

x <- 5L  
y <- -6L

1.3 复数型

# 使用 complex() 函数创建复数
z1 <- complex(real = 3, imaginary = 4) 
# 使用 1i 表示虚数单位
z2 <- 2 + 3i  # 创建复数 2 + 3i

1.4 逻辑型

要大写

x <- TRUE
y <- FALSE

1.5 字符型

text1 <- "Hello, World!"
text2 <- 'R语言字符型'

2.复合数据类型

2.1 向量

向量是最基本的复合数据类型(一维)，向量中的所有元素必须是相同的数据类型，可以是以下几种

# 数字型向量（Numeric）
numeric_vector <- c(1.5, 2.5, 3.5, 4.5, 5.5)

# 字符型向量（Character）
character_vector <- c("a", "b", "c", "d", "e")

# 逻辑型向量（Logical）
logical_vector <- c(TRUE, FALSE, TRUE)

# 整数型向量（Integer）
integer_vector <- c(1L, 2L, 3L, 4L, 5L)

# 复杂型向量（Complex）
complex_vector <- c(1+2i, 3-4i, 5+6i, 7-8i, 9+10i)

可以使用typeof()或class()函数来查看向量的类型：

typeof(numeric_vector)  # 返回 "double"
class(character_vector)  # 返回 "character"

向量操作

元素访问：可以通过索引访问向量的元素（索引从1开始）

numeric_vector[1]  # 返回 1.5

向量运算：可以对向量进行数学运算，这些运算会逐元素执行。

numeric_vector + 2  # 每个元素加2，结果为 c(3.5, 4.5, 5.5, 6.5, 7.5)

逻辑操作：可以对逻辑向量进行与（&）、或（|）操作。

logical_vector & c(TRUE, TRUE, FALSE)  # 结果为 c(TRUE, FALSE, FALSE)

如果长的对象长度是短的对象长度的整倍数，R会将较短的向量自动扩展（重复）以匹配较长的向量。这种特性称为“回收规则”（recycling rule）。

向量的常用函数

length()：返回向量的长度。

sum()：计算向量的所有元素之和（适用于数值向量）。

mean()：计算向量的平均值（适用于数值向量）。

sort()：对向量进行排序。

sort(x, decreasing = FALSE, na.last = TRUE)

• x：要排序的向量。
• decreasing：逻辑值，默认为 FALSE，表示升序排列；如果为 TRUE，则表示降序排列。
• na.last：控制 NA 值的位置，默认为 TRUE，表示将 NA 值放在最后；如果为 FALSE，则将 NA 值放在最前面；如果为 NA，则去除所有 NA 值。

unique()：返回向量中的唯一值，即去重复，类似python中的set作用

2.2 矩阵

矩阵是一个二维的数据结构，它是一个由行和列组成的元素集合，所有元素的类型必须相同。

mat <- matrix(data, nrow=number_of_rows, ncol=number_of_columns, byrow=logical_value)

data: 用于填充矩阵的数据。

nrow: 矩阵的行数。

ncol: 矩阵的列数。

byrow: 是否按行填充（默认为按列填充）

# 创建一个2x3的矩阵，按列填充
mat <- matrix(1:6, nrow = 2, ncol = 3)
print(mat)

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

矩阵操作

矩阵访问：使用方括号[]来访问矩阵中的元素。格式为matrix[row, col]，其中row表示行，col表示列。

mat[1, 2]  # 访问第一行第二列的元素
mat[1, ] # 选择第一行
mat[, 2] # 选择第二列
mat[1:2, ] # 子矩阵提取 

访问的同时也可以修改：matrix[row, col] <- new_value

行列绑定:

• rbind(): 按行绑定，将多个矩阵或向量合并为一个矩阵。
• cbind(): 按列绑定，将多个矩阵或向量合并为一个矩阵。

# 创建两个矩阵
mat1 <- matrix(1:6, nrow = 2)
mat2 <- matrix(7:12, nrow = 2)

# 按行绑定
mat_rbind <- rbind(mat1, mat2)
print(mat_rbind)

# 按列绑定
mat_cbind <- cbind(mat1, mat2)
print(mat_cbind)

矩阵运算：

# 创建两个矩阵
mat1 <- matrix(1:4, nrow = 2)
mat2 <- matrix(5:8, nrow = 2)

# 矩阵加法
mat_add <- mat1 + mat2
print(mat_add)

# 矩阵减法
mat_sub <- mat1 - mat2
print(mat_sub)

# 逐元素乘法
mat_mult <- mat1 * mat2
print(mat_mult)

# 逐元素除法
mat_div <- mat1 / mat2
print(mat_div)

# 矩阵乘法(线性代数)
mat_product <- mat1 %*% mat2
print(mat_product)

矩阵的常用函数

矩阵转置：矩阵的转置将行变为列，列变为行。

# 矩阵转置
mat <- matrix(1:6, nrow = 2)
transposed_mat <- t(mat)
print(transposed_mat)

求逆矩阵：solve()函数用于求解矩阵的逆矩阵，适用于方阵（行数和列数相等）。

# 求逆矩阵
square_mat <- matrix(c(1, 2, 3, 4), nrow = 2)
inverse_mat <- solve(square_mat)
print(inverse_mat)

矩阵的行列式：det()函数计算方阵的行列式。

# 计算行列式
determinant <- det(square_mat)
print(determinant)

矩阵的秩：qr()函数可以用来计算矩阵的秩。

# 矩阵的秩
rank_mat <- qr(square_mat)$rank
print(rank_mat)

特征值和特征向量：eigen()函数计算方阵的特征值和特征向量）。

# 计算特征值和特征向量
eigen_result <- eigen(square_mat)
print(eigen_result$values)    # 特征值
print(eigen_result$vectors)   # 特征向量

2.3 数组

数组是用于存储相同数据类型的多维数据结构。数组与向量类似，但它可以有多个维度，比如二维数组（矩阵）或三维及更高维的数组。

array(data = NA, dim = length(data), dimnames = NULL)

ata：要填充数组的元素（通常是一个向量）。

dim：数组的维度。可以是一个向量，表示每个维度的大小。

dimnames：数组中每个维度的名称（可选）。

data <- 1:18
dim_names <- list(c("Row1", "Row2", "Row3"), c("Col1", "Col2", "Col3"), c("Matrix1", "Matrix2"))
my_array <- array(data, dim = c(3, 3, 2), dimnames = dim_names)
print(my_array)

, , Matrix1

     Col1 Col2 Col3
Row1    1    4    7
Row2    2    5    8
Row3    3    6    9

, , Matrix2

     Col1 Col2 Col3
Row1   10   13   16
Row2   11   14   17
Row3   12   15   18

数组的操作

数据的运算

与之前的类似，长的对象长度是短的对象长度的整倍数，R会将较短的向量自动扩展（重复）以匹配较长的向量。

# 创建两个3x3x2的数组
array1 <- array(1:18, dim = c(3, 3, 2))
array2 <- array(18:1, dim = c(3, 3, 2))

# 加法
sum_array <- array1 + array2

# 减法
diff_array <- array1 - array2

# 乘法
prod_array <- array1 * array2

# 除法
div_array <- array1 / array2

# 与标量的运算
scalar_add <- array1 + 5

数组的访问

单个元素的访问：

element <- array1[2, 3, 1]

选择子数组：

sub_array <- array1[,,2]

数组的维度操作

dim()函数：获取或设置数组的维度。

dim(array1) # 获取数组的维度
dim(array1) <- c(9, 2) # 修改数组的维度

dimnames()函数：获取或设置数组的维度名称。

dimnames(array_named) # 获取维度名称
dimnames(array1) <- list(c("A", "B", "C"), c("X", "Y", "Z"), c("M1", "M2")) # 设置维度名称

数组的常用函数

apply()函数：apply()函数可以沿数组的任一维度应用函数（如求和、平均值等）：

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

# 创建一个3x3x2的数组
array1 <- array(1:18, dim = c(3, 3, 2))

# 沿第一个维度求和
sum_result <- apply(array1, 1, sum)
print(sum_result)

# 沿第二个维度计算平均值
mean_result <- apply(array1, 2, mean)
print(mean_result)

2.4 数据框

数据框是一种用于存储表格数据的结构，它的每一列可以包含不同的数据类型（如数值、字符、因子等）。

df <- data.frame(
  Name = c("Alice", "Bob", "Charlie"),
  Age = c(25, 30, 35),
  Salary = c(50000, 55000, 60000)
)

数据框操作

查看数据框结构

str(df)

'data.frame':	3 obs. of  3 variables:
 $ Name  : chr  "Alice" "Bob" "Charlie"
 $ Age   : num  25 30 35
 $ Salary: num  50000 55000 60000

访问数据框中的列

df$Name  # 访问 Name 列, 返回一个向量
df[["Name"]]  # 访问 Name 列, 返回一个向量
df["Name"]  # 访问 Name 列, 返回一个数据框
df[1]  # 访问第 1 列，结果是一个数据框

子集操作

df[1:2, ]  # 选择前两行
df[, 1:2]  # 选择前两列
df[df$Age > 28, ]  # 筛选 Age 大于 28 的行

添加新列

df$Department <- c("HR", "IT", "Finance")  # 使用 $ 符号
df["Experience"] <- c(2, 5, 7)  # 使用 [] 操作符

删除列

df$Department <- NULL  # 删除 Department 列

合并数据框

# 创建另一个数据框
df2 <- data.frame(
  Name = c("David", "Eva"),
  Age = c(28, 24),
  Salary = c(58000, 52000)
)

# 按行合并
combined_df <- rbind(df, df2)

# 按列合并
combined_df <- cbind(df, Experience = c(2, 5, 7, 3, 4))

数据框的常用函数

·head(df, n) 和 tail(df, n)：查看前 n 行或后 n 行。

·dim(df)：查看数据框的维度（行数和列数）。

·nrow(df) 和 ncol(df)：分别返回行数和列数。

·summary(df)：生成数据框的摘要统计信息。

·merge(df1, df2, by = "column_name")：按列合并两个数据框。

2.5 列表

列表是一种通用的数据结构，可以容纳不同类型的数据对象。列表是R中的一种非常灵活的数据类型，因为它可以包含多种类型的元素，包括向量、矩阵、数据框、甚至其他列表。

my_list <- list(1, "Hello", TRUE) # 创建一个简单的列表

my_named_list <- list(Number = 1, Text = "Hello", Logical = TRUE) # 创建一个带有名称的列表

nested_list <- list(list(1, 2), list("a", "b")) # 嵌套列表

列表的操作

my_list[[1]] # 访问第一个元素
my_list[1] # 返回一个列表，只包含第一个元素
my_named_list$Text # 访问名为 "Text" 的元素
nested_list[[1]][[2]] # 访问嵌套列表中的第二个元素

my_list[[1]] <- 100 # 修改元素
my_list[[4]] <- NULL # 删除元素

列表的常用函数

length(my_list) # 来获取列表的长度
combined_list <- c(my_list, my_named_list)v # 使用c()函数来合并两个或多个列表
is.list(my_list) # 判断一个对象是否是列表

列表和数据框都可以包含不同类型的对象，但列表和数据框的区别是列表是一维和数据框是二维。除此之外，数据框要求每列的长度必须一致（即数据框的行数相同），但列表并不要求每个元素的长度一致。