R语言常用基本函数，含实例：万字总结

news2024/9/25 17:16:28

目录

vector:创建向量（默认填充0，空字符，FALSE）

data.frame :可以看作由多个向量组成的表格，每个向量代表表格的一列数据

sequence:创建序列(可以简写为seq)

dim:获取矩阵或数组的维度信息

length

subset：从数据框和向量中提取子集

list

unlist：将列表转换为向量

排序（sort,order,unique,rev）

attr：获取或设置对象的特定属性

attributes：获取或设置对象的所有属性

typeof：获取给定对象的数据类型的函数

names:获取或设置对象的名称

nchar:计算字符向量或字符串的长度

substr: 从字符串中提取子串

format: 格式化数值

formatC: 格式化数值，并将其转换为字符型向量

paste: 将多个对象拼接成一个字符向量的函数

sapply:用于应用函数到向量、列表或数据框的便捷工具函数

strsplit:根据指定的分隔符将一个字符串对象拆分成多个子字符串，并返回一个包含拆分结果的列表或字符向量

charmatch：在向量或矩阵中查找匹配的字符，它返回一个表示匹配位置的整数向量

pmatch: 在向量或矩阵中进行部分匹配

grep:用于在字符向量中查找模式（pattern）匹配的元素，并返回匹配的位置或索引

sub：替换字符串中第一个匹配项的函数

gsub：用于替换字符串中所有匹配项的函数

复数

factor:因子是一种用于表示分类数据的数据类型，它将离散的取值映射为有序或无序的级别

nlevels:获取因子（factor）对象的级别数量

codes：因子的编码

cut：对数值变量进行划分时，可以根据不同的需求选择不同的参数配置

table：获取划分后每个区间的计数

split:根据指定的因子或向量来拆分数据框、列表或向量

aggregate:按照指定的因子或条件对数据进行聚合计算

tapply:根据指定的因子或条件对数据进行分组并应用于每个组的函数

vector:创建向量（默认填充0，空字符，FALSE）

vector(mode, length)

  • mode：指定向量的数据类型，例如 "numeric"（数值型），"character"（字符型），"logical"（逻辑型）等。
  • length：指定向量的长度，即元素的个数。

(1)创建一个包含整数类型的向量：

# 创建一个包含5个整数的向量
my_vector <- vector("integer", 5)
print(my_vector)

 结果

[1] 0 0 0 0 0 

(2)创建一个字符型向量：

# 创建包含字符元素的向量
my_vector <- vector("character", 3)
print(my_vector)

结果

[1] " " " " " "

(3) 创建一个逻辑型向量：

# 创建包含逻辑元素的向量
my_vector <- vector("logical", 4)
print(my_vector)

结果

[1] FALSE FALSE FALSE FALSE

 (4)直接创建向量

# 创建一个数值型向量
my_vector <- c(1, 2, 3, 4, 5)
print(my_vector)

结果

[1] 1 2 3 4 5

data.frame :可以看作由多个向量组成的表格，每个向量代表表格的一列数据

(1) 创建一个包含姓名和年龄的data.frame

name <- c("Alice", "Bob", "Charlie")
age <- c(25, 30, 35)

my_df <- data.frame(Name = name, Age = age)
print(my_df)

结果

    Name Age
1  Alice  25
2    Bob  30
3 Charlie 35
 

(2)访问列数据

# 访问列数据
print(my_df$Name)   # 打印Name列的数据
print(my_df$Age)    # 打印Age列的数据

 结果

[1] Alice Bob Charlie

[1] 26 31 36

（3）修改列数据 

my_df$Age <- c(26, 31, 36)   # 将Age列的数据修改为新的值
print(my_df)

结果

    Name Age
1  Alice  26
2    Bob  31
3 Charlie 36

sequence:创建序列(可以简写为seq)

（1）生成1~10的序列

seq <- sequence(10)
print(seq)

结果

 [1]  1  2  3  4  5  6  7  8  9 10

 (2)生成10~1的递减序列

seq <- sequence(10, from = 10, to = 1, by = -1)
#from是起始数字,to是结尾数字,by表示递增或递减的步长
print(seq)

结果

 [1] 10  9  8  7  6  5  4  3  2  1

（3）生成步长为2的从1到10的序列

seq <- sequence(5, from = 1, by = 2)
print(seq)

结果

[1] 1 3 5 7 9

（4）创建一个重复的序列：

结果 

[1] 1 1 2 2 3 

dim:获取矩阵或数组的维度信息

（1）获取矩阵的维度

mat <- matrix(1:6, nrow = 2)
#列出1~6数值的矩阵,矩阵的行数为2
dims <- dim(mat)
print(dims)

#补充
sub_mat <- mat[1:2, ]
print(sub_mat)

[1] 2 3 

#补充

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

（2）获取数组维度 

#1
arr <- array(1:12, dim = c(2, 3, 2))
print(arr)


#2
dims <- dim(arr)
print(dims)

结果1

, , 1

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

, , 2

     [,1] [,2] [,3]
[1,]    7    9   11
[2,]    8   10   12

结果2

[1] 2 3 2

length

(1)计算向量的长度

vec <- c(1, 2, 3, 4, 5)
len <- length(vec)
print(len)

[1] 5

 (2)计算列表的长度：

lst <- list("apple", "banana", "orange")
len <- length(lst)
print(len)

[1] 3

(3) 计算数组的长度：

arr <- array(1:12, dim = c(2, 3, 2))
#
len <- length(arr)
print(len)

[1] 12

subset：从数据框和向量中提取子集

（1）从数据框中提取符合条件的子集：

# 创建一个数据框
df <- data.frame(Name = c("Alice", "Bob", "Charlie"),
                 Age = c(25, 30, 35),
                 Gender = c("Female", "Male", "Male"))

# 提取年龄大于等于30岁的子集
subset_df <- subset(df, Age >= 30)
print(subset_df)

     Name Age Gender
2     Bob  30   Male
3 Charlie  35   Male

（2）从向量中提取符合条件的子集：

# 创建一个向量
vec <- c(10, 5, 8, 3, 6)

# 提取大于等于5的元素
subset_vec <- subset(vec, vec >= 5)
print(subset_vec)

[1] 10  5  8  6

list

(1)创建一个包含多个元素的列表：

# 创建一个列表
my_list <- list("Alice", 25, c(1, 2, 3), TRUE)

# 打印列表
print(my_list)

[[1]]
[1] "Alice"

[[2]]
[1] 25

[[3]]
[1] 1 2 3

[[4]]
[1] TRUE

 (2)访问和操作列表中的元素

# 访问列表中的元素
name <- my_list[[1]]
age <- my_list[[2]]
numbers <- my_list[[3]]
is_true <- my_list[[4]]

# 打印提取的元素
print(name)
print(age)
print(numbers)
print(is_true)

[1] "Alice"
[1] 25
[1] 1 2 3
[1] TRUE

（3）向列表中添加元素

# 添加新元素到列表中
my_list[[5]] <- "New element"

# 打印更新后的列表
print(my_list)

[[1]]
[1] "Alice"

[[2]]
[1] 25

[[3]]
[1] 1 2 3

[[4]]
[1] TRUE

[[5]]
[1] "New element"

unlist：将列表转换为向量

my_list <- list(a = 1, b = 2, c = 3)
my_vector <- unlist(my_list)
#经过 unlist() 转换后得到了向量 {1, 2, 3}
#其中元素的名称分别为 "a"、"b" 和 "c"
print(my_vector)

 a b c 
 1 2 3 

排序（sort,order,unique,rev）

(1)sort:对向量或数据框的元素进行升序排序

# 对向量进行排序
x <- c(5, 2, 8, 3, 1)
sorted_x <- sort(x)

# 打印排序后的向量
print(sorted_x)

[1] 1 2 3 5 8

（2）order： 返回按照给定向量排序的索引（默认升序）

# 获取按照向量排序的索引
x <- c(5, 2, 8, 3, 1)
sorted_index <- order(x)

# 打印排序后的索引
print(sorted_index)

[1] 5 2 4 1 3

索引1表示的是排序最小的值，也就是1，1的位置在第5个，所以显示5，以此类推

如果想结果降序排列，有下面两种写法

#1
x <- c(5, 2, 8, 3, 1)
sorted_index <- order(x, decreasing = TRUE)

print(sorted_index)

#2
x <- c(5, 2, 8, 3, 1)
sorted_index <- order(-x)

print(sorted_index)

 [1] 3 1 4 2 5

（3） unique：用于提取向量中的唯一值

# 提取向量中的唯一值
x <- c(2, 1, 3, 2, 1, 4)
unique_values <- unique(x)

# 打印唯一值
print(unique_values)

[1] 2 1 3 4

（4）rev:将向量或列表倒序排列

# 将向量倒序排列
x <- c(1, 2, 3, 4, 5)
reversed_x <- rev(x)

# 打印倒序排列后的向量
print(reversed_x)

 [1] 1 3 8 2 5

attr：获取或设置对象的特定属性

（1）设置对象属性

my_vector <- c(1, 2, 3)
attr(my_vector, "description") <- "This is a vector of numbers"

（2）获取对象属性

my_matrix <- matrix(1:9, nrow = 3)
attr(my_matrix, "dimnames") <- list(c("row1", "row2", "row3"), c("col1", "col2", "col3"))
dims <- attr(my_matrix, "dimnames")
print(dims)
[[1]]
[1] "row1" "row2" "row3"

[[2]]
[1] "col1" "col2" "col3"

my_matrix如图所示

attributes：获取或设置对象的所有属性

my_vector <- c(1, 2, 3)
attr(my_vector, "description") <- "This is a vector of numbers"
attr(my_vector, "author") <- "John Doe"

all_attributes <- attributes(my_vector)

print(all_attributes)

$description
[1] "This is a vector of numbers"

$author
[1] "John Doe"

typeof：获取给定对象的数据类型的函数

（1）向量的数据类型

my_vector <- c(1, 2, 3)
type <- typeof(my_vector)

print(type)

[1] "double"

（2）矩阵的数据类型

my_matrix <- matrix(1:9, nrow = 3)
type <- typeof(my_matrix)

print(type)

[1] "integer"

（3） 字符型数据的数据类型

my_string <- "Hello, World!"
type <- typeof(my_string)

print(type)

[1] "character"

names:获取或设置对象的名称

(1)向量的名称

my_vector <- c(1, 2, 3)
names(my_vector) <- c("a", "b", "c")

print(names(my_vector))

[1] "a" "b" "c"

(2) 列表的名称

my_list <- list(a = 1, b = 2, c = 3)

print(names(my_list))

[1] "a" "b" "c"

(3) 数据框的名称

my_df <- data.frame(x = c(1, 2, 3), y = c(4, 5, 6))
print(names(my_df))

[1] "x" "y"

(4)设置对象名称

my_vector <- c(1, 2, 3)
names(my_vector) <- c("a", "b", "c")
#my_vector 的元素分别设置名称 "a"、"b" 和 "c"

nchar:计算字符向量或字符串的长度

my_string <- "Hello, world!"
length <- nchar(my_string)
print(length)
[1] 13

substr: 从字符串中提取子串

（1）提取子串

my_string <- "Hello, world!"
substring <- substr(my_string, start = 1, stop = 5)
print(substring)

[1] "Hello"

 (2)使用负数来指定相对于字符串末尾的位置

my_string <- "Hello, world!"
substring <- substr(my_string, start = -3, stop = -1)
print(substring)

[1] "rld"

format: 格式化数值

x <- 12345.6789
formatted <- format(x, big.mark = ",", decimal.mark = ".", nsmall = 2)
print(formatted)
[1] "12,345.68"

参数：

  1. nsmall：一个整数参数，用于指定保留的小数位数。

  2. scientific：一个逻辑值参数，用于控制是否使用科学计数法来表示数值。如果设置为 TRUE，则使用科学记数法；如果设置为 FALSE，则不使用科学计数法。

  3. big.mark：一个字符型参数，用于指定千位分隔符号的显示方式。默认情况下，R 使用逗号 , 作为千位分隔符号。

  4. decimal.mark：一个字符型参数，用于指定小数部分的小数点符号。默认情况下，R 使用小数点 . 作为小数点符号。

  5. trim：一个逻辑值参数，用于控制是否删除尾部多余的零。如果设置为 TRUE，则删除尾部多余的零；如果设置为 FALSE，则保留所有小数位数。

formatC: 格式化数值，并将其转换为字符型向量

x <- 12345.6789
formatted <- formatC(x, format = "f", digits = 2)
print(formatted)
[1] "12345.68"

参数：

  1. x：要格式化的数据对象，可以是单个数字、向量或矩阵。

  2. format：一个字符型参数，用于指定格式的字符串。你可以使用不同的占位符来表示各种格式，例如 %d 表示整数、%f 表示浮点数、%e 表示科学计数法、%s 表示字符型等。

  3. digits：一个整数参数，用于指定保留的小数位数。当格式为浮点数时，通过设置 digits 参数可以控制小数位数。

  4. width：一个整数参数，用于指定输出字符的总宽度。如果设定了 width 参数，且输出字符的长度不足 width，则会在左侧填充空格以达到指定的宽度。

  5. flag：一个字符型参数，用于设置特殊标志。例如，`flag = "#"`` 可以在八进制数格式化时添加前缀 "0"，在十六进制数格式化时添加前缀 "0x"。

paste: 将多个对象拼接成一个字符向量的函数

# 示例 1：拼接两个向量
x <- c("Hello", "world")
y <- c("How", "are", "you?")
result <- paste(x, y)
print(result)
# 输出: "Hello How" "world are" " you?"

# 示例 2：指定分隔符
result <- paste(x, y, sep = "-")
print(result)
# 输出: "Hello-How" "world-are" "you?"

# 示例 3：折叠拼接结果
result <- paste(x, y, collapse = " ")
print(result)
# 输出: "Hello world How are you?"

#collapse 参数设置为空字符串,这样多个对象就会按照空格分隔并拼接成一个字符串。

sapply:用于应用函数到向量、列表或数据框的便捷工具函数

# 创建一个数字向量
numbers <- c(1, 2, 3, 4, 5)

# 使用sapply计算每个数字的平方
squared_numbers <- sapply(numbers, function(x) x^2)

# 输出结果
print(squared_numbers)

[1] 1 4 9 16 25

strsplit:根据指定的分隔符将一个字符串对象拆分成多个子字符串，并返回一个包含拆分结果的列表或字符向量

str <- "Hello,world,how,are,you?"
result <- strsplit(str, split = ",")
print(result)

[[1]]
[1] "Hello" "world" "how"   "are"   "you?"

 获取第一个拆分结果

 str <- "apple,banana,carrot|dog,cat,rabbit|red,green,blue"
 results <- strsplit(str, split = "\\|")
 print(results)
 first_elements <- sapply(results, function(x) x[[1]])
#返回子列表的第一个元素
 print(first_elements)
[[1]]
[1] "apple,banana,carrot"
[2] "dog,cat,rabbit"     
[3] "red,green,blue"
[1] "apple,banana,carrot"

charmatch：在向量或矩阵中查找匹配的字符，它返回一个表示匹配位置的整数向量

charmatch(target, x, nomatch = NA)
  • target是要查找的目标字符向量。
  • x是被搜索的字符向量。
  • nomatch是当无法找到匹配时要返回的值，默认为NA。
# 创建一个字符向量
fruits <- c("apple", "banana", "orange", "mango")

# 使用charmatch查找元素的位置
match_index <- charmatch("banana", fruits)

# 输出结果
print(match_index)

[1] 2

如果要查找的元素不在字符向量中

# 使用charmatch查找不存在的元素的位置
match_index <- charmatch("grape", fruits, nomatch = 0)

# 输出结果
print(match_index)

[1] 0

模糊匹配

使用==运算符进行模糊匹配：

fruits <- c("apple", "banana", "orange", "mango")
target <- "banana"

# 循环遍历字符向量并进行模糊匹配
matches <- c()
for (i in 1:length(fruits)) {
  if (target == fruits[i]) {
    matches <- c(matches, i)
  }
}
print(fruits[matches])

[1] "banana"

 如果是

> target <- "banaba"
character(0)

 使用%in%运算符进行模糊匹配：

fruits <- c("apple", "banana", "orange", "mango")
target <- c("banaba", "apple")

# 使用向量化操作进行模糊匹配
matches <- fruits %in% target
print(fruits[matches])

[1] "apple"

fruits <- c("apple", "banana", "orange", "mango")
target <- c("banana", "apple")

# 使用向量化操作进行模糊匹配
matches <- fruits %in% target
print(fruits[matches])

[1] "apple"  "banana"

pmatch: 在向量或矩阵中进行部分匹配

pmatch(target, vector, duplicates.ok = FALSE)
  • target：要查找的模式或目标项。
  • vector：要在其中进行匹配的向量或矩阵。
  • duplicates.ok：一个逻辑值，表示是否允许多个匹配项。默认为FALSE，即只返回第一个匹配项的索引。如果设置了duplicates.ok = TRUE，则会返回所有匹配项的索引。 
fruits <- c("apple", "banana", "orange", "mango")
target <- "ban"

matches <- pmatch(target, fruits)
print(matches)

[1] 2

fruits <- c("apple", "banana", "orange", "mango")
target <- "pp"

matches <- pmatch(target, fruits)
print(matches)

 [1] NA

grep:用于在字符向量中查找模式（pattern）匹配的元素，并返回匹配的位置或索引

grep(pattern, x, ignore.case = FALSE, perl = FALSE, value = FALSE, fixed = FALSE, ...)
  • pattern：要匹配的模式，可以是一个正则表达式或简单的字符模式。
  • x：要在其中进行搜索的向量、列表或数据框。
  • ignore.case：一个逻辑值，表示是否忽略大小写。默认为FALSE。
  • perl：一个逻辑值，表示是否使用Perl正则表达式。默认为FALSE。
  • value：一个逻辑值，表示是否返回匹配的元素本身而不是索引位置。默认为FALSE。
  • fixed：一个逻辑值，表示是否将pattern视为字面字符串而不是正则表达式。默认为FALSE。
fruits <- c("apple", "banana", "orange", "mango")

# 返回包含"an"的元素的索引位置
matches <- grep("an", fruits)
print(matches)
# 输出: [1] 1 2

# 返回以字母"a"开头的元素的索引位置
matches_start_with_a <- grep("^a", fruits)
print(matches_start_with_a)
# 输出: [1] 1

# 返回包含字母"o"或"e"的元素的索引位置
matches_o_or_e <- grep("[oe]", fruits)
print(matches_o_or_e)
# 输出: [1] 1 3 4

# 返回与正则表达式匹配的元素本身
matching_elements <- grep("an", fruits, value = TRUE)
print(matching_elements)
# 输出: [1] "apple"  "banana"

# 忽略大小写进行匹配
ignore_case_matches <- grep("O", fruits, ignore.case = TRUE)
print(ignore_case_matches)
# 输出: [1] 3

sub：替换字符串中第一个匹配项的函数

sub(pattern, replacement, x, ignore.case = FALSE, perl = FALSE, fixed = FALSE, ...)
  • pattern：要匹配的模式，可以是一个正则表达式或简单的字符模式。
  • replacement：要替换匹配项的字符串。
  • x：要在其中进行替换的向量、列表或数据框。
  • ignore.case：一个逻辑值，表示是否忽略大小写。默认为FALSE。
  • perl：一个逻辑值，表示是否使用Perl正则表达式。默认为FALSE。
  • fixed：一个逻辑值，表示是否将pattern视为字面字符串而不是正则表达式。默认为FALSE。
fruit <- "banana"

# 将第一个匹配的"a"替换为"o"
replaced <- sub("a", "o", fruit)
print(replaced)
# 输出: [1] "bonana"

# 忽略大小写进行替换
ignore_case_replaced <- sub("A", "o", fruit, ignore.case = TRUE)
print(ignore_case_replaced)
# 输出: [1] "bonana"

# 将数字替换为空字符串
numbers <- c("value1", "value2", "value3")
numbers_replaced <- sub("[0-9]", "", numbers)
print(numbers_replaced)
# 输出: [1] "value"  "value2" "value3"

gsub：用于替换字符串中所有匹配项的函数

gsub(pattern, replacement, x, ignore.case = FALSE, perl = FALSE, fixed = FALSE, ...)
  • pattern：要匹配的模式，可以是一个正则表达式或简单的字符模式。
  • replacement：要替换匹配项的字符串。
  • x：要在其中进行替换的向量、列表或数据框。
  • ignore.case：一个逻辑值，表示是否忽略大小写。默认为FALSE。
  • perl：一个逻辑值，表示是否使用Perl正则表达式。默认为FALSE。
  • fixed：一个逻辑值，表示是否将pattern视为字面字符串而不是正则表达式。默认为FALSE。
  • ...：其他传递给正则表达式替换函数的参数。
fruit <- "banana"

# 将所有匹配的"a"替换为"o"
replaced <- gsub("a", "o", fruit)
print(replaced)
# 输出: [1] "bonono"

# 忽略大小写进行替换
ignore_case_replaced <- gsub("A", "o", fruit, ignore.case = TRUE)
print(ignore_case_replaced)
# 输出: [1] "bonono"

# 将所有数字替换为空字符串
numbers <- c("value1", "value2", "value3")
numbers_replaced <- gsub("[0-9]", "", numbers)
print(numbers_replaced)
# 输出: [1] "value"  "value"  "value"

复数

（1）complex()：创建一个复数。它接受两个参数，分别是实部和虚部

# 创建复数：2 + 3i
z <- complex(real = 2, imaginary = 3)
print(z)
# 输出: [1] 2+3i

（2）Re()：返回复数的实部

# 获取复数的实部
real_part <- Re(z)
print(real_part)
# 输出: [1] 2

（3）Im()：返回复数的虚部

# 获取复数的虚部
imaginary_part <- Im(z)
print(imaginary_part)
# 输出: [1] 3

（4）Mod()：返回复数的模（绝对值）

# 获取复数的模
modulus <- Mod(z)
print(modulus)
# 输出: [1] 3.605551

（5）Arg()：返回复数的辐角

# 获取复数的辐角
argument <- Arg(z)
print(argument)
# 输出: [1] 0.9827937

(6)Conj()：返回复数的共轭

# 获取复数的共轭
conjugate <- Conj(z)
print(conjugate)
# 输出: [1] 2-3i

factor:因子是一种用于表示分类数据的数据类型，它将离散的取值映射为有序或无序的级别

factor(x, levels, labels, ordered = FALSE)
  • x：要转换为因子的向量或因子（或其他对象）。
  • levels：可选参数，指定因子的级别。它可以是一个字符向量或整数向量。如果没有指定级别，将使用唯一的x中的取值作为级别。
  • labels：可选参数，指定因子的标签（用于表示每个级别的名字）。如果没有指定标签，将使用级别的字符串表示。
  • ordered：一个逻辑值，表示是否创建有序因子。如果为TRUE，则表示级别之间存在顺序关系，默认为FALSE。
# 创建一个无序因子
x <- c("A", "B", "A", "C", "B")
f <- factor(x)
print(f)
labels <- levels(f)
print(labels)
# 输出: [1] A B A C B
# Levels: A B C

# 创建一个有序因子
y <- c("low", "medium", "high", "low", "high")
o <- factor(y, levels = c("low", "medium", "high"), ordered = TRUE)
print(o)
labels <- levels(o)
print(labels)
# 输出: [1] low    medium high   low    high  
# Levels: low < medium < high

# 指定标签的因子
z <- c("male", "female", "female", "male")
g <- factor(z, levels = c("male", "female"), labels = c("M", "F"))
print(g)
labels <- levels(g)
print(labels)
# 输出: [1] M F F M
# Levels: M F

#因子的各水平的名字,可以通过levels进行数据的分类和汇总分析

nlevels:获取因子（factor）对象的级别数量

# 创建一个因子
x <- c("A", "B", "A", "C", "B")
f <- factor(x)

# 获取因子的级别数量
num_levels <- nlevels(f)
print(num_levels)
# 输出: 3

codes：因子的编码

# 创建一个因子
x <- c("A", "B", "A", "C", "B")
f <- factor(x)

# 获取因子的代码
codes <- as.integer(f)
print(codes)
# 输出: [1] 1 2 1 3 2

# 将代码转换回级别标签
labels <- labels(f)
print(labels)
# 输出: [1] "A" "B" "C"

注：as.integer:将数据转化为整型

# 将数值转换为整数
x <- 3.14
x_integer <- as.integer(x)
print(x_integer)
# 输出: 3

# 将逻辑值 TRUE 和 FALSE 转换为整数
logic_val <- TRUE
logic_val_integer <- as.integer(logic_val)
print(logic_val_integer)
# 输出: 1

logic_val <- FALSE
logic_val_integer <- as.integer(logic_val)
print(logic_val_integer)
# 输出: 0

# 将字符型转换为整数
text <- "123"
text_integer <- as.integer(text)
print(text_integer)
# 输出: 123

cut：对数值变量进行划分时，可以根据不同的需求选择不同的参数配置

（1）指定分割点

# 创建一个数值向量
x <- c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

# 使用cut()函数将数值划分为三个离散的区间
cuts <- cut(x, breaks = c(0, 5, 8, 10))
print(cuts)
# 输出:
# [1] (0,5] (0,5] (0,5] (0,5] (0,5] (5,8] (5,8] (5,8] (8,10] (8,10]
# Levels: (0,5] (5,8] (8,10]

（2）指定区间数量

# 创建一个数值向量
x <- c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

# 使用cut()函数将数值划分为五个离散的区间
cuts <- cut(x, breaks = 5)
print(cuts)
# 输出:
# [1] (0.992,2.8]  (0.992,2.8]  (0.992,2.8]  (2.8,4.6]    (4.6,6.4]   
# [6] (6.4,8.2]    (8.2,10]     (8.2,10]     (8.2,10]     (8.2,10]    
# Levels: (0.992,2.8] (2.8,4.6] (4.6,6.4] (6.4,8.2] (8.2,10]

table：获取划分后每个区间的计数

x <- c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
cuts <- cut(x, breaks = 5)
table(cuts)

split:根据指定的因子或向量来拆分数据框、列表或向量

split(x, f, drop = FALSE, ...)
  • x：要拆分的对象，可以是数据框、列表或向量。
  • f：用于拆分的因子或向量。
  • drop：逻辑值，表示是否删除空的拆分组。默认为 FALSE，即保留空的拆分组。
x <- c(1, 2, 3, 4, 5)
f <- c("A", "B", "A", "B", "A")
result <- split(x, f)

$A

[1] 1 3 5

$B

[1] 2 4

aggregate:按照指定的因子或条件对数据进行聚合计算

aggregate(formula, data, FUN, ...)
  • formula：用于指定聚合操作的公式，通常形式为 y ~ x，其中 y 是要聚合的变量，x 是用于分组的因子或变量。
  • data：要进行聚合计算的数据框或列表。
  • FUN：表示要应用的聚合函数。可以是内置的聚合函数（如sum、mean、max等），也可以是用户自定义的函数。
# 创建一个示例数据框
df <- data.frame(
  group = c("A", "A", "B", "B", "A"),
  value = c(1, 2, 3, 4, 5)
)

# 使用aggregate()函数计算每个组的平均值
result <- aggregate(value ~ group, data = df, FUN = mean)
print(result)

tapply:根据指定的因子或条件对数据进行分组并应用于每个组的函数

tapply(X, INDEX, FUN, ..., simplify = TRUE)
  • INDEX：表示分组的因子、列表或数组。
  • FUN：要应用于每个组的函数，可以是内置的函数（如sum、mean、max等），也可以是用户自定义的函数。
  • simplify：逻辑值，表示是否简化结果。默认为 TRUE，即使用简化的结果。
# 创建示例向量
x <- c(1, 2, 3, 4, 5)
f <- c("A", "A", "B", "B", "A")

# 使用tapply()函数计算每个组的总和
result <- tapply(x, f, sum)

A B

8 7

整理不易，如有错误或遗漏，请大佬们不吝赐教！！💖💖💖

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/930201.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

优思学院｜传统流水线生产与单元式生产的差异与优势对比

优思学院｜传统流水线生产与单元式生产的差异与优势对比

在制造业领域&#xff0c;生产方式的选择对于生产效率和产品质量至关重要。传统流水线生产和精益生产中的单元式生产是两种常见的生产模式&#xff0c;它们在工作方式、优势以及适用情境上存在着显著的差异。本文将对传统流水线生产和单元式生产进行比较&#xff0c;并探讨它们…
阅读更多...
“探索Spring与MyBatis集成的最佳实践与技巧“

“探索Spring与MyBatis集成的最佳实践与技巧“

目录 引言&#xff1a;1.Spring与MyBatis集成的基本配置2.Spring aop集成pagehelper插件总结附带内容&#xff1a; 引言&#xff1a; 在现代的软件开发中&#xff0c;Spring和MyBatis是两个非常流行的框架。Spring提供了强大的依赖注入和面向切面编程的功能&#xff0c;而MyBa…
阅读更多...
炫酷前端页面，鼠标点击特效

炫酷前端页面，鼠标点击特效

最近发现了两个好看的鼠标点击特效&#xff0c;收藏起来用作学习使用&#xff0c;以及更方便的利用 一、鼠标点击弹出爱心 效果图 html源码如下&#xff1a; <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><m…
阅读更多...
应知道的python基础知识

应知道的python基础知识

1、运算符 2、特殊情况下的逻辑运算 3、循环中的else 3.1 while else 3.2 for else 4、列表相关操作 列表的相关操作 4.1增(append, extend, insert) 通过append可以向列表添加元素：列表.append(新元素数据)通过extend可以将另一个列表中的元素逐一添加到列表中：列表.exte…
阅读更多...
【推荐】Spring与Mybatis集成

【推荐】Spring与Mybatis集成

目录 1.概述 2.集成 2.1代码演示&#xff1a; 3.整合 3.1概述 3.2 进行整合分页 接着上两篇&#xff0c;我已经写了Mybatis动态之灵活使用&#xff0c;mybatis的分页和特殊字符的使用方式接下来把它们集成起来&#xff0c;是如何的呢&#x1f447;&#x1f447;&#x1…
阅读更多...
深入理解linux内核--系统启动

深入理解linux内核--系统启动

史前时代&#xff1a;BIOS 计算机在加电的那一刻几乎是毫无用处的&#xff0c;因为RAM芯片中包含的是随机数据&#xff0c;此时还没有操作系统在运行。 在开始启动时&#xff0c;有一个特殊的硬件电路在CPU的一个引脚上产生一个RESET逻辑值。 在RESET产生以后&#xff0c;就把…
阅读更多...
pytorch学习（7）——神经网络优化器torch.optim

pytorch学习（7）——神经网络优化器torch.optim

1 optim 优化器 PyTorch神经网络优化器&#xff08;optimizer&#xff09;通过调整神经网络的参数&#xff08;weight和bias&#xff09;来最小化损失函数&#xff08;Loss&#xff09;。 学习链接&#xff1a; https://pytorch.org/docs/stable/optim.html 1.1 优化器基类 使…
阅读更多...
Wlan——无线桥接的基本概念及配置

Wlan——无线桥接的基本概念及配置

目录 WDS无线分布式系统 WDS组网拓扑 中继桥接 一对一桥接 一对多桥接 多跳桥接 锐捷无线桥接的配置 根桥的配置(瘦AP是在AC上配置) 非根桥的配置&#xff08;直接在AP上配置&#xff09; WDS无线分布式系统 WDS指AP之间通过无线链路连接两个或多个独立的局域网&…
阅读更多...
picGo+gitee+typora设置图床

picGo+gitee+typora设置图床

picGogiteetypora设置图床 picGogitee设置图床下载picGo软件安装picGo软件gitee操作在gitee中创建仓库在gitee中配置私人令牌 配置picGo在插件设置中搜索gitee插件并进行下载 TyporapicGo设置Typora 下载Typora进行图像设置 picGogitee设置图床 当我了解picGogitee可以设置图床…
阅读更多...
每日两题 129求根节点到叶节点数字之和 257二叉树的所有路径

每日两题 129求根节点到叶节点数字之和 257二叉树的所有路径

129 题目 给你一个二叉树的根节点 root &#xff0c;树中每个节点都存放有一个 0 到 9 之间的数字。 每条从根节点到叶节点的路径都代表一个数字&#xff1a; 例如&#xff0c;从根节点到叶节点的路径 1 -> 2 -> 3 表示数字 123 。 计算从根节点到叶节点生成的 所有…
阅读更多...
pytestx容器化执行引擎

pytestx容器化执行引擎

系统架构 前端、后端、pytest均以Docker容器运行服务&#xff0c;单独的容器化执行引擎&#xff0c;项目环境隔离&#xff0c;即用即取&#xff0c;用完即齐&#xff0c;简单&#xff0c;高效。 前端容器&#xff1a;页面交互&#xff0c;请求后端&#xff0c;展示HTML报告 后…
阅读更多...
2023-8-25食物链

2023-8-25食物链

题目链接&#xff1a;食物链 #include <iostream>using namespace std;const int N 50010;int n, m; int p[N], d[N];int find(int x) {if(p[x] ! x){int t find(p[x]);d[x] d[p[x]];p[x] t;}return p[x]; }int main() {cin >> n >> m;for(int i 1; i…
阅读更多...
Could not initialize class net.sf.cglib.beans.BeanMap$Generator异常解决

Could not initialize class net.sf.cglib.beans.BeanMap$Generator异常解决

目录 前言 解决方法 复盘分析 前言 使用easyexcel时&#xff0c;研发环境正常, 服务器编译正常, EasyExcel调用方法的时候, 服务器出现Could not initialize class net.sf.cglib.beans.BeanMap$Generator问题。 报错信息 com.alibaba.excel.exception.ExcelAnalysisExc…
阅读更多...
​LeetCode解法汇总2236. 判断根结点是否等于子结点之和

​LeetCode解法汇总2236. 判断根结点是否等于子结点之和

目录链接&#xff1a; 力扣编程题-解法汇总_分享记录-CSDN博客 GitHub同步刷题项目&#xff1a; https://github.com/September26/java-algorithms 原题链接&#xff1a;力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成长平台 描述&#xff1a; 给你一个 …
阅读更多...
帆软报表系统查看数据库密码

帆软报表系统查看数据库密码

有子曰&#xff1a;“礼之用&#xff0c;和为贵。先王之道&#xff0c;斯为美。小大由之。有所不行&#xff0c;知和而和&#xff0c;不以礼节之&#xff0c;亦不可行也。” 查看数据库密码 构造payload&#xff0c;访问漏洞url&#xff1a; /ReportServer?opfr_server&…
阅读更多...
商品搜索网：连接您与各类商品的桥梁

商品搜索网：连接您与各类商品的桥梁

导语&#xff1a;在如今信息爆炸的时代&#xff0c;购物已经不再是传统的实体店购买&#xff0c;而是通过互联网实现的线上购物方式。而要实现高效的线上购物&#xff0c;商品搜索引擎则成为我们的得力助手。作为国内垂直的商品搜索之一&#xff0c;为中国用户提供全面的数码电…
阅读更多...
创建abp vnext项目

创建abp vnext项目

需求&#xff1a; 1.使用net core跨平台的方式支持windows和centos系统&#xff1b; 2.实现前后端分离部署 3.框架默认集成用户登录、权限、redis等模块 4.支持多种数据库的方式 5.前端使用vue&#xff0c;不需要使用框架自带的web 1.框架配置官网地址&#xff1a; https://ab…
阅读更多...
改进YOLO系列：8.添加SimAM注意力机制

改进YOLO系列：8.添加SimAM注意力机制

添加SimAM注意力机制 1. SimAM注意力机制论文２. SimAM注意力机制原理３. SimAM注意力机制的配置３.１common.py配置３.２yolo.py配置３.３yaml文件配置1. SimAM注意力机制论文 论文题目：SimAM: A Simple, Parameter-Free Attention Module for Convolutional Neural Network…
阅读更多...
Kaggle（3）：Predict CO2 Emissions in Rwanda

Kaggle（3）：Predict CO2 Emissions in Rwanda

Kaggle&#xff08;3&#xff09;&#xff1a;Predict CO2 Emissions in Rwanda 1. Introduction 在本次竞赛中&#xff0c;我们的任务是预测非洲 497 个不同地点 2022 年的二氧化碳排放量。 在训练数据中&#xff0c;我们有 2019-2021 年的二氧化碳排放量 本笔记本的内容&am…
阅读更多...
查看IIS管理器网站的日志和简要分析

查看IIS管理器网站的日志和简要分析

一、查看IIS管理器网站的日志 1.1、查看网站的日志 1.2、IIS的4种日志文件格式 《1》 IIS日志文件格式 使用 Microsoft IIS 日志文件格式来记录有关站点的信息。这种格式由 HTTP.sys 进行处理，并且是固定的基于 ASCII 文本的格式，这意味着无法自定义记录的字段。字段由逗号…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023