r语言学习笔记

起因是2025年4月18号晚上人类睡眠服务器爆满 久久未眠 遂通宵整理笔记

R的基本数学运算 与 对象命名原则

R语言对象的命名原则

1. 字母开头：对象名称必须以字母开头，不能以数字或特殊字符开头。
2. 区分大小写：R语言区分大小写，例如myData和mydata是两个不同的对象。
3. 避免使用保留字：不要使用R语言的保留字（如if、else、TRUE等）作为对象名称。
4. 使用下划线或点分隔：可以使用下划线（_）或点（.）来分隔单词，例如my_data或my.data。
5. 避免特殊字符：对象名称中不能包含空格或特殊字符（如@、#、$等）。

r语言的基本运算

R的赋值符号

在R语言中，赋值操作可以通过以下符号完成：

1. <-：这是R中最常用的赋值符号，例如：

   x <- 10
   y <- "Hello"
   

2. =：也可以使用等号进行赋值，但通常在函数参数中更常见，例如：

   z = 20
   

3. ->：可以将值赋给符号右侧的变量，例如：

   30 -> a
   

   推荐使用<-作为赋值符号，这是R语言的传统

R的数学运算符号

在R语言中，可以使用以下数学运算符进行基本的数学计算：

1. 加法（+）：
2. 减法（-）：
3. 乘法（*）：
4. 除法（/）：
5. 幂运算（^ 或 ``）**：

   5^3   # 结果为125
   5**3  # 结果为125
   

6. 取余数（%%）：

   5 %% 3  # 结果为2
   

7. 取整数商（%/%）：

   5 %/% 3  # 结果为1
   

8. 绝对值（abs()）：

   abs(-5)  # 结果为5
   

9. e的幂（exp()）：

   exp(1)  # 结果为2.7183
   

10. 对数（log()）：

    log(10)  # 结果为2.3026
    log(10, base=10)  # 结果为1
    

11. 平方根（sqrt()）：

    sqrt(16)  # 结果为4
    

12. 阶乘（factorial()）：

    factorial(5)  # 结果为120
    

圆周率（pi）： r pi # 结果为3.141593

自然常数e（exp(1)）： r exp(1) # 结果为2.718282

近似函数与四舍五入函数

在R语言中，可以使用以下函数进行近似和四舍五入操作：

1. floor()：向下取整，返回不大于输入值的最大整数。

   floor(3.7)  # 结果为3
   floor(-3.7) # 结果为-4
   

2. ceiling()：向上取整，返回不小于输入值的最小整数。

   ceiling(3.7)  # 结果为4
   ceiling(-3.7) # 结果为-3
   

3. trunc()：截断小数部分，返回整数部分。

   trunc(3.7)  # 结果为3
   trunc(-3.7) # 结果为-3
   

4. round()：四舍五入到指定的小数位数。

   round(3.14159, 2)  # 结果为3.14
   round(3.5)         # 结果为4
   round(-3.5)        # 结果为-4
   

5. signif()：保留指定的有效数字。

   signif(3.14159, 3)  # 结果为3.14
   signif(12345, 3)    # 结果为12300
   

R的运算顺序

1. 括号优先：首先计算括号内的表达式。
2. 幂运算：其次进行幂运算（^ 或 **）。
3. 乘除运算：然后进行乘法（*）、除法（/）、取余（%%）、取整数商（%/%）。
4. 加减运算：最后进行加法（+）和减法（-）。
5. 从左到右：同级运算符按从左到右的顺序依次计算。

逻辑判断与逻辑运算

1. 逻辑值：

   • TRUE 和 FALSE 是R中的逻辑值。

2. 比较运算符：

   • ==：等于
   • !=：不等于
   • <：小于
   • >：大于
   • <=：小于等于
   • >=：大于等于

3. 逻辑运算符：

   • &：逻辑与（AND），逐元素运算。
   • |：逻辑或（OR），逐元素运算。
   • !：逻辑非（NOT）。
   • && 和 ||：逻辑与和逻辑或的短路运算，仅对第一个元素进行计算。

   示例：

   TRUE & FALSE  # 结果为FALSE
   TRUE | FALSE  # 结果为TRUE
   !TRUE         # 结果为FALSE
   TRUE && FALSE # 结果为FALSE
   TRUE || FALSE # 结果为TRUE
   

4. 逻辑判断函数：

   • all()：检查所有元素是否为TRUE。
   • any()：检查是否至少有一个元素为TRUE。
   • isTRUE()：检查单个值是否为TRUE。 示例：

   all(c(TRUE, TRUE, FALSE))  # 结果为FALSE
   any(c(TRUE, TRUE, FALSE))  # 结果为TRUE
   isTRUE(TRUE)              # 结果为TRUE
   

NA与NAN

NA（Not Available）和NaN（Not a Number）是R语言中表示缺失值和无效数值的两种特殊值。

1. NA（缺失值）：

   • 表示数据缺失或不可用。
   • 可以出现在任何数据类型中，例如数值、字符、逻辑等。
   • 操作中包含NA的结果通常也是NA。
   • 示例：

     x <- c(1, 2, NA, 4)
     mean(x)  # 结果为NA
     mean(x, na.rm = TRUE)  # 忽略NA，结果为2.333333
     

2. NaN（无效数值）：

   • 表示数学运算中产生的无效结果，例如0除以0或负数的平方根。
   • NaN是NA的一种特殊形式，所有NaN都是NA，但不是所有NA都是NaN。
   • 示例：

     sqrt(-1)  # 结果为NaN
     0 / 0     # 结果为NaN
     

3. 检查NA和NaN：

   • 使用is.na()检查是否为NA。
   • 使用is.nan()检查是否为NaN。
   • 示例：

     x <- c(1, NA, NaN, 4)
     is.na(x)  # 结果为FALSE TRUE TRUE FALSE
     is.nan(x) # 结果为FALSE FALSE TRUE FALSE
     

R的数据类型

R语言数据类型

在R语言中，常见的五种基本数据类型如下：

1. 数值型（Numeric）：

   • 包括整数和实数。 ```

2. 整数型（Integer）：

   • 用于存储整数数据。
   • 示例：

     age <- 25L  # 整数型，L表示整数
     

3. 字符型（Character）：

   • 用于存储文本数据。

4. 逻辑型（Logical）：

   • 包含布尔值：TRUE 和 FALSE。

数据类型的转换

在R语言中，可以使用以下函数进行数据类型的转换：

1. as.numeric()：将数据转换为数值型。

   x <- "42"
   as.numeric(x)  # 结果为42
   

2. as.integer()：将数据转换为整数型。

   x <- 3.14
   as.integer(x)  # 结果为3
   

3. as.character()：将数据转换为字符型。

   x <- 42
   as.character(x)  # 结果为"42"
   

4. as.logical()：将数据转换为逻辑型。

   x <- 1
   as.logical(x)  # 结果为TRUE
   

   注意：如果转换失败，R会返回NA并发出警告。例如：

x <- "abc"
as.numeric(x)  # 结果为NA，并显示警告

R的数据结构

R的6种数据结构

1. 向量（Vector）：

   • 最基本的数据结构，用于存储相同类型的元素。
   • 创建方式：c()函数。
   • 示例：

     v <- c(1, 2, 3, 4)
     

2. 矩阵（Matrix）：

   • 二维数据结构，存储相同类型的元素。
   • 创建方式：matrix()函数。
   • 示例：

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

3. 数组（Array）：

   • 多维数据结构，存储相同类型的元素。
   • 创建方式：array()函数。
   • 示例：

     a <- array(1:8, dim = c(2, 2, 2))
     

4. 数据框（Data Frame）：

   • 表格形式的数据结构，可以存储不同类型的列。
   • 创建方式：data.frame()函数。
   • 示例：

     df <- data.frame(Name = c("Alice", "Bob"), Age = c(25, 30))
     

5. 列表（List）：

   • 可以存储不同类型的元素，包括向量、矩阵、数据框等。
   • 创建方式：list()函数。
   • 示例：

     lst <- list(Name = "Alice", Age = 25, Scores = c(90, 85, 88))
     

6. 因子（Factor）：

   • 用于存储分类数据。
   • 创建方式：factor()函数。
   • 示例：

     f <- factor(c("Male", "Female", "Male"))
     

向量

数值型向量对象

数值型向量是R语言中最基本的数据结构之一，用于存储一组数值数据。向量中的所有元素必须是相同的数据类型。

创建数值型向量的方法

1. c()函数：

   • 作用：将多个数值组合在一起，创建一个数值型向量。
   • 常用参数：
     • ...：需要组合的数值，可以是单个数值或其他向量。
   • 示例：

     v <- c(1, 2, 3, 4, 5)  # 创建一个包含5个元素的数值型向量
     

2. seq()函数：

   • 作用：生成一个等差数列。
   • 常用参数：
     • from：数列的起始值。
     • to：数列的终止值。
     • by：步长，指定相邻两个数之间的间隔。
     • length.out：指定数列的长度，优先级高于by。
   • 示例：

     v1 <- seq(1, 10, by = 2)       # 从1到10，步长为2
     v2 <- seq(1, 10, length.out = 5)  # 从1到10，生成5个等间距的数
     

3. rep()函数：

   • 作用：生成重复的数值，创建重复模式的向量。
   • 常用参数：
     • x：需要重复的数值或向量。
     • times：重复的次数。
     • each：每个元素的重复次数。
   • 示例：

     v1 <- rep(5, times = 3)       # 重复5三次
     v2 <- rep(c(1, 2), each = 2)  # 每个元素重复两次
     v3 <- rep(c(1, 2), times = 2) # 整个向量重复两次
     

4. 数值直接赋值：

   • 作用：直接将数值赋值给变量，创建单一数值的向量。
   • 示例：

     v <- 42  # 创建一个只包含42的单一数值向量
     

字符型向量

字符型向量是用于存储文本数据的向量，其中每个元素都是一个字符串。字符型向量可以通过以下方法创建：

1. c()函数：

   • 作用：将多个字符串组合在一起，创建一个字符型向量。
   • 示例：

     v <- c("apple", "banana", "cherry")  # 创建一个包含3个字符串的字符型向量
     

2. character()函数：

   • 作用：创建一个指定长度的空字符型向量。
   • 常用参数：
     • length：向量的长度。
   • 示例：

     v <- character(3)  # 创建一个长度为3的空字符型向量
     v[1] <- "apple"    # 为向量的第一个元素赋值
     v[2] <- "banana"   # 为向量的第二个元素赋值
     v[3] <- "cherry"   # 为向量的第三个元素赋值
     

逻辑向量对象

逻辑向量是用于存储布尔值（TRUE 和 FALSE）的向量。逻辑向量在条件判断和逻辑运算中非常常用。以下是逻辑向量的特点和创建方法：

1. 特点：

   • 逻辑向量的元素只能是TRUE、FALSE或NA（缺失值）。
   • 可以通过逻辑表达式生成逻辑向量。

2. 创建方法：

   • 直接赋值：

     v <- c(TRUE, FALSE, TRUE)  # 创建一个包含3个布尔值的逻辑向量
     

   • 逻辑表达式：

     v <- c(1, 2, 3, 4, 5)
     result <- v > 3  # 生成一个逻辑向量，表示v中哪些元素大于3
     

向量的属性

• class()函数：查看向量的属性（数据类型）。
  示例：

  v <- c(1, 2, 3)
  class(v)  # 输出 "numeric"
  

• 隐式类型转换：当向量中包含不同类型的元素时，R会自动进行类型转换，遵循以下规则：

  1. 逻辑型 → 数值型 → 字符型
     示例：

  v <- c(TRUE, 1, "text")
  class(v)  # 输出 "character"
  

• str()函数：查看向量的结构。
  示例：

  v <- c(1, 2, 3)
  str(v)  # 输出 num [1:3] 1 2 3
  

• length()函数：查看向量的长度（元素个数）。
  示例：

  v <- c(1, 2, 3)
  length(v)  # 输出 3
  

• nchar()函数：查看字符型向量中每个元素的字符数。
  示例：

  v <- c("apple", "banana", "cherry")
  nchar(v)  # 输出 5 6 6
  

向量对象元素的存取

利用 vec[index] 方法存取向量元素

在R语言中，可以通过方括号 [] 和索引来访问或提取向量中的元素。常见用法如下：

1. 正索引（提取指定位置的元素）

• 使用正整数索引可以提取向量中对应位置的元素（索引从1开始）。

  v <- c(10, 20, 30, 40, 50)
  v[2]        # 提取第2个元素，结果为20
  v[c(1, 3)]  # 提取第1和第3个元素，结果为10和30
  

2. 负索引（排除指定位置的元素）

• 使用负整数索引可以排除对应位置的元素，返回剩余的元素。

  v[-2]         # 排除第2个元素，结果为10 30 40 50
  v[-c(1, 3)]   # 排除第1和第3个元素，结果为20 40 50
  

3. 使用 head() 和 tail() 提取向量元素

• head() 用于提取向量的前几个元素，默认前6个。

• tail() 用于提取向量的后几个元素，默认后6个。

  v <- c(10, 20, 30, 40, 50, 60, 70)
  head(v)        # 提取前6个元素，结果为10 20 30 40 50 60
  head(v, 3)     # 提取前3个元素，结果为10 20 30
  
  tail(v)        # 提取后6个元素，结果为20 30 40 50 60 70
  tail(v, 2)     # 提取后2个元素，结果为60 70
  

这些方法可以灵活地对向量进行元素的访问和筛选。

向量对象的数学运算

向量间的运算

• 加法、减法、乘法、除法：R支持向量间的逐元素运算，两个向量长度相同时，按元素对应运算；长度不同则采用循环回补（recycling）原则。

  a <- c(1, 2, 3)
  b <- c(4, 5, 6)
  a + b  # 结果为 5 7 9
  a * b  # 结果为 4 10 18
  

常用统计函数

• sum(x)：计算向量所有元素的和。
• mean(x)：计算向量的平均值。
• sd(x)：计算向量的标准差。
• var(x)：计算向量的方差。
• max(x)：返回向量中的最大值。
• min(x)：返回向量中的最小值。
• prod(x)：计算向量所有元素的乘积。
• cumsum(x)：返回向量的累加和（每一步的累计总和）。
• cumprod(x)：返回向量的累积乘积。
• cummax(x)：返回向量的累计最大值。
• cummin(x)：返回向量的累计最小值。

diff()函数的用法

diff()函数用于计算向量、时间序列或数据集中的相邻元素之间的差值，常用于分析数据的变化趋势。

基本语法：

diff(x, lag = 1, differences = 1)

• x：要计算差分的数值型向量或时间序列。
• lag：间隔，默认值为1，表示计算相邻元素的差。
• differences：差分的阶数，默认值为1。

示例：

1. 计算相邻元素的差值：

   v <- c(2, 4, 7, 11)
   diff(v)  # 结果为 2 3 4
   # 计算方式：4-2=2, 7-4=3, 11-7=4
   

2. 指定间隔（lag）：

   diff(v, lag = 2)  # 结果为 5 7
   # 计算方式：7-2=5, 11-4=7
   

向量排序相关函数：sort()、rank()、rev()

在R语言中，常用以下函数对向量进行排序、排名和反转操作：

1. sort()：对向量元素进行排序

   • 默认升序排列，decreasing = TRUE 可降序排列。
   • 示例：

     v <- c(5, 2, 8, 1)
     sort(v)                # 结果为 1 2 5 8
     sort(v, decreasing=TRUE) # 结果为 8 5 2 1
     

2. rank()：返回向量元素的排名

   • 相同元素会分配平均排名。
   • 示例：

     v <- c(5, 2, 8, 1)
     rank(v)  # 结果为 3 2 4 1
     

3. rev()：反转向量元素的顺序

   • 示例：

     v <- c(5, 2, 8, 1)
     rev(v)  # 结果为 1 8 2 5
     

向量中包含 Inf、-Inf 和 NA 时的处理

在R语言中，向量可以包含特殊值：Inf（正无穷）、-Inf（负无穷）和 NA（缺失值）。它们在运算和函数中有如下表现：

1. 数学运算

   • Inf 与任何有限数值运算结果仍为 Inf（除非遇到 -Inf 或 NA）。
   • Inf + (-Inf)、Inf - Inf、0 * Inf 等结果为 NaN。
   • 任何与 NA 运算结果为 NA。

   c(1, Inf, -Inf, NA) + 1
   # 结果：2 Inf -Inf NA
   

2. 统计函数的处理

   • 统计函数如 sum()、mean()、max()、min() 等，遇到 Inf 或 -Inf 会返回无穷，遇到 NA 结果为 NA，可用 na.rm=TRUE 忽略缺失值。
   • Inf 和 -Inf 不会被 na.rm=TRUE 移除。

   v <- c(1, 2, Inf, -Inf, NA)
   sum(v)            # 结果为 NA
   sum(v, na.rm=TRUE) # 结果为 Inf
   

向量的逻辑运算

向量的逻辑运算是R语言数据分析中常用的操作，主要包括逻辑判断符号和逻辑与、或、非运算。

1. 逻辑判断符号

• ==：等于
• !=：不等于
• <：小于
• >：大于
• <=：小于等于
• >=：大于等于

这些符号可以直接用于向量，返回一个逻辑向量。例如：

v <- c(1, 3, 5, 7)
v > 3      # 结果为 FALSE FALSE TRUE TRUE
v == 5     # 结果为 FALSE FALSE TRUE FALSE

2. 逻辑与、或、非运算

• &：逻辑与（AND），逐元素运算
• |：逻辑或（OR），逐元素运算
• !：逻辑非（NOT），对每个元素取反

示例：

a <- c(TRUE, FALSE, TRUE)
b <- c(FALSE, FALSE, TRUE)

a & b   # 结果为 FALSE FALSE TRUE
a | b   # 结果为 TRUE FALSE TRUE
!a      # 结果为 FALSE TRUE FALSE

注意：&& 和 || 只对第一个元素进行逻辑运算，常用于条件语句中。

逻辑运算常用于数据筛选、条件判断等场景。

which、any、all 函数的用法

在R语言中，which()、any() 和 all() 是常用的逻辑判断与筛选函数：

1. which()

   • 返回逻辑向量中值为 TRUE 的元素的索引（位置）。
   • 常用于筛选满足条件的元素位置。
   • 示例：

     v <- c(2, 5, 8, 3)
     which(v > 4)  # 结果为 2 3
     

2. any()

   • 检查逻辑向量中是否有至少一个元素为 TRUE。
   • 返回单个逻辑值（TRUE 或 FALSE）。
   • 示例：

     v <- c(2, 5, 8, 3)
     any(v > 7)  # 结果为 TRUE
     any(v < 0)  # 结果为 FALSE
     

3. all()

   • 检查逻辑向量中是否所有元素都为 TRUE。
   • 返回单个逻辑值（TRUE 或 FALSE）。
   • 示例：

     v <- c(2, 5, 8, 3)
     all(v > 1)  # 结果为 TRUE
     all(v > 4)  # 结果为 FALSE
     

这些函数常用于数据筛选、条件判断和数据清洗等场景。

创建带名称的向量与使用 names() 函数修改向量名称

在R语言中，可以为向量的每个元素指定名称，便于数据的理解和访问。常用方法如下：

1. 创建带名称的向量

可以在创建向量时直接指定名称：

v <- c(apple = 3, banana = 5, cherry = 7)
print(v)
# 结果：
# apple banana cherry 
#     3      5      7 

2. 使用 names() 函数为已有向量添加或修改名称

• 为已有向量添加名称：

  v <- c(3, 5, 7)
  names(v) <- c("apple", "banana", "cherry")
  print(v)
  # 结果：
  # apple banana cherry 
  #     3      5      7 
  

• 修改已有向量的名称：

  names(v)[2] <- "orange"
  print(v)
  # 结果：
  #  apple orange cherry 
  #      3      5      7 
  

3. 查看向量的名称

可以通过 names(v) 查看当前向量的名称：

names(v)
# 结果： "apple" "orange" "cherry"

通过为向量元素命名，可以更直观地管理和访问数据。

矩阵与更高维数组

创建矩阵

建立矩阵

在R语言中，常用以下三种方法创建矩阵：

1. matrix()函数

   • 直接创建矩阵，需指定数据、行数或列数。 默认是按列填充的
   • 示例：

     m <- matrix(1:6, nrow = 2, ncol = 3)
     # 结果为2行3列的矩阵
     

2. rbind()函数

   • 按行合并多个向量或矩阵，生成新矩阵。
   • 示例：

     a <- c(1, 2, 3)
     b <- c(4, 5, 6)
     m <- rbind(a, b)
     # 结果为2行3列的矩阵，每个向量为一行
     

3. cbind()函数

   • 按列合并多个向量或矩阵，生成新矩阵。
   • 示例：

     a <- c(1, 2, 3)
     b <- c(4, 5, 6)
     m <- cbind(a, b)
     # 结果为3行2列的矩阵，每个向量为一列
     

这三种方法可以灵活地根据数据结构需求创建和组合矩阵。

矩阵的属性

• str()函数：查看矩阵的结构和属性信息。

  m <- matrix(1:6, nrow = 2, ncol = 3)
  str(m)
  # 输出： int [1:2, 1:3] 1 2 3 4 5 6
  

• nrow() 和 ncol()：分别返回矩阵的行数和列数。

  nrow(m)  # 结果为2
  ncol(m)  # 结果为3
  

• dim()：返回矩阵的维度（行数和列数）。

  dim(m)  # 结果为 2 3
  

• length()：返回矩阵中元素的总数。

  length(m)  # 结果为6
  

• class()：查看对象的数据类型。

  class(m)  # 结果为 "matrix"
  

• is.matrix()：判断对象是否为矩阵。

  is.matrix(m)  # 结果为TRUE
  

利用 mat[index] 对矩阵索引和修改的方法

在R语言中，可以使用方括号 [] 对矩阵进行元素的访问和修改。基本用法如下：

• 按单一索引访问（按列优先）
  矩阵在R中按列存储，mat[index] 会将矩阵视为一个向量，按列优先顺序访问元素。

  m <- matrix(1:6, nrow = 2, ncol = 3)
  m[3]      # 访问第3个元素（结果为3）
  m[2] <- 99  # 修改第2个元素为99
  print(m)
  

• 按行列索引访问和修改
  使用 mat[row, col] 形式可以访问或修改指定位置的元素：

  m[1, 2]      # 访问第1行第2列的元素
  m[2, 3] <- 88  # 修改第2行第3列的元素为88
  

• 访问整行或整列

  m[1, ]    # 访问第1行的所有元素
  m[, 2]    # 访问第2列的所有元素
  

• 访问多个元素

  m[c(1,2), c(2,3)]  # 访问第1、2行和第2、3列组成的子矩阵
  

矩阵的行列名

在R语言中，可以使用 rownames()、colnames() 和 dimnames() 函数来获取和修改矩阵的行名和列名。

• 获取行名和列名

  m <- matrix(1:6, nrow = 2, ncol = 3)
  rownames(m)    # 获取行名
  colnames(m)    # 获取列名
  dimnames(m)    # 同时获取行名和列名
  

• 设置行名和列名

  rownames(m) <- c("Row1", "Row2")
  colnames(m) <- c("Col1", "Col2", "Col3")
  # 或者同时设置
  dimnames(m) <- list(c("R1", "R2"), c("C1", "C2", "C3"))
  

• 示例：

  m <- matrix(1:6, nrow = 2, ncol = 3)
  rownames(m) <- c("A", "B")
  colnames(m) <- c("X", "Y", "Z")
  print(m)
  #      X Y Z
  # A    1 3 5
  # B    2 4 6
  

矩阵的运算

1. 矩阵与常数的运算

• 矩阵与常数之间的加、减、乘、除操作会对矩阵的每个元素进行逐元素运算。

  m <- matrix(1:4, nrow=2)
  m + 2    # 每个元素加2
  m * 3    # 每个元素乘3
  

2. 矩阵间的运算

• 逐元素运算：两个同型矩阵可以直接进行加、减、乘、除等逐元素运算。

  a <- matrix(1:4, 2)
  b <- matrix(5:8, 2)
  a + b    # 对应元素相加
  a * b    # 对应元素相乘
  

• 矩阵乘法：使用 %*% 运算符进行矩阵乘法。

  a %*% b
  

3. 行列求和与平均值

• 按行求和/平均：rowSums()、rowMeans()

  rowSums(m)    # 每行元素之和
  rowMeans(m)   # 每行元素平均值
  

• 按列求和/平均：colSums()、colMeans()

  colSums(m)    # 每列元素之和
  colMeans(m)   # 每列元素平均值
  

4. 矩阵转置

• 使用 t() 函数对矩阵进行转置。

5. 对角矩阵与 diag() 函数

• 创建对角矩阵：

  diag(c(1, 2, 3))  # 创建主对角线为1,2,3的矩阵
  

• 提取对角线元素：

  diag(m)           # 提取主对角线元素
  

6. 矩阵求逆 solve() 函数

• 计算方阵的逆矩阵（矩阵需为可逆方阵）。

  m <- matrix(c(2, 1, 1, 2), 2)
  solve(m)
  

7. 矩阵行列式 det() 函数

• 计算方阵的行列式。

  det(m)
  

三维或高维数组

建立三维数组

在R语言中，可以使用array()函数创建三维或更高维的数组。常用方法如下：

• 创建高维数组

  arr <- array(1:24, dim = c(2, 3, 4))  # 创建一个2行3列4层的三维数组
  

• 查看数组的维度
  使用dim()函数可以查看数组的维度：

  dim(arr)  # 输出 2 3 4
  

• 比较两个数组是否完全相同
  使用identical()函数判断两个数组内容和结构是否完全一致：

  arr2 <- array(1:24, dim = c(2, 3, 4))
  identical(arr, arr2)  # 结果为TRUE
  

• 索引数组中的元素
  使用[,,]等多维索引方式访问指定位置的元素：

  arr[1, 2, 3]  # 访问第1行第2列第3层的元素
  arr[ , , 1]   # 访问第1层的所有元素（返回一个2x3矩阵）
  

因子

因子（Factor）是R语言中用于表示分类数据（categorical data）的一种数据结构。因子可以将一组有限的、离散的取值（称为“水平”levels）进行编码，常用于统计建模和数据分析中的分组变量（如性别、血型、地区等）。

• 特点：
  • 因子本质上是整数向量，每个整数对应一个分类水平（level）。
  • 因子可以是有序的（ordered factor）或无序的（unordered factor）。
  • 使用factor()函数创建因子对象。

创建因子

无序因子

在R语言中，可以使用factor()函数将向量转换为因子（无序分类变量）。例如：

gender <- c("Male", "Female", "Female", "Male")
gender_factor <- factor(gender)
print(gender_factor)
# 结果：
# [1] Male   Female Female Male  
# Levels: Female Male

factor()函数还可以通过labels参数为因子的水平指定自定义标签。例如：

gender_factor2 <- factor(gender, labels = c("女", "男"))
print(gender_factor2)
# 结果：
# [1] 男  女  女  男
# Levels: 女 男

此时，原始的"Female"和"Male"被替换为"女"和"男"作为因子标签。labels的顺序应与levels参数或自动识别的水平顺序一致。

有序因子

有序因子（Ordered Factor）用于表示具有顺序关系的分类数据（如“低、中、高”）。在R语言中，可以通过以下两种方式创建有序因子：

1. 使用factor()函数并指定ordered=TRUE参数

   score <- c("low", "medium", "high", "medium")
   score_ordered <- factor(score, levels = c("low", "medium", "high"), ordered = TRUE)
   print(score_ordered)
   # 结果：
   # [1] low    medium high   medium
   # Levels: low < medium < high
   

2. 使用ordered()函数

   score2 <- ordered(score, levels = c("low", "medium", "high"))
   print(score2)
   # 结果与上面相同
   

因子的操作与管理

• levels()：查看或设置因子的水平（分类标签）。

  levels(gender_factor)  # 查看因子的水平
  levels(gender_factor) <- c("F", "M")  # 修改水平名称
  

• nlevels()：返回因子的水平数。

  nlevels(gender_factor)  # 结果为2
  

• length()：返回因子中元素的个数（即观测值数量）。

  length(gender_factor)  # 结果为4
  

• table()：统计每个水平的频数。

  table(gender_factor)
  # 结果：
  #  F M 
  #  2 2
  

• 因子转向量：使用as.character()或as.numeric()将因子转换为普通向量。

  as.character(gender_factor)  # 转为字符型向量
  as.numeric(gender_factor)    # 转为对应的整数编码
  

• 无序因子转有序因子：

  ordered_factor <- as.ordered(gender_factor)
  

• 有序因子转无序因子：

  unordered_factor <- as.factor(ordered_factor)
  

数据框

• 数据类型

  • 矩阵（Matrix）：所有元素必须是相同的数据类型（如全为数值、全为字符等）。
  • 数据框（Data Frame）：每一列可以是不同的数据类型（如数值、字符、因子等），更适合存储结构化表格数据。

• 创建方式

  • 矩阵：使用matrix()、rbind()、cbind()等函数创建。
  • 数据框：使用data.frame()函数创建。

• 访问方式

  • 矩阵：通过[行, 列]方式访问元素。
  • 数据框：既可以用[行, 列]，也可以用$列名或[["列名"]]访问列。

• 应用场景

  • 矩阵：适用于所有数据类型一致的数学运算和线性代数操作。
  • 数据框：适用于数据分析、统计建模等需要处理多类型数据的场景。

• 示例
  r # 矩阵 m <- matrix(1:6, nrow=2) # 数据框 df <- data.frame(Name=c("Alice", "Bob"), Age=c(25, 30))

创建数据框

创建函数

在R语言中，常用以下两种方法创建数据框：

1. 使用 data.frame() 函数创建数据框
   直接通过 data.frame() 函数，将各列数据以参数形式传入，自动生成数据框。
   示例：

   df <- data.frame(
     Name = c("Alice", "Bob", "Charlie"),
     Age = c(25, 30, 28),
     Gender = c("F", "M", "M")
   )
   print(df)
   

2. 使用 as.data.frame() 函数将其他数据结构转换为数据框
   可以将矩阵、列表等数据结构转换为数据框。
   示例：

   m <- matrix(1:6, nrow = 2)
   df2 <- as.data.frame(m)
   print(df2)
   

data.frame() 适合直接创建新的数据框，as.data.frame() 适合将已有的数据结构转换为数据框。

数据框的行列名

• 查看行名和列名

  • 使用 rownames() 查看行名，colnames() 查看列名。
  • 示例：

    rownames(df)      # 查看数据框的行名
    colnames(df)      # 查看数据框的列名
    

• 修改行名和列名

  • 直接赋值即可修改行名或列名。
  • 示例：

    rownames(df) <- c("Row1", "Row2", "Row3")           # 修改行名
    colnames(df) <- c("姓名", "年龄", "性别")             # 修改列名
    

• 同时查看和修改行列名

  • 使用 dimnames() 可以同时查看或设置行名和列名。
  • 示例：

    dimnames(df)      # 查看行名和列名
    dimnames(df) <- list(c("A", "B", "C"), c("Name", "Age", "Gender"))  # 同时修改
    

数据框的数据结构

• str()：显示数据框的结构，包括每列的数据类型和部分数据内容。
  示例：

  str(df)
  # 输出类似：
  # 'data.frame':	3 obs. of  3 variables:
  #  $ Name  : chr  "Alice" "Bob" "Charlie"
  #  $ Age   : num  25 30 28
  #  $ Gender: chr  "F" "M" "M"
  

• class()：查看对象的类型，数据框返回 "data.frame"。
  示例：

  class(df)  # 输出 "data.frame"
  

• is.data.frame()：判断对象是否为数据框，返回逻辑值。
  示例：

  is.data.frame(df)  # 输出 TRUE
  

访问数据框

在R语言中，数据框（data.frame）可以通过多种方式访问其元素，包括行列名、二维索引、$符号和单个索引。常见方法如下：

1. 通过行名和列名访问

   • 使用df["行名", "列名"]可以访问指定行和列的元素。
   • 示例：

     df["Row1", "Age"]  # 访问行名为Row1、列名为Age的元素
     

2. 通过二维索引访问

   • 使用df[行索引, 列索引]，索引可以是数字、逻辑值或名称。
   • 示例：

     df[1, 2]        # 访问第1行第2列的元素
     df[1:2, c("Name", "Gender")]  # 访问前两行的Name和Gender列
     

3. 通过 $ 访问列

   • 使用df$列名可以直接访问数据框的某一列，返回一个向量。
   • 示例：

     df$Age      # 访问Age列
     

4. 通过单个索引访问

   • 使用df[索引]，当只提供一个索引时，返回对应的列（数据框）。
   • 示例：

     df[1]       # 返回第1列，类型仍为数据框
     df["Name"]  # 返回Name列，类型为数据框
     

注意：

• df[ , 列索引]返回的数据类型取决于是否加drop=FALSE参数，默认可能会降为向量。
• $只能用于访问列，不能用于访问行。
• 行名和列名可以通过rownames(df)和colnames(df)查看和设置。

操作数据框

R语言中，可以通过以下方式为数据框添加新的行或列：

1. 添加新列

   • 直接赋值新列名即可添加新列。

   • 示例：

     df$Score <- c(90, 85, 88)  # 添加Score列
     

   • 或使用 cbind() 合并新列：

     df <- cbind(df, Height = c(160, 175, 168))
     

2. 添加新行

   • 使用 rbind() 合并新行，需保证新行与原数据框列数和列名一致。

   • 示例：

     new_row <- data.frame(Name = "David", Age = 32, Gender = "M")
     df <- rbind(df, new_row)
     

   • 注意：如果数据框有因子型列，建议先将新行的列类型与原数据框保持一致。

这些方法可以灵活地扩展数据框的结构，适用于数据整理和补充。

串行

在R语言中，串行（List）是一种可以存储不同类型数据（如数值、字符、向量、矩阵、数据框等）的数据结构。List 的每个元素可以是任意类型和长度，甚至可以是另一个 List，非常灵活，适合存储复杂或异构的数据集合。

创建串行

利用 list() 函数创建串行

在R语言中，可以使用 list() 函数创建串行（List）对象。list() 可以包含任意类型和长度的数据元素，包括向量、矩阵、数据框、甚至其他串行。

基本用法：

lst <- list(
    name = "Alice",
    age = 25,
    scores = c(90, 85, 88),
    info = data.frame(height = 165, weight = 55)
)
print(lst)

• 可以为每个元素指定名称，方便后续访问。
• 串行中的元素类型和长度可以不同，支持嵌套结构。

无名称元素的串行：

lst2 <- list("apple", 3.14, TRUE)
print(lst2)

串行（list）的内容结构

• str()：显示list的结构和每个元素的类型、内容。
  示例：

  str(lst)
  # 输出类似：
  # List of 4
  #  $ name  : chr "Alice"
  #  $ age   : num 25
  #  $ scores: num [1:3] 90 85 88
  #  $ info  :'data.frame':	1 obs. of  2 variables:
  #   ..$ height: num 165
  #   ..$ weight: num 55
  

• class()：查看对象的数据类型。
  示例：

  class(lst)  # 输出 "list"
  

• names()：查看或设置list中各元素的名称。
  示例：

  names(lst)  # 输出 "name" "age" "scores" "info"
  

• length()：返回list中元素的个数。
  示例：

  length(lst)  # 输出 4
  

访问、操作串行

访问和操作串行（List）的常用方法

1. 使用 $ 运算符

   • 通过元素名称访问list中的元素，返回元素本身。
   • 示例：

     lst$name
     

2. 使用 [[]] 运算符

   • 通过索引或名称访问list中的单个元素，返回元素本身（原始类型）。
   • 示例：

     lst[[1]]         # 访问第1个元素
     lst[["name"]]    # 通过名称访问元素
     

3. 使用 [] 运算符

   • 通过索引或名称访问list中的一个或多个元素，返回一个新的list。
   • 示例：

     lst[1]           # 返回只包含第1个元素的list
     lst[c(1, 3)]     # 返回第1和第3个元素组成的新list
     lst["name"]      # 返回只包含name元素的list
     

4. 使用 c() 函数合并list

   • 可以将多个list合并为一个更大的list。
   • 示例：

     lst2 <- list(city = "Beijing")
     new_lst <- c(lst, lst2)
     print(new_lst)
     

R语言中的字符串操作

字符串的分割与连接

在R语言中，常用 strsplit() 函数进行字符串分割，使用 paste() 或 paste0() 函数进行字符串合并。

1. 字符串分割：strsplit()

• 语法：strsplit(x, split)

  • x：要分割的字符串（或字符串向量）
  • split：分隔符（正则表达式）

• 示例：

  s <- "apple,banana,cherry"
  result <- strsplit(s, split = ",")
  print(result)
  # 结果：list("apple", "banana", "cherry")
  

  注意：strsplit() 返回的是一个列表。

2. 字符串合并：paste() 和 paste0()

• paste(..., sep = " ")

  • 用指定分隔符连接多个字符串，默认用空格分隔。

  a <- "Hello"
  b <- "World"
  paste(a, b)           # 结果："Hello World"
  paste(a, b, sep = ",")# 结果："Hello,World"
  

• paste0(..., collapse = NULL)

  • 直接连接字符串，无分隔符。

  paste0(a, b)          # 结果："HelloWorld"
  

• 合并向量为单个字符串

  • 使用 collapse 参数将向量合并为一个字符串。

  fruits <- c("apple", "banana", "cherry")
  paste(fruits, collapse = "-")  # 结果："apple-banana-cherry"
  

总结

• strsplit() 用于分割字符串，返回列表。
• paste() 和 paste0() 用于合并字符串，可自定义分隔符或直接拼接。

字符串的修改与排序

在R语言中，常用以下函数对字符串进行大小写转换、去重、替换和排序操作：

1. 大小写转换

   • toupper()：将字符串全部转换为大写。

     s <- "Hello World"
     toupper(s)  # 结果为 "HELLO WORLD"
     

   • tolower()：将字符串全部转换为小写。

     tolower(s)  # 结果为 "hello world"
     

2. 去重

   • unique()：去除向量或字符串向量中的重复元素。

     fruits <- c("apple", "banana", "apple", "cherry")
     unique(fruits)  # 结果为 "apple" "banana" "cherry"
     

3. 字符串替换

   • sub()：替换字符串中首次出现的模式。

     s <- "apple, banana, apple"
     sub("apple", "orange", s)  # 结果为 "orange, banana, apple"
     

   • gsub()：替换字符串中所有出现的模式。

     gsub("apple", "orange", s)  # 结果为 "orange, banana, orange"
     

4. 字符串排序

   • sort()：对字符串向量进行排序。

     fruits <- c("banana", "apple", "cherry")
     sort(fruits)  # 结果为 "apple" "banana" "cherry"
     

字符串搜索与正则表达式

在R语言中，substr()、grep() 以及正则表达式是处理字符串的重要工具。

1. substr()：提取或替换字符串的子串

• 语法：substr(x, start, stop)

  • x：原始字符串
  • start：起始位置
  • stop：结束位置

• 示例：

  s <- "abcdef"
  substr(s, 2, 4)  # 结果为 "bcd"
  substr(s, 2, 4) <- "XYZ"
  print(s)         # 结果为 "aXYZef"
  

2. grep()：查找匹配正则表达式的字符串

• 语法：grep(pattern, x, value = FALSE)

  • pattern：正则表达式模式
  • x：字符串向量
  • value：是否返回匹配的元素（TRUE 返回元素，FALSE 返回索引）

• 示例：

  fruits <- c("apple", "banana", "cherry", "apricot")
  grep("^a", fruits)           # 返回以"a"开头的元素索引：1 4
  grep("^a", fruits, value=TRUE)  # 返回以"a"开头的元素："apple" "apricot"
  

3. 正则表达式

• 正则表达式用于描述字符串的匹配规则，常见符号包括：

  • ^：匹配字符串开头
  • $：匹配字符串结尾
  • .：匹配任意单个字符
  • *：匹配前面的字符零次或多次
  • +：匹配前面的字符一次或多次
  • []：匹配括号内的任意一个字符
  • |：或操作

• 示例：

  grep("a.e", fruits, value=TRUE)  # 匹配"a"和"e"之间有任意一个字符的字符串
  

if语句

if语句简介

在R语言中，if语句用于根据条件判断执行不同的代码块。常见形式包括if、if-else和if的嵌套。

1. if语句

只在条件为TRUE时执行某段代码：

x <- 5
if (x > 0) {
    print("x是正数")
}

2. if-else语句

根据条件选择执行不同的代码块：

x <- -3
if (x > 0) {
    print("x是正数")
} else {
    print("x不是正数")
}

3. if的嵌套

在if或else代码块中再使用if语句，实现多重条件判断：

x <- 0
if (x > 0) {
    print("x是正数")
} else if (x == 0) {
    print("x是零")
} else {
    print("x是负数")
}

ifelse函数简介

在R语言中，ifelse() 是一种向量化的条件判断函数，常用于对向量或数据框中的每个元素进行条件判断并返回不同的结果。

基本语法

ifelse(test, yes, no)

• test：逻辑判断条件（可以是逻辑向量）。
• yes：当条件为TRUE时返回的值。
• no：当条件为FALSE时返回的值。

示例

x <- c(5, -2, 0, 8)
result <- ifelse(x > 0, "正数", "非正数")
print(result)
# 结果： "正数" "非正数" "非正数" "正数"

特点

• ifelse() 支持向量化操作，适合批量数据处理。
• 可以用于数据清洗、分组赋值等场景。

注意：ifelse() 适合元素级别的条件判断，若需复杂分支逻辑建议使用 if 或 if-else 语句。

switch语句简介

在R语言中，switch() 是一种多分支选择结构，用于根据表达式的值选择并执行不同的代码块。常用于替代多重 if-else 语句，使代码更简洁。

基本语法

switch(EXPR, case1, case2, case3, ...)

• EXPR：可以是字符型或数值型表达式。
• case1, case2, ...：各个分支的返回值或表达式。

用法示例

1. 字符型分支选择

x <- "b"
result <- switch(x,
    a = "你选择了A",
    b = "你选择了B",
    c = "你选择了C",
    "未匹配到选项"
)
print(result)  # 输出 "你选择了B"

2. 数值型分支选择

y <- 2
result <- switch(y, "第一个", "第二个", "第三个")
print(result)  # 输出 "第二个"

特点

• 如果 EXPR 为字符型，则匹配对应名称的分支。
• 如果 EXPR 为数值型，则按位置选择第 EXPR 个分支。
• 若未匹配到，返回最后一个无名分支或 NULL。

循环

在R语言中，常用的循环结构包括for、while和repeat循环。循环体内可以使用next和break语句进行流程控制。

1. for循环

for循环用于遍历向量、列表等集合，对每个元素执行相同的操作。

for (i in 1:5) {
    print(i)
}

2. while循环

while循环在条件为TRUE时反复执行循环体，直到条件为FALSE。

i <- 1
while (i <= 5) {
    print(i)
    i <- i + 1
}

3. repeat循环

repeat循环会无限执行，直到遇到break语句跳出循环。

i <- 1
repeat {
    print(i)
    i <- i + 1
    if (i > 5) break
}

4. next和break语句

• next：跳过本次循环的剩余部分，直接进入下一次循环。
• break：立即终止整个循环。

示例：

for (i in 1:5) {
    if (i == 3) next    # 跳过i等于3时的循环
    if (i == 5) break   # i等于5时终止循环
    print(i)
}
# 输出：1 2 4

函数

函数的定义与参数设置

1. 定义函数的基本语法

函数名 <- function(参数1, 参数2 = 默认值, ...) {
    # 函数体
    # 可以包含多条语句
    return(返回值)
}

• 函数名：自定义的函数名称。
• 参数1, 参数2：函数的输入参数，可以设置默认值。
• ...：用于接收不定数量的额外参数。
• return()：指定函数的返回值（可省略，R默认返回最后一条语句的结果）。

2. 示例：定义一个带参数的函数

add <- function(x, y = 1) {
    result <- x + y
    return(result)
}
add(5, 3)    # 结果为8
add(5)       # 结果为6（使用默认参数y=1）

3. 参数设置说明

• 必选参数：调用函数时必须传递的参数。
• 默认参数：在函数定义时为参数赋默认值，调用时可省略。
• 不定参数（...）：允许传递任意数量的参数，常用于封装和扩展。

4. 查看和调用函数

• 使用 args(函数名) 查看函数的参数列表。
• 调用函数时，可以按顺序传参，也可以使用 参数名 = 值 的方式指定参数。

R中的函数

基本数据操作

函数名	作用简述
c()	创建向量
seq()	生成等差数列
rep()	生成重复元素的向量
length()	返回对象长度
unique()	去重
sort()	排序
rev()	反转顺序
diff()	相邻元素差值
rank()	元素排名
which()	TRUE索引

类型与结构及类型转换

函数名	作用简述
class()	查看数据类型
str()	查看结构
is.na()	是否为NA
is.nan()	是否为NaN
isTRUE()	是否为TRUE
identical()	是否完全相同
names()	获取/设置名称

数值计算

函数名	作用简述
sum()	元素之和
mean()	平均值
sd()	标准差
var()	方差
max()	最大值
min()	最小值
prod()	元素乘积
cumsum()	累加和
cumprod()	累积乘积
cummax()	累计最大值
cummin()	累计最小值
abs()	绝对值
exp()	e的幂
log()	对数
sqrt()	平方根
factorial()	阶乘
floor()	向下取整
ceiling()	向上取整
trunc()	截断小数
round()	四舍五入
signif()	有效数字
rowMeans()	按行求平均
colSums()	按列求和
colMeans()	按列求平均
t()	矩阵转置
diag()	创建或提取对角线
solve()	求逆矩阵
det()	计算行列式
array()	创建多维数组

因子与数据框

函数名	作用简述
factor()	创建因子
ordered()	创建有序因子
levels()	获取或设置因子水平
nlevels()	返回因子水平数
is.factor()	判断是否为因子
as.ordered()	转换为有序因子
as.factor()	转换为无序因子
table()	统计频数
data.frame()	创建数据框
is.data.frame()	判断是否为数据框
as.data.frame()	转换为数据框

类型转换

函数名	作用简述
as.character()	类型转换为字符型
as.numeric()	类型转换为数值型
as.integer()	类型转换为整数型
as.logical()	类型转换为逻辑型

列表

函数名	作用简述
list()	创建串行（列表）

条件与流程控制

函数名	作用简述
ifelse()	向量化条件判断
switch()	多分支选择结构

函数相关

函数名	作用简述
args()	查看函数参数列表
print()	打印输出
head()	提取前若干个元素
tail()	提取后若干个元素

help与example

在R语言中，help() 和 example() 是非常实用的内置帮助函数 如果你忘记了 某个函数的功能或者写法 在编译器里使用help和example可以帮助你回忆（需要一点英文基础）

1. help() 或 ?：查看函数帮助文档

• 用法：help(函数名) 或 ?函数名
• 作用：打开指定函数的帮助页面，查看用法、参数、示例等详细说明。
• 示例：

  help(mean)   # 查看mean函数的帮助文档
  ?mean        # 等价写法
  

2. example()：运行函数示例

• 用法：example(函数名)
• 作用：自动运行帮助文档中给出的示例代码，便于快速理解函数的实际用法。
• 示例：

  example(mean)  # 运行mean函数的示例代码
  

小技巧：如果不确定函数名，可以用 help.search("关键词") 或 ??关键词 搜索相关帮助文档。