R语言R包详解——stringr包:字符处理

R语言

R语言R包详解------stringr包:字符处理

一切用法皆以说明书为准,想要了解该包,请多查阅说明书或者查看底层算法。


文章目录

  • R语言
  • 一、安装与加载R包
  • 二、函数简介
  • 三、函数详解
    • [3.1、str_c: 字符串拼接](#3.1、str_c: 字符串拼接)
    • [3.2、str_trim: 去掉字符串的空格和TAB(\t)](#3.2、str_trim: 去掉字符串的空格和TAB(\t))
    • [3.3、str_pad: 以单字符填充字符串的长度](#3.3、str_pad: 以单字符填充字符串的长度)
    • [3.4、str_dup: 复制字符](#3.4、str_dup: 复制字符)
    • [3.5、str_wrap: 控制字符串输出格式](#3.5、str_wrap: 控制字符串输出格式)
    • [3.6、str_sub: 截取字符串](#3.6、str_sub: 截取字符串)
    • [3.7、str_subset: 返回匹配的字符串](#3.7、str_subset: 返回匹配的字符串)
    • [3.8、word: 从文本中提取单词](#3.8、word: 从文本中提取单词)
    • [3.9、str_count: 字符串计数](#3.9、str_count: 字符串计数)
    • [3.10、str_length: 字符串长度](#3.10、str_length: 字符串长度)
    • [3.11、str_sort: 字符串值排序](#3.11、str_sort: 字符串值排序)
    • [3.12、str_order: 字符串索引排序](#3.12、str_order: 字符串索引排序)
    • [3.13、str_split / str_split_fixed: 字符串分割](#3.13、str_split / str_split_fixed: 字符串分割)
    • [3.14、str_detect: 检查匹配字符串的字符](#3.14、str_detect: 检查匹配字符串的字符)
    • [3.15、str_match / str_match_all: 从字符串中提取匹配组](#3.15、str_match / str_match_all: 从字符串中提取匹配组)
    • [3.16、str_replace / str_replace_all: 字符串替换](#3.16、str_replace / str_replace_all: 字符串替换)
    • 3.17、str_replace_na:把NA替换为指定字符串
    • [3.18、str_locate / str_locate_all: 找到匹配的字符串的位置](#3.18、str_locate / str_locate_all: 找到匹配的字符串的位置)
    • [3.19、str_extract / str_extract_all: 从字符串中提取匹配字符](#3.19、str_extract / str_extract_all: 从字符串中提取匹配字符)
    • [3.20、str_conv: 字符编码转换](#3.20、str_conv: 字符编码转换)
    • [3.21、str_to_upper / str_to_lower: 字符串转成大/小写](#3.21、str_to_upper / str_to_lower: 字符串转成大/小写)
    • [3.22、str_to_title: 字符串转成标题](#3.22、str_to_title: 字符串转成标题)
    • 3.23、str_to_sentence:字符转为语句
    • [3.24、str_glue / str_glue_data:提取字符串中的变量](#3.24、str_glue / str_glue_data:提取字符串中的变量)
    • [3.25、str_remove / str_remove_all: 字符删除](#3.25、str_remove / str_remove_all: 字符删除)
  • 四、参数控制函数
    • [4.1、boundary: 定义使用边界](#4.1、boundary: 定义使用边界)
    • [4.2、coll: 使用标准Unicode排序规则比较字符串。](#4.2、coll: 使用标准Unicode排序规则比较字符串。)
    • [4.3、fixed: 比较文字字节](#4.3、fixed: 比较文字字节)
    • 4.4、coll和fixed区别
    • [4.5、regex: 定义正则表达式](#4.5、regex: 定义正则表达式)
  • 五、用于字符处理的其他包

  • stringr是R语言中一个常用的字符串处理包,它提供了一系列函数来处理和操作字符串。
  • 常用的字符串的处理以str_开头来命名,方便更直观理解函数的定义,看名知意。
  • 掌握此包,辅以正则表达式,足以处理大部分字符处理上的问题。

一、安装与加载R包

r 复制代码
install.packages("stringr") # 安装R包
library(stringr) # 加载R包
packageVersion("stringr") # 查看加载的R包版本
help(package = "stringr") # 产看R包的具体信息

二、函数简介

函数 功能
str_c 字符串拼接
str_trim 去掉字符串的空格和TAB(\t)
str_pad 补充字符串的长度
str_dup 复制字符串
str_wrap 控制字符串输出格式
str_sub 截取字符串
str_subset 返回匹配的字符串
word 从文本中提取单词
str_count 字符串计数
str_length 字符串长度
str_sort 字符串值排序
str_order 字符串索引排序,规则同str_sort
str_split 字符串分割
str_split_fixed 字符串分割,同str_split
str_detect 检查匹配字符串的字符
str_match 从字符串中提取匹配组。
str_match_all 从字符串中提取匹配组,同str_match
str_replace 字符串替换
str_replace_all 字符串替换,同str_replace
str_replace_na 把NA替换为指定字符串
str_locate 找到匹配的字符串的位置。
str_locate_all 找到匹配的字符串的位置,同str_locate
str_extract 从字符串中提取匹配字符
str_extract_all 从字符串中提取匹配字符,同str_extract
str_conv 字符编码转换
str_to_upper 字符串转成大写
str_to_lower 字符串转成小写,规则同str_to_upper
str_to_title 字符串转成标题,规则同str_to_upper
str_to_sentence 字符转为语句
str_glue 提取字符串中的变量
str_remove 字符删除
str_remove_all 字符删除,规则同str_remove

三、函数详解

3.1、str_c: 字符串拼接

  • 概述 :用来进行字符串、向量拼接,与R语言自带的pastepaste0函数功能类似。
  • 语法
r 复制代码
str_c(..., sep = "", collapse = NULL)

参数列表:
...: 多参数的输入
sep: 用于字符串拼接,为字符串的分割符。
collapse: 用于向量拼接,为向量字符串的分割符。
  • 示例
r 复制代码
> # 默认无向量分割符拼接
> str_c("a","b")
[1] "ab"

> # 指定向量分隔符
> str_c("a","b",sep = "_")
[1] "a_b"

> # 指定向量折叠符
> str_c(c("a","b","c"),collapse = "_")
[1] "a_b_c"

> # 混合应用
> str_c(c("a","b"),c("c","d"),sep = "/",collapse = "_")
[1] "a/c_b/d"
  • str_cpaste函数的异同点
r 复制代码
> #相同点
> ############
> # 向量拼接字符串,collapse参数的行为一致
> str_c(c("a","b","c"), collapse = "") #collapse 将一个向量的所有元素连接成一个字符串,collapse设置元素间的连接符
[1] "abc"

> paste(c("a","b","c"), collapse = "")
[1] "abc"

> #不同点
> ############
> str_c('a','b') #把多个字符串拼接为一个大的字符串。
[1] "ab"

> paste('a','b') # 多字符串拼接,默认的sep参数行为不一致
[1] "a b"

> #拼接有NA值的字符串向量,对NA的处理行为不一致
> str_c(c("a", NA, "b"), "-d") #若为空,则无法连接
[1] "a-d" NA    "b-d"

> paste(c("a", NA, "b"), "-d") #即使空,也可连接
[1] "a -d"  "NA -d" "b -d" 

> str_c(str_replace_na(c("a", NA, "b")), "-d") #需要进行处理才可连接
[1] "a-d"  "NA-d" "b-d" 
# str_replace_na用于将值NA替换为字符"NA"

3.2、str_trim: 去掉字符串的空格和TAB(\t)

  • 概述:去掉字符串的空格和TAB(\t)
  • 语法
r 复制代码
str_trim(string, side = c("both", "left", "right"))

参数列表:
string: 字符串,字符串向量。
side: 过滤方式,both两边都过滤,left左边过滤,right右边过滤
  • 示例
r 复制代码
> # 删除字符串两侧的空格
> str_trim(" a ",side = "both")
[1] "a"

> # 删除字符串左侧的空格
> str_trim(" a ",side = "left")
[1] "a "

> # 删除字符串右侧的空格
> str_trim(" a ",side = "right")
[1] " a"

3.3、str_pad: 以单字符填充字符串的长度

  • 概述:字符补齐函数str_pad,用于在字符串中添加单个字符,可选择添加的位置。
  • 语法
r 复制代码
str_pad(string, width, side = c("left", "right", "both"), pad = " ", use_width = TRUE)

参数列表:
string: 字符串,字符串向量
width: 字符串填充后的长度(若指定的width长度小于string长度,则无效扩充)
side: 填充方向,both两边都填充,left左边填充,right右边填充
pad: 用于填充的字符(要求单字符)
use_width: 若为False,则返回string(不扩充)
  • 示例
r 复制代码
> # string ≤ width 无效扩充
> str_pad("aaaaa",3)
[1] "aaaaa"

> # string > width 默认为从左侧扩充
> str_pad("aaaaa",10)
[1] "     aaaaa"

> # 更改扩充方式和填充内容,both方式下,非对称时优先补充至右侧
> str_pad("aaaaa",10,side = "both",pad = "*")
[1] "**aaaaa***"

3.4、str_dup: 复制字符

  • 概述:复制字符串
  • 语法
r 复制代码
str_dup(string, times)

参数列表:
string:需要重复处理的字符串
times:指定重复的次数
  • 示例
r 复制代码
> # 字符串复制
> str_dup("a",2)
[1] "aa"

> # 向量复制
> str_dup(c("a","b","c"),1:3)
[1] "a"   "bb"  "ccc"

> # 组合使用
> str_c(c("a","b","c"),str_dup(c(1,2,3),1:3),sep = "_",collapse = "/")
[1] "a_1/b_22/c_333"

3.5、str_wrap: 控制字符串输出格式

  • 概述:用于将长字符串按照指定的宽度进行换行。它可以帮助我们在输出或显示长字符串时,使其更易读和美观。
  • 语法
r 复制代码
str_wrap(string, width = 80, indent = 0, exdent = 0, whitespace_only = TRUE))

参数列表:
string: 字符串,字符串向量。
width: 设置一行所占的宽度。
indent: 段落首行的缩进值(缩进字符不纳入width的考量内)。
exdent: 设置第二行及之后每行缩进(缩进字符不纳入width的考量内)。
whitespace_only: 若为Ture则换行只会发生在空格处,若为False则换行也会发生在非字符(,/-等)处。
  • 示例
r 复制代码
> text <- "This is a-long-string that needs to be wrapped to fit within a specified width."

> # 首行不缩进,后面每行缩进两字符(缩进字符不纳入width的考量内)
> str_wrap(text, width = 14,indent = 0,exdent = 2)
[1] "This is\n  a-long-string\n  that needs\n  to be\n  wrapped to\n  fit within\n  a specified\n  width."

> # 缩进会发生在非字符处
> str_wrap(text, width = 14,indent = 0,exdent = 2,whitespace_only = F)
[1] "This is a-\n  long-\n  string that\n  needs to be\n  wrapped to\n  fit within\n  a specified\n  width."

3.6、str_sub: 截取字符串

  • 概述 :字符过滤函数str_substr_subsetstr_sub函数通过指定开始和结束位置,过滤出字符串的部分字符串。
  • 语法
r 复制代码
str_sub(string, start = 1L, end = -1L)

参数列表:
string: 字符串,字符串向量。
start : 开始位置
end : 结束位置
  • 示例
r 复制代码
> # 字符过滤(正向索引)
> str_sub(string = "banana",start = 1,end = 3)
[1] "ban"

> # 字符过滤(反向索引)
> str_sub(string = "banana",start = -2,end = -1)
[1] "na"

> # 字符过滤,并赋值
> x <- "banana"

> str_sub(string = x,start = 1,end = 1) <- "A"

> print(x)
[1] "Aanana"

> # 分2段截取字符串
> str_sub("banana", c(1, 2), c(3, -2)) 
[1] "ban"  "anan"

3.7、str_subset: 返回匹配的字符串

  • 概述str_subset函数通过匹配模式,过滤出满足模式的字符串。
  • 语法
r 复制代码
str_subset(string, pattern)

参数列表:
string: 字符串,字符串向量。
pattern: 匹配的字符。
  • 示例
r 复制代码
> fruit <- c("apple", "banana", "pear", "pinapple")

> ##返回含字符'ap'的字符串
> str_subset(fruit, "ap") 
[1] "apple"    "pinapple"

> # 运用正则表达式进行详细的字符匹配
> ## 匹配开头
> str_subset(fruit, "^a") 
[1] "apple"

> ## 匹配结尾为a的字符串
> str_subset(fruit, "a$") 
[1] "banana"

> ##返回含'aeiou'任一个字符的单词
> str_subset(fruit, "[aeiou]") 
[1] "apple"    "banana"   "pear"     "pinapple"

> #匹配任意字符,即可以实现丢弃空值
> str_subset(c("a", NA, "b"), ".") 
[1] "a" "b"

3.8、word: 从文本中提取单词

  • 概述 :提取一个完整的字符,不如str_substr_subset来得灵活,一些情况下比起前两者来说更加的便捷。
  • 语法
r 复制代码
word(string, start = 1L, end = start, sep = fixed(" "))

参数列表:
string: 字符串,字符串向量。
start: 开始的单词。
end: 结束的单词。
sep: 分隔符。
  • 示例
r 复制代码
> sentences <- c("I saw a cat, it sat down","Maybe you-were-right")

> #提取第二个单词到最后一个单词
> word(sentences, 2, -1) 
[1] "saw a cat, it sat down" "you-were-right"        

> #整个句子从第一~三个单词到最后一个单词
> word(sentences[1], 1:3, -1) 
[1] "I saw a cat, it sat down" "saw a cat, it sat down"   "a cat, it sat down"      

> # 指定分隔符
> word(sentences, 2, -1, sep = ",") 
[1] " it sat down" NA            

> word(sentences, 2, -1, sep = "-") 
[1] NA           "were-right"

3.9、str_count: 字符串计数

  • 概述:字符串计数,计算字符串中指定字符的个数
  • 语法
r 复制代码
str_count(string, pattern = "")

参数列表:
string: 字符串,字符串向量。
pattern: 匹配的字符。
  • 示例
r 复制代码
> # 单个目标字符计数
> str_count(string = c("sql","json","java"),pattern = "s")
[1] 1 1 0

> # 多个目标字符计数
> str_count(string = c("sql","json","java"),pattern = c("s","j","a"))
[1] 1 1 2

> # 统计字符长度
> str_count(string = c("sql","json","java"))
[1] 3 4 4

3.10、str_length: 字符串长度

  • 概述 :计算字符串长度,阉割版str_count函数
  • 语法
r 复制代码
str_length(string)

参数列表:
string: 字符串,字符串向量。
  • 示例
r 复制代码
> str_length(c("I", "am", "福旺旺", NA))
[1]  1  2  3 NA

3.11、str_sort: 字符串值排序

  • 概述:对字符向量进行排序
  • 语法
r 复制代码
str_sort(x, decreasing = FALSE, na_last = TRUE, locale = "en", numeric = FALSE,...)

参数列表:
x: 字符串,字符串向量
decreasing: 排序方向
na_last: NA值的存放位置,一共3个值,TRUE放到最后,FALSE放到最前,NA过滤处理
locale: 按哪种语言习惯排序,默认为"en" (English)
numeric: 若为Ture,则将数字当作数值型进行排序处理,否则按照字符型排序处理
  • 示例
r 复制代码
> # 字符向量升序排序,返回字符向量
> str_sort(c("sql","json","python",NA))
[1] "json"   "python" "sql"    NA      

> # 字符向量降序排序,返回字符向量,并丢弃掉NA值
> str_sort(c("sql","json","python",NA),decreasing = TRUE, na_last = NA)
[1] "sql"    "python" "json"  

> # 字符向量升序排序,返回字符向量,并将NA值放在第一个
> str_sort(c("sql","json","python",NA),na_last = F)
[1] NA       "json"   "python" "sql"

3.12、str_order: 字符串索引排序

  • 概述:字符串索引排序,规则同str_sort,str_order和str_sort的区别在于前者返回排序后的索引(下标),后者返回排序后的实际值。
  • 语法
r 复制代码
str_order(x, decreasing = FALSE, na_last = TRUE, locale = "en", numeric = FALSE,...)

参数列表:
x: 字符串,字符串向量
decreasing: 排序方向
na_last: NA值的存放位置,一共3个值,TRUE放到最后,FALSE放到最前,NA过滤处理
locale: 按哪种语言习惯排序,默认为"en" (English)
numeric: 若为Ture,则将数字当作数值型进行排序处理,否则按照字符型排序处理
  • 示例
r 复制代码
> # 字符向量升序排序,返回索引向量
> str_order(c("sql","json","python",NA))
[1] 2 3 1 4

> # 字符向量降序排序,返回索引向量,并丢弃掉NA值
> str_order(c("sql","json","python",NA),decreasing = TRUE, na_last = NA)
[1] 1 3 2

> # 字符向量升序排序,返回索引向量,并将NA值放在第一个
> str_order(c("sql","json","python",NA),na_last = F)
[1] 4 2 3 1

3.13、str_split / str_split_fixed: 字符串分割

  • 概述:对字符串进行分割,str_split与str_split_fixed的区别在于前者返回列表格式,后者返回矩阵格式。
  • 语法
r 复制代码
str_split(string, pattern, n = Inf, simplify = FALSE)
str_split_fixed(string, pattern, n)

参数列表:
string: 字符串,字符串向量。
pattern: 匹配的字符。
n: 分割个数  #最后一组就不会被分割
simplify: False 返回列表,Ture 返回矩阵(有了这个参数,那str_split_fixed就属于旧时代的遗物了)
  • 示例
r 复制代码
> # 字符分割,返回列表
> str_split(string = "ba-na-na",pattern = "")
[[1]]
[1] "b" "a" "-" "n" "a" "-" "n" "a"

> # 字符分割3次,返回列表
> str_split(string = "ba-na-na",pattern = "", n = 3)
[[1]]
[1] "b"      "a"      "-na-na"

> # 字符分割,返回矩阵
> str_split(string = "ba-na-na",pattern = "-",simplify = T)
     [,1] [,2] [,3]
[1,] "ba" "na" "na"

> # 字符分割,需要指定分割块数
> str_split_fixed(string = "ba-na-na",pattern = "-", n = Inf)
     [,1] [,2] [,3]
[1,] "ba" "na" "na"

3.14、str_detect: 检查匹配字符串的字符

  • 概述:检查字符串中是否包含指定字符,返回逻辑向量。
  • 语法
r 复制代码
str_detect(string, pattern)

参数列表:
string: 字符串,字符串向量。
pattern: 匹配字符。
  • 示例
r 复制代码
> # 检测字符串中是否包含s
> str_detect(string = c("sql","json","java"),pattern = "s")
[1]  TRUE  TRUE FALSE

> # 检测字符串中是否以s开头
> str_detect(string = c("sql","json","java"),pattern = "^s")
[1]  TRUE FALSE FALSE

3.15、str_match / str_match_all: 从字符串中提取匹配组

  • 概述 :与字符提取函数str_extract 类似,返回匹配到的字符,不同之处在于返回格式。str_matchstr_match_all 的区别在于前者返回矩阵格式,后者返回列表格式。str_match_all 会返回每一个匹配到的值,str_match只会返回第一个匹配成功的字符。
  • 语法
r 复制代码
str_match(string, pattern)
str_match_all(string, pattern)

参数列表:
string: 字符串,字符串向量。
pattern: 匹配字符。
  • 示例
r 复制代码
> val <- c("aabbcc", 123, "1ab") 

> # 从字符串中提取匹配组
> # 匹配字符a,并返回对应的字符
> str_match(val, "a") 
     [,1]
[1,] "a" 
[2,] NA  
[3,] "a" 

> #从字符串中提取匹配组,以字符串matrix格式返回
> str_match_all(val, "a") 
[[1]]
     [,1]
[1,] "a" 
[2,] "a" 

[[2]]
     [,1]

[[3]]
     [,1]
[1,] "a" 


> # 匹配字符0-9,限1个,并返回对应的字符
> str_match(val, "[0-9]") 
     [,1]
[1,] NA  
[2,] "1" 
[3,] "1" 

> # 匹配字符0-9,不限数量,并返回对应的字符
> str_match(val, "[0-9]*") 
     [,1] 
[1,] ""   
[2,] "123"
[3,] "1"  

> # 匹配每一个字符0-9,并返回对应的字符
> str_match_all(val, "[0-9]")
[[1]]
     [,1]

[[2]]
     [,1]
[1,] "1" 
[2,] "2" 
[3,] "3" 

[[3]]
     [,1]
[1,] "1" 

3.16、str_replace / str_replace_all: 字符串替换

  • 概述 :用于替换字符串中的部分字符,str_replacestr_replace_all的区别在于前者只替换一次匹配的对象,而后者可以替换所有匹配的对象
  • 语法
r 复制代码
str_replace(string, pattern, replacement)

参数列表:
string: 字符串,字符串向量。
pattern: 匹配字符。
replacement: 用于替换的字符。
  • 示例
r 复制代码
> #替换第一个匹配的字符# 把目标字符串第一个出现的a或b,替换为-
> str_replace(val, "[ab]", "-") 
[1] "-bc" "123" "c-a"

> #替换所有匹配的字符 # 把目标字符串所有出现的a或b,替换为-
> str_replace_all(val, "[ab]", "-") 
[1] "--c" "123" "c--"

3.17、str_replace_na:把NA替换为指定字符串

  • 概述:把NA替换为指定字符串
  • 语法
r 复制代码
str_replace_na(string, replacement = "NA")

参数列表:
string: 字符串,字符串向量。
replacement : 用于替换的字符。
  • 示例
r 复制代码
> # 把NA值替换为字符串
> str_replace_na(c(NA,'NA',"abc"),'x')
[1] "x"   "NA"  "abc"

3.18、str_locate / str_locate_all: 找到匹配的字符串的位置

  • 概述 :字符位置提取函数str_locatestr_locate_all ,返回匹配到的字符的位置,**str_locate()str_locate_all()**的区别在于前者只匹配第一个匹配的字符,而后者可以匹配所有可能的值
  • 语法
r 复制代码
str_locate(string, pattern)
str_locate_all(string, pattern)

参数列表:
string: 字符串,字符串向量。
pattern: 匹配字符。
  • 示例
r 复制代码
> val <- c("aabbcc","123","bacabc")

> # 用字符匹配
> str_locate(val, "a")
     start end
[1,]     1   1
[2,]    NA  NA
[3,]     2   2

> # 用向量匹配
> str_locate(val, c("a", 12, "b"))
     start end
[1,]     1   1
[2,]     1   2
[3,]     1   1

> # 以字符串matrix格式返回
> str_locate_all(val, "a")
[[1]]
     start end
[1,]     1   1
[2,]     2   2

[[2]]
     start end

[[3]]
     start end
[1,]     2   2
[2,]     4   4


> # 匹配a或b字符,以字符串matrix格式返回
> str_locate_all(val, "[ab]")
[[1]]
     start end
[1,]     1   1
[2,]     2   2
[3,]     3   3
[4,]     4   4

[[2]]
     start end

[[3]]
     start end
[1,]     1   1
[2,]     2   2
[3,]     4   4
[4,]     5   5

3.19、str_extract / str_extract_all: 从字符串中提取匹配字符

  • 概述 :字符提取函数str_extractstr_extract_all ,对字符串进行提取,str_extract_all函数返回所有的匹配结果。
  • 语法
r 复制代码
str_extract(string, pattern, group = NULL)
str_extract_all(string, pattern, simplify = FALSE)

参数列表:
string: 字符串,字符串向量。
pattern: 匹配字符。
group: 如果提供,则不会返回完整的匹配,而是从指定的捕获组返回匹配的文本。
simplify: 返回值,TRUE返回matrix,FALSE返回字符串向量
  • 示例
r 复制代码
> shopping_list <- c("apples x4", "bag of flour", "bag of sugar", "milk x2")

> # 提取所有数字,\转义,\d正则表达式,等价于[0-9]查找所有数字。
> str_extract(shopping_list, "\\d")
[1] "4" NA  NA  "2"

> # 提取小写字母,+匹配前面的子表达式一次或多次。
> str_extract(shopping_list, "[a-z]+")
[1] "apples" "bag"    "bag"    "milk"  

> # 提取小写字母,{1,4}匹配前面的子表达式最少1次,最多4次。
> str_extract(shopping_list, "[a-z]{1,4}")
[1] "appl" "bag"  "bag"  "milk"

> # \b匹配一个单词边界,即字与空格间的位置。若左右两侧皆加上\b则表示取一个位于两个空格之间的完整字符串。
> str_extract(shopping_list, "\\b[a-z]{1,4}\\b")
[1] NA     "bag"  "bag"  "milk"

> # ()标记一个子表达式的开始和结束位置。配合group参数,可以精确的挑出想要的子表达式。
> str_extract(shopping_list, "([a-z]+) of ([a-z]+)")
[1] NA             "bag of flour" "bag of sugar" NA            

> str_extract(shopping_list, "([a-z]+) of ([a-z]+)", group = 1)
[1] NA    "bag" "bag" NA   

> str_extract(shopping_list, "([a-z]+) of ([a-z]+)", group = 2)
[1] NA      "flour" "sugar" NA     

> # 提取所有匹配字符,返回列表的形式。
> str_extract_all(shopping_list, "[a-z]+")
[[1]]
[1] "apples" "x"     

[[2]]
[1] "bag"   "of"    "flour"

[[3]]
[1] "bag"   "of"    "sugar"

[[4]]
[1] "milk" "x"   


> str_extract_all(shopping_list, "\\b[a-z]+\\b")
[[1]]
[1] "apples"

[[2]]
[1] "bag"   "of"    "flour"

[[3]]
[1] "bag"   "of"    "sugar"

[[4]]
[1] "milk"


> str_extract_all(shopping_list, "\\d")
[[1]]
[1] "4"

[[2]]
character(0)

[[3]]
character(0)

[[4]]
[1] "2"


> # Simplify参数,将返回值转化为矩阵形式
> str_extract_all(shopping_list, "\\b[a-z]+\\b", simplify = TRUE)
     [,1]     [,2] [,3]   
[1,] "apples" ""   ""     
[2,] "bag"    "of" "flour"
[3,] "bag"    "of" "sugar"
[4,] "milk"   ""   ""     

> str_extract_all(shopping_list, "\\d", simplify = TRUE)
     [,1]
[1,] "4" 
[2,] ""  
[3,] ""  
[4,] "2" 

> # 将所有的单词提取出来(剔除标点之类的非字符)
> str_extract_all("This is, suprisingly, a sentence.", boundary("word"))
[[1]]
[1] "This"        "is"          "suprisingly" "a"           "sentence"  

3.20、str_conv: 字符编码转换

  • 概述:转换字符的编码方式
  • 语法
r 复制代码
str_conv(string, encoding)

参数列表:
string: 字符串,字符串向量。
encoding: 编码名。
  • 示例
r 复制代码
> x <- rawToChar(as.raw(177))
> x
[1] "\xb1"
> str_conv(x, "ISO-8859-2") # Polish "a with ogonek"
[1] "ą"
> str_conv(x, "ISO-8859-1") # Plus-minus
[1] "±"

3.21、str_to_upper / str_to_lower: 字符串转成大/小写

  • 概述:将字符串转成大/小写
  • 语法
r 复制代码
str_to_upper(string, locale = "en")
str_to_lower(string, locale = "en")

参数列表:
string: 字符串,字符串向量
locale: 按哪种语言习惯排序,默认为"en" (English)
  • 示例
r 复制代码
> val <- "This is a dog. It is so cute."

> # 全大写
> str_to_upper(val)
[1] "THIS IS A DOG. IT IS SO CUTE."

> # 全小写
> str_to_lower(val)
[1] "this is a dog. it is so cute."

3.22、str_to_title: 字符串转成标题

  • 概述:将每个单词的首字母都大写
  • 语法
r 复制代码
str_to_title(string, locale = "en")

参数列表:
string: 字符串,字符串向量
locale: 按哪种语言习惯排序,默认为"en" (English)
  • 示例
r 复制代码
> val <- "This is a dog. It is so cute."

> # 每个单词的首字母都大写
> str_to_title(val)
[1] "This Is A Dog. It Is So Cute."

3.23、str_to_sentence:字符转为语句

  • 概述:只有第一个单词的首字母大写
  • 语法
r 复制代码
str_to_sentence(string, locale = "en")

参数列表:
string: 字符串,字符串向量
locale: 按哪种语言习惯排序,默认为"en" (English)
  • 示例
r 复制代码
> val <- "This is a dog. It is so cute."

> # 只有第一个单词的首字母大写
> str_to_sentence(val)
[1] "This is a dog. It is so cute."

3.24、str_glue / str_glue_data:提取字符串中的变量

  • 概述 :字符串格式化函数str_glue ,用花括号{}表示占位符,括号内的变量被替换成全局变量值。str_gluestr_glue_data 的区别在于参数传递方式和变量引用方式有所不同。如果需要从数据框中获取变量值,可以使用str_glue_data 函数,而如果直接引用变量名,可以使用str_glue 函数。
    • 这两个函数的区别具体如下:
  1. 参数传递方式:str_glue函数使用...参数来传递变量,而str_glue_data函数使用data参数来传递变量。在str_glue_data中,可以通过data参数指定一个数据框(data frame),其中包含了要插入到字符串中的变量。

  2. 变量引用方式:在str_glue函数中,可以直接引用变量名,例如"{var}"。而在str_glue_data函数中,需要使用花括号和句点的组合来引用变量,例如"{.data$var}"。这是因为str_glue_data需要通过data参数指定数据框,所以需要使用句点来引用数据框中的变量。

  3. 环境设置:str_glue函数默认使用当前环境来获取变量值,而str_glue_data函数使用data参数指定的数据框作为环境来获取变量值。这意味着在str_glue_data中,可以直接使用数据框中的变量名,而不需要在变量名前加上数据框的名称。

  • 语法
r 复制代码
str_glue(..., .sep = "", .envir = parent.frame())
str_glue_data(.x, ..., .sep = "", .envir = parent.frame(), .na = "NA")

参数列表:
...:表示要插入到字符串中的变量。可以是一个或多个变量,用逗号分隔。
.sep:表示多个变量之间的分隔符,默认为空格。例如,如果设置为"-",则多个变量之间将用"-"分隔。
.envir:表示要从中获取变量值的环境,默认为当前环境。可以是一个环境对象或一个整数,表示要获取变量值的环境的层数。
.na:表示当变量值为NA时的替代文本,默认为空字符串。例如,如果设置为"NA",则当变量值为NA时,将使用"NA"替代。
  • 示例
r 复制代码
> name <- "Fred"
> age <- 50
> anniversary <- as.Date("1991-10-12")

> # 使用全局变量
> str_glue(
+   "My name is {name}, ",
+   "my age next year is {age + 1}, ",
+   "and my anniversary is {format(anniversary, '%A, %B %d, % ..." ... [TRUNCATED] 
My name is Fred, my age next year is 51, and my anniversary is 星期六, 十月 12, 1991.

> # 双{{}}会失效
> str_glue("My name is {name}, not {{name}}.")
My name is Fred, not {name}.

> # 使用局部变量
> str_glue(
+   "My name is {name}, ",
+   "and my age next year is {age + 1}.",
+   name = "Joe",
+   age = 40
+ )
My name is Joe, and my age next year is 41.

> # 调用数据框
> mtcars %>% str_glue_data("{rownames(.)} has {hp} hp")
Mazda RX4 has 110 hp
Mazda RX4 Wag has 110 hp
Datsun 710 has 93 hp
Hornet 4 Drive has 110 hp
Hornet Sportabout has 175 hp
Valiant has 105 hp
...

3.25、str_remove / str_remove_all: 字符删除

  • 概述 :字符删除函数str_removestr_remove_all,用于删除字符串中的部分字符。
  • 语法
r 复制代码
str_remove(string, pattern)
str_remove_all(string, pattern)

参数列表:
string: 字符串,字符串向量。
pattern: 匹配字符。
  • 示例
r 复制代码
> # 删除第一个匹配到的字符
> str_remove(string = c("abc","123","bac"),pattern = "[ab]")
[1] "bc"  "123" "ac" 

> # 删除所有匹配到的字符
> str_remove_all(string = c("abc","123","bac"),pattern = "[ab]")
[1] "c"   "123" "c" 

四、参数控制函数

  • 概述:参数控制函数,仅用于构造功能的参数,不能独立使用。
  • boundary: 定义使用边界
  • coll: 使用标准Unicode排序规则比较字符串
  • fixed: 比较文字字节
  • regex: 定义正则表达式

4.1、boundary: 定义使用边界

  • 概述:定义使用边界
  • 语法
r 复制代码
boundary(
  type = c("character", "line_break", "sentence", "word"),
  skip_word_none = NA,
  ...
)

参数列表:
type: 要检测的边界类型

character
每一个字符
line_break
换行符
sentence
一句话(以"."结尾,且句子前后有空格分开)
word
单词(前后有空格隔开)

skip_word_none: 忽略不包含任何字符或数字的"单词"一一例如标点符号。默认NA仅在单词边界上拆分时才会跳过此类"单词"。
  • 示例
r 复制代码
> words <- c("These are   some words.")
> str_count(words, boundary("word"))
[1] 4
> str_split(words, " ")[[1]]
[1] "These"  "are"    ""       ""       "some"   "words."
> str_split(words, " ")
[[1]]
[1] "These"  "are"    ""       ""       "some"   "words."

> str_split(words, boundary("word"))[[1]]
[1] "These" "are"   "some"  "words"

4.2、coll: 使用标准Unicode排序规则比较字符串。

  • 概述:使用标准Unicode排序规则比较字符串
  • 语法
r 复制代码
coll(pattern, ignore_case = FALSE, locale = "en", ...)

参数列表:
pattern: 匹配字符
ignore_case: Ture不区分大小写差异,False区分差异
locale: 按哪种语言习惯排序,默认为"en" (English)
  • 示例
r 复制代码
> pattern <- "a.b"
> strings <- c("abb", "a.b")
> str_detect(strings, pattern)
[1] TRUE TRUE
> str_detect(strings, fixed(pattern))
[1] FALSE  TRUE
> str_detect(strings, coll(pattern))
[1] FALSE  TRUE
> 
> # coll() is useful for locale-aware case-insensitive matching
> i <- c("I", "\u0130", "i")
> i
[1] "I" "İ" "i"
> str_detect(i, fixed("i", TRUE))
[1]  TRUE FALSE  TRUE
> str_detect(i, fixed("i", FALSE))
[1] FALSE FALSE  TRUE
> str_detect(i, coll("i", TRUE))
[1]  TRUE FALSE  TRUE
> str_detect(i, coll("i", TRUE, locale = "tr"))
[1] FALSE  TRUE  TRUE

4.3、fixed: 比较文字字节

  • 概述:比较文字字节
  • 语法
r 复制代码
fixed(pattern, ignore_case = FALSE)

参数列表:
pattern: 匹配字符
ignore_case: Ture不区分大小写差异,False区分差异
  • 示例
r 复制代码
> pattern <- "a.b"
> strings <- c("abb", "a.b")
> str_detect(strings, pattern)
[1] TRUE TRUE
> str_detect(strings, fixed(pattern))
[1] FALSE  TRUE
> str_detect(strings, coll(pattern))
[1] FALSE  TRUE
> 
> # coll() is useful for locale-aware case-insensitive matching
> i <- c("I", "\u0130", "i")
> i
[1] "I" "İ" "i"
> str_detect(i, fixed("i", TRUE))
[1]  TRUE FALSE  TRUE
> str_detect(i, fixed("i", FALSE))
[1] FALSE FALSE  TRUE
> str_detect(i, coll("i", TRUE))
[1]  TRUE FALSE  TRUE
> str_detect(i, coll("i", TRUE, locale = "tr"))
[1] FALSE  TRUE  TRUE

4.4、coll和fixed区别

在R语言的stringr包中,coll和fixed函数都是用于进行字符串匹配和替换的函数,但它们有一些区别。

  1. coll函数:coll函数用于进行基于正则表达式的字符串匹配和替换。它使用的是基于Unicode的正则表达式引擎,可以进行更复杂的模式匹配。coll函数可以接受正则表达式作为模式参数,并根据模式进行字符串的匹配和替换。

  2. fixed函数:fixed函数用于进行基于固定字符串的字符串匹配和替换。它不使用正则表达式,而是直接按照给定的固定字符串进行匹配和替换。fixed函数适用于简单的字符串匹配,不需要考虑正则表达式的特殊字符。

总的来说,coll函数适用于复杂的字符串匹配和替换,可以使用正则表达式进行模式匹配。而fixed函数适用于简单的字符串匹配和替换,不需要考虑正则表达式的特殊字符。选择使用哪个函数取决于具体的需求和字符串处理的复杂程度。

4.5、regex: 定义正则表达式

  • 概述:定义正则表达式
  • 语法
r 复制代码
regex(
  pattern,
  ignore_case = FALSE,
  multiline = FALSE,
  comments = FALSE,
  dotall = FALSE,
  ...
)

参数列表:
pattern: 匹配字符
ignore_case: Ture不区分大小写差异,False区分差异
multiline: 如果TRUE,则$和^匹配每一行的开头和结尾。如果为FALSE(默认),则只匹配输入的开始和结束
comments: 如果为TRUE,则忽略空格和以#开头的注释。用\\转义文本空间
dotall: 如果为TRUE,将匹配行终止符(将换行符\n当作是一般字符去识别)。
  • 示例
r 复制代码
> # Regular expression variations
> str_extract_all("The Cat in the Hat", "[a-z]+")
[[1]]
[1] "he"  "at"  "in"  "the" "at" 


> # ignore_case = Ture 忽视大小写
> str_extract_all("The Cat in the Hat", regex("[a-z]+", TRUE))
[[1]]
[1] "The" "Cat" "in"  "the" "Hat"


> # multiline = TRUE 匹配每一行
> str_extract_all("a\nb\nc", "^.")
[[1]]
[1] "a"


> str_extract_all("a\nb\nc", regex("^.", multiline = TRUE))
[[1]]
[1] "a" "b" "c"


> # dotall = TRUE 匹配换行符
> str_extract_all("a\nb\nc", "a.")
[[1]]
character(0)


> str_extract_all("a\nb\nc", regex("a.", dotall = TRUE))
[[1]]
[1] "a\n"

五、用于字符处理的其他包

除了stringr包之外,R语言中还有其他一些常用的用于字符处理的包,包括:

  1. stringi:stringi包是一个功能强大的字符串处理包,提供了大量的函数和方法来处理和操作字符串。它支持多种语言和字符编码,具有较高的性能。

  2. stringdist:stringdist包提供了一系列计算字符串之间距离的函数,例如编辑距离、汉明距离等。它可以用于字符串匹配、聚类和分类等任务。

  3. stringi:stringi包是另一个用于字符串处理的包,它提供了一系列函数来处理和操作字符串,包括字符串匹配、替换、分割、提取等功能。

  4. string:string包提供了一些基本的字符串处理函数,例如字符串匹配、替换、分割等。它是R语言的基础包,无需额外安装。

  5. stringdistroy:stringdistroy包是stringdist包的扩展,提供了更多的字符串距离计算方法,例如Jaro-Winkler距离、Smith-Waterman距离等。

这些包都提供了丰富的函数和方法来处理和操作字符串,具体选择哪个包取决于您的需求和偏好。您可以通过在R中使用install.packages()命令安装这些包,并使用library()命令加载它们。同时,您也可以通过使用?命令在R中获取更详细的帮助信息。

相关推荐
生信摆渡15 小时前
R语言-快速对多个变量取交集
开发语言·数据库·r语言
biomooc16 小时前
R语言/Rstudio 报错
开发语言·r语言
Hello World and You1 天前
R ggplot2 绘图细节 geom_text展示不全 y轴坐标细节 x轴标题
开发语言·r语言
NiNg_1_2343 天前
R语言基础入门详解
开发语言·r语言
rock——you3 天前
R环境依赖的备份与恢复全攻略
开发语言·r语言
biomooc3 天前
R语言 | 宽数据变成一列,保留对应的行名和列名
开发语言·r语言
生信学习小达人3 天前
R package安装的几种方式
开发语言·r语言
卡卡_R-Python4 天前
训练误差or测试误差与特征个数之间的关系--基于R语言实现
开发语言·回归·r语言
亚图跨际5 天前
MATLAB和Python及R瑞利散射
python·matlab·r语言·光学·瑞利散射
不是伍壹5 天前
【R语言】字符类型转换
开发语言·r语言