R语言入门学习教程，从入门到精通，R语言数据结构(4）

R语言数据结构

一、向量（Vector）

向量是R中最基本的数据结构，同一向量中的所有元素必须是相同类型。

1.1 创建向量

r 复制代码

# 使用c()函数创建向量
vec1 <- c(1, 2, 3, 4, 5)  # 创建数值型向量
print(vec1)  # 输出: 1 2 3 4 5

# 创建字符型向量
vec2 <- c("苹果", "香蕉", "橙子")  # 字符串用引号括起来
print(vec2)  # 输出: "苹果" "香蕉" "橙子"

# 使用冒号运算符创建连续序列
vec3 <- 1:10  # 创建从1到10的整数序列
print(vec3)  # 输出: 1 2 3 4 5 6 7 8 9 10

# 使用seq()函数创建有规律的序列
vec4 <- seq(from = 1, to = 10, by = 2)  # 从1到10，步长为2
print(vec4)  # 输出: 1 3 5 7 9

# 使用rep()函数创建重复序列
vec5 <- rep(x = c(1, 2), times = 3)  # 重复向量c(1,2)共3次
print(vec5)  # 输出: 1 2 1 2 1 2

# 创建空向量
vec6 <- vector(mode = "numeric", length = 5)  # 创建长度为5的空数值向量
print(vec6)  # 输出: 0 0 0 0 0

1.2 向量索引

r 复制代码

# 创建示例向量
scores <- c(85, 92, 78, 90, 88)
names(scores) <- c("张三", "李四", "王五", "赵六", "钱七")  # 为元素命名

# 正整数索引（索引从1开始）
scores[1]     # 获取第1个元素: 85
scores[3]     # 获取第3个元素: 78

# 负整数索引（排除指定位置）
scores[-2]    # 排除第2个元素，返回其余所有元素

# 向量索引（获取多个元素）
scores[c(1, 3, 5)]  # 获取第1、3、5个元素: 85 78 88

# 逻辑索引
scores[scores > 85]   # 获取大于85的元素: 92 90 88

# 范围索引
scores[2:4]   # 获取第2到第4个元素: 92 78 90

# 名称索引
scores["李四"]  # 获取名为"李四"的元素: 92

1.3 向量操作

r 复制代码

# 创建两个向量
a <- c(1, 2, 3)
b <- c(4, 5, 6)

# 向量的基本操作
length(a)        # 获取向量长度: 3
append(a, 4)     # 在末尾添加元素: 1 2 3 4

# 向量的合并
c(a, b)          # 合并两个向量: 1 2 3 4 5 6

# 向量的重复
rep(a, times = 2)   # 重复整个向量2次: 1 2 3 1 2 3
rep(a, each = 2)    # 每个元素重复2次: 1 1 2 2 3 3

# 向量的唯一值
unique(c(1, 2, 2, 3, 3, 3))  # 去重: 1 2 3

# 判断元素是否在向量中
2 %in% a   # TRUE
5 %in% a   # FALSE

1.4 向量运算

r 复制代码

# 创建示例向量
x <- c(1, 2, 3)
y <- c(4, 5, 6)

# 算术运算（对应元素运算）
x + y   # 加法: 5 7 9
x - y   # 减法: -3 -3 -3
x * y   # 乘法: 4 10 18
x / y   # 除法: 0.25 0.4 0.5
x ^ y   # 幂运算: 1^4=1, 2^5=32, 3^6=729

# 数学函数运算
sqrt(x)        # 平方根: 1 1.414 1.732
log(x)         # 自然对数: 0 0.693 1.099
exp(x)         # 指数函数: 2.718 7.389 20.086

# 统计运算
sum(x)         # 求和: 6
mean(x)        # 均值: 2
median(x)      # 中位数: 2
var(x)         # 方差: 1
sd(x)          # 标准差: 1
min(x)         # 最小值: 1
max(x)         # 最大值: 3
range(x)       # 范围: 1 3

# 向量长度不同时的循环规则
x <- c(1, 2, 3, 4)
y <- c(10, 20)
x + y          # 较短向量循环: 1+10=11, 2+20=22, 3+10=13, 4+20=24

1.5 向量排序

r 复制代码

# 创建示例向量
scores <- c(85, 92, 78, 90, 75)

# sort() - 返回排序后的值
sort(scores)              # 升序排序: 75 78 85 90 92
sort(scores, decreasing = TRUE)   # 降序排序: 92 90 85 78 75

# order() - 返回排序后的索引位置
order(scores)             # 升序索引: 5(75) 3(78) 1(85) 4(90) 2(92)
scores[order(scores)]     # 使用索引获取排序后的值: 75 78 85 90 92

# 带名称向量的排序
grades <- c(张三 = 85, 李四 = 92, 王五 = 78)
sort(grades)              # 按值排序并保留名称

# 倒序排列
rev(scores)               # 反转向量顺序: 75 90 78 92 85

1.6 向量合并

r 复制代码

# 创建多个向量
v1 <- c(1, 2, 3)
v2 <- c(4, 5, 6)
v3 <- c(7, 8, 9)

# 使用c()合并多个向量
combined <- c(v1, v2, v3)   # 1 2 3 4 5 6 7 8 9

# 使用append()合并
append(v1, v2)              # 在v1后追加v2

# 使用c()合并不同类型（会自动转换类型）
mixed <- c(1, "二", 3)      # 数值被转为字符: "1" "二" "3"

# 合并为矩阵（按行或按列）
cbind(v1, v2)               # 按列合并（生成矩阵）
rbind(v1, v2)               # 按行合并（生成矩阵）

二、矩阵（Matrix）

矩阵是二维数据结构，所有元素必须是相同类型。

2.1 创建矩阵

r 复制代码

# 使用matrix()函数创建矩阵
data <- 1:9  # 创建数据向量

# 创建3行3列的矩阵，按列填充（默认）
mat1 <- matrix(data = data, nrow = 3, ncol = 3)
print(mat1)
#      [,1] [,2] [,3]
# [1,]    1    4    7
# [2,]    2    5    8
# [3,]    3    6    9

# 按行填充矩阵
mat2 <- matrix(data = data, nrow = 3, ncol = 3, byrow = TRUE)
print(mat2)
#      [,1] [,2] [,3]
# [1,]    1    2    3
# [2,]    4    5    6
# [3,]    7    8    9

# 为矩阵的行列添加名称
rownames(mat2) <- c("行1", "行2", "行3")
colnames(mat2) <- c("列1", "列2", "列3")
print(mat2)

# 使用rbind()和cbind()创建矩阵
row1 <- c(1, 2, 3)
row2 <- c(4, 5, 6)
mat3 <- rbind(row1, row2)     # 按行绑定
mat4 <- cbind(row1, row2)     # 按列绑定

2.2 矩阵索引

r 复制代码

# 创建示例矩阵
m <- matrix(1:12, nrow = 3, ncol = 4, byrow = TRUE)
print(m)
#      [,1] [,2] [,3] [,4]
# [1,]    1    2    3    4
# [2,]    5    6    7    8
# [3,]    9   10   11   12

# 获取单个元素
m[2, 3]        # 第2行第3列: 7

# 获取整行
m[2, ]         # 第2行所有列: 5 6 7 8

# 获取整列
m[, 3]         # 第3列所有行: 3 7 11

# 获取多行多列
m[1:2, 3:4]    # 第1-2行，第3-4列
#      [,1] [,2]
# [1,]    3    4
# [2,]    7    8

# 使用向量索引
m[c(1,3), c(2,4)]  # 第1、3行和第2、4列

# 使用逻辑索引
m[m > 6]       # 获取所有大于6的元素: 7 8 9 10 11 12

# 使用名称索引（如果设置了行列名）
rownames(m) <- c("A", "B", "C")
colnames(m) <- c("a", "b", "c", "d")
m["B", "c"]    # B行c列

2.3 矩阵编辑

r 复制代码

# 创建示例矩阵
m <- matrix(1:9, nrow = 3, ncol = 3)

# 修改单个元素
m[2, 2] <- 100    # 将第2行第2列改为100
print(m)

# 修改整行
m[1, ] <- c(10, 20, 30)   # 修改第1行所有列
print(m)

# 修改整列
m[, 3] <- c(99, 88, 77)   # 修改第3列所有行
print(m)

# 添加新行
new_row <- c(40, 50, 60)
m <- rbind(m, new_row)    # 添加新行
print(m)

# 添加新列
new_col <- c(70, 80, 90, 100)
m <- cbind(m, new_col)    # 添加新列
print(m)

# 删除行
m <- m[-2, ]              # 删除第2行
print(m)

# 删除列
m <- m[, -1]              # 删除第1列
print(m)

# 修改矩阵维度
dim(m) <- c(2, 6)         # 将矩阵改为2行6列（元素总数不变）

2.4 矩阵运算

r 复制代码

# 创建示例矩阵
A <- matrix(1:4, nrow = 2, ncol = 2)
B <- matrix(5:8, nrow = 2, ncol = 2)
print(A)
#      [,1] [,2]
# [1,]    1    3
# [2,]    2    4
print(B)
#      [,1] [,2]
# [1,]    5    7
# [2,]    6    8

# 矩阵加法（对应元素相加）
A + B
#      [,1] [,2]
# [1,]    6   10
# [2,]    8   12

# 矩阵乘法（对应元素相乘）
A * B
#      [,1] [,2]
# [1,]    5   21
# [2,]   12   32

# 矩阵相乘（线性代数乘法）
A %*% B
#      [,1] [,2]
# [1,]   23   31
# [2,]   34   46

# 矩阵转置
t(A)
#      [,1] [,2]
# [1,]    1    2
# [2,]    3    4

# 矩阵求逆
C <- matrix(c(4, 7, 2, 6), nrow = 2)
inv_C <- solve(C)    # 求逆矩阵
print(inv_C)

# 检查：原矩阵乘逆矩阵应得到单位矩阵
C %*% inv_C

# 计算行列式
det(C)               # 行列式值: 10

# 计算特征值和特征向量
eigen(C)

# 矩阵的迹（对角线元素之和）
sum(diag(C))

# 提取对角线
diag(C)              # 返回对角线元素: 4 6

# 创建对角矩阵
diag(c(1, 2, 3))     # 创建3x3对角矩阵

三、数组（Array）

数组是多维数据结构，可以看作是矩阵的推广。

3.1 认识数组

r 复制代码

# 数组可以是三维或更高维度
# 一维数组实际上就是向量
# 二维数组就是矩阵
# 三维及以上才是通常意义上的数组

3.2 创建数组

r 复制代码

# 使用array()函数创建数组
data <- 1:24  # 数据向量

# 创建3×4×2的三维数组（3行，4列，2个表）
arr1 <- array(data = data, dim = c(3, 4, 2))
print(arr1)

# 为各维度添加名称
dimnames1 <- list(
  rows = c("行1", "行2", "行3"),
  cols = c("列1", "列2", "列3", "列4"),
  tables = c("表1", "表2")
)
arr2 <- array(data = data, dim = c(3, 4, 2), dimnames = dimnames1)
print(arr2)

# 创建三维数组并指定填充顺序
arr3 <- array(1:12, dim = c(2, 3, 2))  # 默认按列填充
print(arr3)

3.3 数组索引

r 复制代码

# 创建示例数组
arr <- array(1:24, dim = c(3, 4, 2))
print(arr)

# 获取单个元素（需要指定所有维度）
arr[2, 3, 1]      # 第2行，第3列，第1个表

# 获取整行（指定行，所有列，指定表）
arr[2, , 1]       # 第2行所有列，第1个表

# 获取整列
arr[, 3, 2]       # 第3列所有行，第2个表

# 获取整个表
arr[, , 1]        # 第1个表的所有数据（即一个矩阵）

# 获取多个元素
arr[c(1,3), c(2,4), 1]   # 指定行、列、表的组合

# 使用负索引排除
arr[-2, -1, 1]    # 排除第2行和第1列，取第1个表

# 使用逻辑索引
arr[arr > 15]     # 获取所有大于15的元素

# 修改数组维度
dim(arr)          # 查看数组维度: 3 4 2

3.4 修改数组

r 复制代码

# 创建数组
arr <- array(1:12, dim = c(2, 3, 2))

# 修改单个元素
arr[1, 2, 1] <- 100
print(arr)

# 修改整行
arr[2, , 1] <- c(50, 60, 70)
print(arr)

# 修改整列
arr[, 3, 2] <- c(200, 300)
print(arr)

# 修改整个表
arr[, , 2] <- matrix(101:106, nrow = 2, ncol = 3)
print(arr)

# 添加新维度（通过重新设置dim属性）
arr_new <- arr
dim(arr_new) <- c(2, 3, 2, 1)  # 添加第4维度
print(dim(arr_new))  # 2 3 2 1

# 删除维度（通过重新设置dim）
dim(arr_new) <- c(2, 3, 2)     # 恢复原维度

# 应用函数到数组
apply(arr, 1, sum)      # 对行求和（每个表的行分别求和）
apply(arr, 2, mean)     # 对列求均值
apply(arr, 3, sum)      # 对每个表求和

四、数据框（Data Frame）

数据框是R中最常用的数据结构，类似于Excel表格，不同列可以包含不同类型的数据。

4.1 创建数据框

r 复制代码

# 使用data.frame()函数创建数据框
df1 <- data.frame(
  姓名 = c("张三", "李四", "王五", "赵六"),
  年龄 = c(25, 30, 28, 35),
  工资 = c(5000, 6000, 5500, 6500),
  是否在职 = c(TRUE, TRUE, FALSE, TRUE)
)
print(df1)

# 创建时指定字符串不作为因子
df2 <- data.frame(
  name = c("Alice", "Bob", "Charlie"),
  score = c(85, 92, 78),
  stringsAsFactors = FALSE   # 防止字符型自动转为因子
)
print(df2)

# 从列表创建数据框
my_list <- list(
  ID = 1:3,
  Product = c("A", "B", "C"),
  Price = c(10.5, 20.0, 15.8)
)
df3 <- as.data.frame(my_list)
print(df3)

# 读取CSV文件创建数据框（实际使用时需要文件存在）
# df4 <- read.csv("data.csv")

4.2 查看数据框信息

r 复制代码

# 使用示例数据框
df <- data.frame(
  姓名 = c("张三", "李四", "王五", "赵六", "钱七"),
  年龄 = c(25, 30, 28, 35, 26),
  工资 = c(5000, 6000, 5500, 6500, 5800),
  部门 = c("销售", "技术", "市场", "技术", "销售")
)

# 查看数据框结构
str(df)          # 显示数据框的结构（类型、维度、各列信息）
head(df)         # 查看前6行
tail(df)         # 查看后6行
summary(df)      # 显示统计摘要（数值列统计、分类型计数）
dim(df)          # 查看维度（行数 列数）
nrow(df)         # 查看行数
ncol(df)         # 查看列数
names(df)        # 查看列名
colnames(df)     # 查看列名（同上）
rownames(df)     # 查看行名

# 查看数据框的前几行（自定义行数）
head(df, 3)      # 显示前3行

# 查看数据框的末尾几行
tail(df, 2)      # 显示后2行

4.3 获取指定数据

r 复制代码

# 使用示例数据框
df <- data.frame(
  姓名 = c("张三", "李四", "王五"),
  年龄 = c(25, 30, 28),
  工资 = c(5000, 6000, 5500)
)

# 使用$符号获取列
df$姓名          # 获取姓名列: "张三" "李四" "王五"
df$工资          # 获取工资列: 5000 6000 5500

# 使用列索引
df[, 2]          # 获取第2列所有行
df[1:2, ]        # 获取第1-2行所有列
df[3, 1]         # 获取第3行第1列: "王五"

# 使用列名索引
df[, "年龄"]     # 获取年龄列
df["年龄"]       # 返回数据框格式的年龄列
df[["年龄"]]     # 返回向量格式的年龄列

# 使用subset()函数
subset(df, 年龄 > 26)           # 筛选年龄大于26的行
subset(df, 工资 >= 5500 & 年龄 < 30)  # 多条件筛选
subset(df, select = c(姓名, 工资))    # 选择特定列

# 使用逻辑条件（返回数据框）
df[df$年龄 > 26, ]              # 年龄大于26的所有行
df[df$工资 > 5000, c("姓名", "工资")]  # 条件筛选并选择列

4.4 数据的处理

r 复制代码

# 创建示例数据框
df <- data.frame(
  姓名 = c("张三", "李四", "王五", "赵六"),
  年龄 = c(25, 30, NA, 35),      # NA表示缺失值
  工资 = c(5000, 6000, 5500, NA),
  部门 = c("销售", "技术", "市场", "技术")
)

# 1. 处理缺失值
is.na(df)             # 判断每个元素是否为NA
na.omit(df)           # 删除包含NA的行
df_clean <- na.omit(df)  # 保存清理后的数据

# 2. 添加新列
df$奖金 <- c(1000, 2000, 1500, 1800)  # 添加奖金列
df$总收入 <- df$工资 + df$奖金        # 基于现有列计算新列

# 3. 修改现有列
df$工资[is.na(df$工资)] <- mean(df$工资, na.rm = TRUE)  # 用均值填充缺失值

# 4. 重命名列
colnames(df)[2] <- "年龄(岁)"           # 修改第2列名
names(df)[3] <- "月薪"                  # 修改第3列名

# 5. 删除列
df$奖金 <- NULL                         # 删除奖金列
df <- df[, -5]                          # 删除第5列

# 6. 排序
df_sorted <- df[order(df$年龄), ]       # 按年龄升序排序
df_sorted_desc <- df[order(-df$工资), ] # 按工资降序排序

# 7. 合并数据框
df1 <- data.frame(ID = 1:3, 姓名 = c("张三", "李四", "王五"))
df2 <- data.frame(ID = 1:3, 年龄 = c(25, 30, 28))
df_merged <- merge(df1, df2, by = "ID")  # 按ID列合并

# 8. 应用函数到数据框
apply(df[, c("年龄", "工资")], 2, mean, na.rm = TRUE)  # 计算各列均值
lapply(df, class)     # 查看每列的数据类型
sapply(df, typeof)    # 查看每列的类型

五、因子（Factor）

因子用于表示分类数据，可以带有顺序。

5.1 因子的概念及应用

r 复制代码

# 因子是一种特殊的数据类型，用于存储分类变量
# 因子具有水平（levels），每个水平是分类的一个可能取值
# 应用场景：性别、教育程度、地区、月/季度等分类数据

5.2 创建因子

r 复制代码

# 使用factor()函数创建因子
gender <- c("男", "女", "男", "女", "男")
gender_factor <- factor(gender)
print(gender_factor)
# 输出: 男 女 男 女 男
# Levels: 女 男

# 查看因子信息
levels(gender_factor)        # 查看水平: "女" "男"
nlevels(gender_factor)       # 查看水平个数: 2
table(gender_factor)         # 统计各水平频次

# 指定水平的顺序
education <- c("高中", "本科", "硕士", "本科", "高中")
edu_factor <- factor(education, 
                     levels = c("高中", "本科", "硕士"),
                     ordered = TRUE)  # 创建有序因子
print(edu_factor)
# Levels: 高中 < 本科 < 硕士

# 创建有序因子
satisfaction <- c("满意", "非常满意", "一般", "满意")
sat_factor <- factor(satisfaction, 
                     levels = c("一般", "满意", "非常满意"),
                     ordered = TRUE)
print(sat_factor)

# 创建带标签的因子
code <- c(1, 2, 1, 2, 3)
status_factor <- factor(code, 
                        levels = c(1, 2, 3),
                        labels = c("初级", "中级", "高级"))
print(status_factor)

# 数值型因子转换为数值
num_factor <- factor(c(10, 20, 30, 20))
as.numeric(num_factor)       # 转换为水平编码: 1 2 3 2
as.numeric(as.character(num_factor))  # 转换为原始数值: 10 20 30 20

5.3 调整因子水平

r 复制代码

# 创建示例因子
city <- c("北京", "上海", "广州", "北京", "深圳")
city_factor <- factor(city)
print(city_factor)
# Levels: 北京 广州 上海 深圳

# 修改水平名称
levels(city_factor) <- c("Beijing", "Guangzhou", "Shanghai", "Shenzhen")
print(city_factor)

# 添加新的水平
levels(city_factor) <- c(levels(city_factor), "天津")
print(levels(city_factor))

# 合并水平
grades <- factor(c("优", "良", "优", "中", "良", "差"))
levels(grades)              # 查看当前水平
levels(grades) <- c("良好", "良好", "中等", "优秀", "差")  # 错误示例

# 正确合并水平方法
grades_new <- factor(grades)
levels(grades_new) <- list(
  优秀 = "优",
  良好 = c("优", "良"),     # 将"优"和"良"合并为"良好"
  中等 = "中",
  差 = "差"
)
print(grades_new)

# 删除未使用的水平
grades_used <- droplevels(grades_new)  # 删除数据中不存在的水平

# 重新排序水平
levels(city_factor) <- levels(city_factor)[c(4, 2, 1, 3, 5)]  # 自定义顺序

# 在数据框中使用因子
df <- data.frame(
  姓名 = c("张三", "李四", "王五"),
  性别 = factor(c("男", "女", "男")),
  学历 = factor(c("本科", "硕士", "博士"), ordered = TRUE)
)
str(df)  # 查看数据框结构

六、列表（List）

列表是最灵活的数据结构，可以包含不同类型和不同长度的元素。

6.1 创建列表

r 复制代码

# 使用list()函数创建列表
my_list <- list(
  name = "张三",           # 字符型元素
  age = 25,                # 数值型元素
  scores = c(85, 90, 78),  # 向量元素
  is_active = TRUE,        # 逻辑型元素
  matrix_data = matrix(1:4, nrow = 2)  # 矩阵元素
)
print(my_list)

# 不指定名称的列表
list2 <- list("苹果", 100, c(TRUE, FALSE), mean)
print(list2)

# 创建空列表
empty_list <- list()
empty_list2 <- vector(mode = "list", length = 5)  # 长度为5的空列表

# 嵌套列表（列表中包含列表）
nested_list <- list(
  person = list(name = "李四", age = 30),
  company = list(name = "科技公司", location = "北京")
)
print(nested_list)

# 使用as.list()转换向量为列表
vec <- c(10, 20, 30)
vec_as_list <- as.list(vec)
print(vec_as_list)  # 每个元素变成列表的一个元素

6.2 列表的索引

r 复制代码

# 创建示例列表
my_list <- list(
  姓名 = "张三",
  年龄 = 25,
  成绩 = c(85, 90, 78),
  信息 = list(电话 = "123456", 地址 = "北京")
)

# 使用$符号访问（需要知道名称）
my_list$姓名          # 获取"姓名"元素: "张三"
my_list$成绩          # 获取成绩向量: 85 90 78
my_list$信息$电话     # 访问嵌套元素: "123456"

# 使用双中括号[[]]访问（返回元素本身）
my_list[[2]]          # 获取第2个元素: 25
my_list[["年龄"]]     # 按名称获取: 25
my_list[["成绩"]][2]  # 获取成绩向量的第2个元素: 90

# 使用单中括号[]访问（返回子列表）
my_list[1]            # 返回包含第1个元素的列表
my_list[c(1, 3)]      # 返回包含第1和第3个元素的列表
my_list["姓名"]       # 返回包含"姓名"的列表

# 修改列表元素
my_list$年龄 <- 26           # 修改已有元素
my_list$新元素 <- "新值"     # 添加新元素
my_list[[4]] <- NULL         # 删除第4个元素
my_list$成绩 <- NULL         # 删除"成绩"元素

# 合并列表
list_a <- list(a = 1, b = 2)
list_b <- list(c = 3, d = 4)
list_combined <- c(list_a, list_b)  # 合并两个列表
print(list_combined)

# 列表长度
length(my_list)          # 列表元素个数

# 获取列表所有名称
names(my_list)

# 判断是否为列表
is.list(my_list)         # TRUE

# 将列表转换为向量（当所有元素类型相同时）
list_numeric <- list(1, 2, 3, 4)
unlist(list_numeric)     # 转换为数值向量: 1 2 3 4

# 将列表转换为数据框（各元素长度需相同）
list_for_df <- list(
  姓名 = c("张三", "李四"),
  年龄 = c(25, 30)
)
df_from_list <- as.data.frame(list_for_df)
print(df_from_list)

# 应用函数到列表
lapply(my_list, class)   # 对每个元素应用class函数
sapply(my_list, length)  # 对每个元素应用length函数，简化结果

七、要点回顾

r 复制代码

# ===== 1. 向量回顾 =====
v <- c(10, 20, 30, 40, 50)
v[3]                      # 索引: 30
v[v > 25]                 # 逻辑索引: 30 40 50
mean(v)                   # 均值: 30

# ===== 2. 矩阵回顾 =====
m <- matrix(1:6, nrow = 2, ncol = 3)
m[2, 3]                   # 第2行第3列: 6
t(m)                      # 转置
m %*% t(m)                # 矩阵乘法

# ===== 3. 数组回顾 =====
a <- array(1:12, dim = c(2, 3, 2))
a[1, 2, 1]                # 第一个表第1行第2列
dim(a)                    # 维度: 2 3 2

# ===== 4. 数据框回顾 =====
df <- data.frame(
  ID = 1:3,
  Name = c("A", "B", "C"),
  Score = c(85, 92, 78)
)
df$Name                   # 访问列
df[df$Score > 80, ]       # 筛选行
df$Grade <- c("B", "A", "C")  # 添加新列

# ===== 5. 因子回顾 =====
gender <- factor(c("男", "女", "男", "女"))
levels(gender)            # 水平: "女" "男"
table(gender)             # 频数统计

# ===== 6. 列表回顾 =====
lst <- list(
  name = "张三",
  scores = c(85, 90, 78),
  info = list(age = 25, city = "北京")
)
lst$name                  # "张三"
lst$scores[2]             # 90
lst$info$city             # "北京"
lst$new_col <- "新值"     # 添加元素

# ===== 7. 类型转换 =====
as.vector(m)              # 矩阵转向量
as.matrix(df)             # 数据框转矩阵（注意类型一致性）
as.data.frame(lst)        # 列表转数据框（需各元素长度相同）
as.list(v)                # 向量转列表
as.factor(v)              # 向量转因子
as.numeric(factor(c(10,20)))  # 因子转数值（先转字符再转数值）

# ===== 8. 检查数据结构 =====
class(v)                  # "numeric"
typeof(v)                 # "double"
str(df)                   # 显示详细结构
is.vector(v)              # TRUE
is.matrix(m)              # TRUE
is.data.frame(df)         # TRUE
is.factor(gender)         # TRUE
is.list(lst)              # TRUE