《R数据科学》第10章-用stringr处理字符串 / 四六文摘

1. 准备工作
2. 字符串基础

2.1 创建字符串或字符向量
2.2 字符串长度：str_length() 函数
2.3 字符串组合：str_c() 函数
2.4 字符串取子集：str_sub() 函数
2.5 区域设置

3. 用正则表达式进行模式匹配：str_view()函数

3.1 基础匹配
3.2 锚点
3.3 字符类与字符选项
3.4 重复
3.5 分组与回溯引用

4. 工具

4.1 匹配检测：str_detect() 函数
4.2 提取匹配内容：str_extract() 函数
4.3 分组匹配：str_match() 函数
4.4 替换匹配内容：str_replace() 函数
4.5 拆分：str_split() 函数
4.6 定位匹配内容：str_locate()

5. 其他类型的模式

5.1 regex() 函数
5.2 fixed() 函数
5.3 coll() 函数
5.4 boundary() 函数

6. 正则表达式的其他应用

6.1 apropos() 函数
6.2 dir() 函数

7. stirngi

1. 准备工作

stringr 不是tidyverse 核心 R 包的一部分，故需要使用命令来加载它。

library(tidyverse) library(stringr)

2. 字符串基础

2.1 创建字符串或字符向量

（1）用单引号或双引号来创建字符串。

单引号和双引号在 R中没有区别。一般用双引号。单引号通常用于分隔包含"的字符向量。

string1 <- "This is a string" #用"创建字符串 string2 <- 'To put a "quote" inside a string, use single quotes' #字符串中含"时，用"来创建字符串

如果要在字符串中包含一个'或"，需要用 \ 对其进行“转义”（也就是说，\在字符串中有特殊含义，即“转义”）：

> writeLines("\'") # writelines() 函数用于查看字符串的初始内容 ' > writeLines('\"') "

如果要在字符串中包含一个反斜杠，需要用两个反斜杠：\。

> writeLines('\\') \

其他特殊字符列表（用 ?'"' 或 ?"'" 命令来查看）

> writeLines("\u00b5") μ

（2）用 c() 函数来创建字符向量（包含多个字符串）

> c("one", "two", "three") [1] "one" "two" "three"

2.2 字符串长度：str_length() 函数

功能：返回字符串中的字符数量：
用法：str_length(string)

> str_length(c("a", "R for data science", NA)) [1] 1 18 NA

2.3 字符串组合：str_c() 函数

（1）str_c() 函数-stringr包中的函数

功能：将多个字符串连接成一个字符串。
用法：str_c(..., sep = "", collapse = NULL)
参数 ... ：字符串列表或字符向量
参数 sep ：分隔符，默认不分隔
参数 collapse ：将字符向量中的字符串合并，并用提供的分隔符分隔

> str_c("x", "y", "z") # 输入为3个字符串"x", "y", "z" [1] "xyz"


> str_c("x", "y", "z", sep = ", ") # 用“逗号+空格”分隔

[1] "x, y, z"

> str_c(c("x", "y", "z"), collapse = ", ") # 输入为1个字符向量c("x", "y", "z") [1] "x, y, z"

长度为 0 的对象会被丢弃，这与 if 结合起来特别有用

name <- "Hadley" time_of_day <- "morning" birthday <- TRUE str_c( "Good ", time_of_day, " ", name, if (birthday) " and HAPPY BIRTHDAY", "." ) [1] "Good morning Hadley and HAPPY BIRTHDAY."

> birthday <- FALSE > str_c( + "Good ", time_of_day, " ", name, + if (birthday) " and HAPPY BIRTHDAY", + "." + ) [1] "Good morning Hadley."

str_c() 函数是向量化的，它可以自动循环短向量，使得其与最长的向量具有相同的长度：

> str_c("prefix-", c("a", "b", "c"), "-suffix") # "prefix-"和 "-suffix"是短向量，c("a", "b", "c")是长向量 [1] "prefix-a-suffix" "prefix-b-suffix" "prefix-c-suffix"

缺失值是可传染的。如果想要将它们输出为 "NA"，可以使用 str_ replace_na()：

> x <- c("abc", NA) # 1个字符向量，包含2个字符串 > str_c("|-", x, "-|") # 组合字符串，没有特殊说明时，缺失值可传染 [1] "|-abc-|" NA > str_c("|-", str_replace_na(x), "-|") # 用 str_replace_na()将缺失值输出为 "NA"， [1] "|-abc-|" "|-NA-|"

（2） paste() 和 paste0() 函数-R语言内置函数

功能：连接字符串
用法：
paste (..., sep = " ", collapse = NULL, recycle0 = FALSE) #可自定义分隔符，默认为空格
paste0(..., collapse = NULL, recycle0 = FALSE) #字符串间紧密连接

> x <- "apple" > y <- "banana" > paste(x,y) [1] "apple banana" > paste0(x,y) [1] "applebanana"

处理NA时与str_c()的区别：str_c()中NA有传染性，paste()将NA返回成字符

> x <- "apple" > z <- NA > paste(x,z) [1] "apple NA" > str_c(x,z) [1] NA

2.4 字符串取子集：str_sub() 函数

功能：提取或修改字符串的一部分。
用法：str_sub(string, start = 1L, end = -1L)
参数start和end：Start给出第一个字符的位置(默认为第一个)，end给出最后一个字符的位置(默认为最后一个字符)。

> x <- c("Apple", "Banana", "Pear") > str_sub(x, 1, 3) [1] "App" "Ban" "Pea"

即使字符串过短， str_sub() 函数也不会出错，它将返回尽可能多的字符：

> str_sub("a", 1, 5) [1] "a"

用 str_sub()替换字符串：通过函数的赋值形式来实现

> str_sub(x, 1, 1) <- str_to_lower(str_sub(x, 1, 1)) # str_to_lower()将文本转化为小写 > x [1] "apple" "banana" "pear"

2.5 区域设置

（1）str_to_upper()，str_to_title()

功能：将文本转化为大写
用法：str_to_upper(string, locale = "en")
参数locale：区域设置，默认为“en”(英语)。区域设置可以参考 ISO 639 语言编码标准，语言编码是 2 或 3 个字母的缩写，见下表，如“tr”(土耳其语)

> str_to_upper(c("i", "ı"), locale = "tr") # 土耳其语中有带点和不带点的两个i，它们在转换为大写时是不同的： [1] "İ" "I" > str_to_upper(c("i", "ı")) #默认区域设置是英语，转化成大写时是一样的 [1] "I" "I"

（2） str_sort() 和 str_order() 函数

功能：排序
参数locale：区域设置

> x <- c("apple", "eggplant", "banana") > str_sort(x, locale = "en") # 英语 [1] "apple" "banana" "eggplant" > str_sort(x, locale = "haw") # 夏威夷语 [1] "apple" "eggplant" "banana" # 用英语和夏威夷与排序时的结果是不一样的

3. 用正则表达式进行模式匹配：str_view() 函数

正则表达式(Regular Expression)

是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。描述了一种字符串匹配的模式（pattern）。通常被用来检索、替换那些符合某个模式(规则)的文本。许多程序设计语言都支持利用正则表达式进行字符串操作。

str_view() 和 str_view_all() 函数

用法：

str_view(string, pattern, match = NA) 显示第一个匹配

str_view_all(string, pattern, match = NA) 显示所有匹配

参数match：为TRUE时只显示匹配项，为FALSE时只显示不匹配项，为NA时显示匹配项和不匹配项（默认）
要显示str_view()匹配的结果，还需要额外安装两个 R 包：htmltools 和 htmlwidgets。
很多 stringr 函数都是成对出现的：一个函数用于单个匹配，另一个函数用于全部匹配，后者会有后缀 _all。

# htmltools包可以用 library() 直接安装 library(htmltools)

# htmlwidgets包直接安装不，可以试着用下面命令安装 BiocManager::install("htmlwidgets") library(htmlwidgets)

str_view()匹配的结果显示在右下角窗格中

3.1 基础匹配

(1) 精确匹配字符串

> x <- c("apple", "banana", "pear") > str_view(x, "an")

（2）用.可以匹配任意字符（除了换行符）（但只能匹配1个字符）：

> str_view(x, ".a.")

（3）如何匹配字符 . 呢？

. 可以匹配任意字符，正则表达式用\来去除某些字符的特殊含义，因此，要匹配.，需要的正则表达式是\.（前面加1个\来去除.匹配任意字符的特殊含义，使其仅用来匹配.）。

\ 在字符串中也用作转义字符(去除某些字符的特殊含义)，因此，正则表达式 \. 的字符串形式应是 \\.

> str_view(c("abc", "a.c", "bef"), "a\\.c")

（4）如何匹配\呢？

要匹配\，需要的正则表达式是\\，对应的字符串形式为"\\\\"

> x <- "a\\b" > writeLines(x) a\b > str_view(x, "\\\\")

3.2 锚点

默认情况下，正则表达式会匹配字符串的任意部分。

需要从字符串的开头或末尾进行匹配时，要设置锚点。

^ 从字符串开头进行匹配。
$ 从字符串末尾进行匹配。

x <- c("apple", "banana", "pear") str_view(x, "^a") # 匹配字符串开头的a str_view(x, "a$") # 匹配字符串末尾的a

x <- c("apple pie", "apple", "apple cake") str_view(x, "apple") #正则表达式默认匹配字符串的任意部分，只要含apple即可，这里3个字符串中的apple都会匹配到 str_view(x, "^apple$") #严格匹配到第2个字符串，不仅含apple，且字符串以a开头以e结尾

\b 匹配单词间的边界

x <- c("The green light in the brown box flickered.","Glue the sheet to the dark blue background.","Hedge apples may stain your hands green." ) # 匹配x中的颜色 colors <- c("red", "orange", "yellow", "green", "blue", "purple") # 创建颜色名称向量 color_match <- str_c(colors, collapse = "|") # 将颜色名称向量转化为正则表达式 str_view_all(x,color_match) # 匹配x中的颜色 # 发现第一个句子中的flickered也被匹配到了，该怎么修改？ color_match2 <- str_c("\\b(",color_match,")\\b") # 在pattern前后加\b（单词边界） str_view_all(x,color_match2)

3.3 字符类与字符选项

很多特殊模式可以匹配多个字符。（虽然可以匹配多个，但是一次只匹配一个，想匹配多次见3.4）

.可以匹配除换行符外的任意字符。
\d 可以匹配任意数字。
\s 可以匹配任意空白字符（如空格、制表符和换行符）
[abc] 可以匹配 a、 b 或 c。
[^abc] 可以匹配除 a、 b、 c 外的任意字符。

注意：要想创建包含 \d 或 \s 的正则表达式，需要在字符串中对 \ 进行转义，因此需要输入 "\\d" 或 "\\s"。

| 的优先级很低（最后才考虑|），所以 abc|xyz 匹配的是 abc 或 xyz，而不是 abcyz 或 abxyz。

如果优先级让人感到困惑，那么可以使用括号让其表达得更清晰一些：如gr(e|a)y匹配的是grey或gray。

3.4 重复

正则表达式的另一项强大功能是，其可以控制一个模式能够匹配多少次。（是将它前面的字符匹配多少次）

?：0 次或 1 次。相当于{0,1}
+：1 次或多次。相当于{1,}
*：0 次或多次。相当于{0,}

x <- "1888 is the longest year in Roman numerals: MDCCCLXXXVIII" str_view(x, "CC?") #"CC?"是将第2个C匹配0次或1次，也就是说匹配的是C或CC。 str_view(x, "CC+") #"CC+"是将第2个C匹配1次或多次，也就是说匹配的是连续2个以上的C str_view(x, 'C[LX]+') #'C[LX]+'是将[LX]匹配1次或多次，[LX]意思是匹配L或X，也就是说只要C后面接的是L或X都可以匹配到，直到不是L或X为止。

注意：这些运算符的优先级非常高（也就是说优先考虑匹配次数），因此很多时候需要使用括号

> x <- c("color","colour","banana","bananana") > str_view(x, "banana+", match = TRUE) #"banana+"是将最后一个a匹配1次或多次，匹配的是banana或bananaaaa..，这里只能匹配到第3个和第4个字符串中的banana > str_view(x, "bana(na)+", match = TRUE) #"bana(na)+"是将最后的na匹配1次或多次，比如banana或bananana，这里第3个和第4个字符串可以全部匹配到

还可以精确设置匹配的次数

{n}：匹配 n 次。
{n,}：匹配 n 次或更多次。
{,m}：最多匹配 m 次。
{n, m}：匹配 n 到 m 次。

> x <- "1888 is the longest year in Roman numerals: MDCCCLXXXVIII" > str_view(x, "C{2}") #"C{2}"是将C匹配2次，即匹配的是CC > str_view(x, "C{2,}") #"C{2,}"是将C匹配2次以上，也就是说可以匹配连续2个以上的C > str_view(x, "C{2,3}") #"C{2,3}"是将C匹配2~3次，也就是说匹配的是CC或CCC

正则表达式默认会匹配尽量长的字符串（默认的匹配方式是“贪婪的”，如果有长的就匹配长的，没长的就匹配略短的）。

在正则表达式后面加一个 ?，可以将匹配方式更改为“懒惰的”，即匹配尽量短的字符串。

> str_view(x, "C{2,3}") #"C{2,3}"匹配方式为贪婪，如果字符串含CCC，那匹配的是CCC而非CC。当然，如果只有2个连续C那匹配的就是CC，如果有4个连续C那匹配的还是前3个C。 > str_view(x, "C{2,3}?") #"C{2,3}?"匹配方式为懒惰，即匹配的是CC。 > str_view(x, 'C[LX]+?') #'C[LX]+?'匹配方式为懒惰，即匹配的是CL或CX。

练习

用语言描述以下正则表达式匹配的是何种模式（仔细阅读来确认我们使用的是正则表达式，还是定义正则表达式的字符串）？ a. ^.*$ #这是正则表达式，.*表示重复0次以上的.，这里^和$表示以任意字符开始，以任意字符结束，故这个匹配的是任意字符。 b. "\\{.+\\}" #这是定义正则表达式的字符串，由于{和}在正则表达式中有特殊含义，所以\\{匹配的是单纯的{，\\}匹配的是}，.+表示重复1次以上的.，.在正则表达式中可匹配任意字符，故这个匹配的是任意花括号里有至少1个字符的字符串，如"{a}"或"{abc}"等 c. \d{4}-\d{2}-\d{2} #这是正则表达式，\d可以匹配任意数字，{4}意思是将任意数字匹配4次，故这个匹配的是4位数字后接一个连字符，然后是两个数字后接一个连字符，然后是另外两个数字。这是一个正则表达式，可以匹配格式为“YYYY-MM-DD”(“%Y-%m-%d”)的日期。如2021-08-16 d. "\\\\{4}" #这是定义正则表达式的字符串，正则表达式的字符串中\\\\匹配的是\，故这个匹配的是\\\\。


找出以 3 个辅音字母开头的单词

str_view(words,"^[^aeiou]{3}",match=TRUE) #这里[^aeiou]可以匹配任意非元音字母（辅音字母），但只能匹配一个字母，{3}是匹配3次辅音字母
找出有连续 3 个或更多元音字母的单词。

str_view(words,"[aeiou]{3}",match=TRUE)

找出有连续 2 个或更多元音—辅音配对的单词 str_view(words,"([aeiou][^aeiou]){2,}",match=TRUE)

3.5 分组与回溯引用

括号的作用：

阐明优先级，用于消除复杂表达式中的歧义。【前部分】
能对正则表达式进行分组，分组可以在匹配时回溯引用（如 \1、 \2 等）【本部分】
提取一个复杂匹配的各个部分【后部分】

回溯引用

回溯引用可以匹配到捕获组曾经匹配过的结果。
回溯引用的标志是反斜杠后加数字
回溯引用中的数字是从左至右计算的。回溯引用中的\1对应第一个圆括号中的内容，\2对应第二个圆括号中的内容。

# 找出名称中有重复的一对字母的所有水果 str_view(fruit, "(..)\\1", match = TRUE) #"(..)\\1"中..表示匹配任意两个字符，\1表示回溯引用第一个()中的内容，由于用字符串表示，所以表示为\\1，故这个匹配的是名称中有重复的一对字母的所有水果

练习

用语言描述以下正则表达式会匹配何种模式？ (.)\1\1 #同一字符重复3次，如"aaa" "(.)(.)\\2\\1" #一对字符镜像出现，如"abba" (..)\1 #任意2个字符重复，如"a1a1" "(.).\\1.\\1" #注意这是定义正则表达式的字符串，表示“一个字符后面跟着任意字符，原始字符，任何其他字符，再重复原始字符”，如"abaca"或"b8b.b"，即一共5个字符，第1、3、5个字符一样，其余随意。 "(.)(.)(.).*\\3\\2\\1" 表示“三个字符，后面跟着0个或多个任意字符，后面跟着三个相同的字符，只是顺序相反”，如“abcsgasgddsadgsdgcba”或“abccba”或“abc1cba”。

4. 工具

基本思想：将一个复杂问题分解为多个简单问题

4.1 匹配检测：str_detect() 函数

（1）str_detect() 函数

功能：确定一个字符向量能否匹配一种模式，判断的是能否匹配，故结果是逻辑向量，即TRUE或FALSE
用法：str_detect(string, pattern, negate = FALSE)，negate为TRUE 则返回不匹配的元素

# 判断x的3个字符串中是否含e > x <- c("apple", "banana", "pear") > str_detect(x, "e") [1] TRUE FALSE TRUE > str_detect(x, "e", negate = TRUE) [1] FALSE TRUE FALSE

从数学意义上来说，逻辑向量中的 FALSE 为 0， TRUE 为 1。这使得在匹配特别大的向量时，sum() 和 mean() 函数能够发挥更大的作用：

# 以t开头的常用单词有多少个？ > sum(str_detect(words, "^t")) # words中共有980个单词，其中以t开头的有65个，也就是说str_detect(words, "^t")的结果中有65个TRUE（数学意义上=1），915个FALSE（数学意义上=0），65个1与915个0的和为65。 [1] 65 # sum(..., na.rm = FALSE)函数中的...可以是数字，也可以是逻辑向量

# 以元音字母结尾的常用单词的比例是多少？ > mean(str_detect(words, "[aeiou]$")) # words中共有980个单词，其中以元音字母结尾的有271个，也就是说str_detect(words, "^t")的结果中有271个TRUE（数学意义上=1），709个FALSE（数学意义上=0），271个1与709个0的均值为0.2765306。 [1] 0.2765306

str_detect() 函数的一种常见用法是选取出匹配某种模式的元素。

# 通过逻辑取子集方式，来选取出匹配某种模式的元素 # [是取子集函数，调用方式为x[i]，逻辑向量取子集方式可提取出TRUE值对应的所有元素（见课本15.4.5向量取子集） > words[str_detect(words, "x$")] #提取出 words 中str_detect(words, "x$")结果为TRUE（以x结尾）的元素 [1] "box" "sex" "six" "tax"

# 或用str_subset() 包装器函数，来来选取出匹配某种模式的元素 > str_subset(words, "x$") [1] "box" "sex" "six" "tax"

如果正则表达式过于复杂，则应该将其分解为几个更小的子表达式，将每个子表达式的匹配结果赋给一个变量，并使用逻辑运算组合起来。

# 找出以 x 开头或结尾的所有单词


# 用str_subset()函数选取匹配某种模式的元素

> str_subset(words,"^x|x$") # words中没有以x开头的单词，以x结尾的单词有4个

[1] "box" "sex" "six" "tax"
# 通过逻辑取子集方式选取匹配某种模式的元素

> words[str_detect(words,"^x|x$")] #选出 words 中结果为TRUE的元素

[1] "box" "sex" "six" "tax"

# 将其分解为2个简单问题，将结果赋值给变量，然后使用逻辑运算组合起来 > start_with_x <- str_detect(words,"^x") > end_with_x <- str_detect(words,"x$") > words[start_with_x|end_with_x] [1] "box" "sex" "six" "tax"

字符串通常会是数据框的一列，此时我们可以使用 filter 操作

> df <- tibble(word = words, i = seq_along(word)) #seq_along()用于生成序列，df是一个数据框（2个向量，一个word，一个序号） > df %>% filter(str_detect(words, "x$")) #筛选出df中word以x结尾的行 # A tibble: 4 x 2 word i <chr> <int> 1 box 108 2 sex 747 3 six 772 4 tax 841

（2）str_count()函数

功能：返回字符串中匹配的数量
用法：str_count(string, pattern = "")

> x <- c("apple", "banana", "pear") > str_count(x, "a") # 返回字符串中a的个数 [1] 1 3 1


> mean(str_count(words, "[aeiou]")) # str_count(words, "[aeiou]")返回words中每个单词中含元音字母的个数，求均值即为“平均来看，每个单词中含元音字母的个数”

[1] 1.991837
# 哪个单词包含最多数量的元音字母？

> vowels <- str_count(words, "[aeiou]")

> words[which(vowels == max(vowels))]

[1] "appropriate" "associate" "available" "colleague" "encourage" "experience"

[7] "individual" "television"

# 哪个单词包含最大比例的元音字母？（提示：分母应该是什么？） > prop_vowels <- str_count(words, "[aeiou]") / str_length(words) > words[which(prop_vowels == max(prop_vowels))] [1] "a"

str_count() 也完全可以同 mutate() 函数一同使用

> df %>% mutate(vowels = str_count(word, "[aeiou]"), consonants = str_count(word, "[^aeiou]")) #在df基础上添加2列vowels和consonants，表示每个单词中含元音字母和辅音字母的个数 # A tibble: 980 x 4 word i vowels consonants <chr> <int> <int> <int> 1 a 1 1 0 2 able 2 2 2 3 about 3 3 2 4 absolute 4 4 4 5 accept 5 2 4 6 account 6 3 4 7 achieve 7 4 3 8 across 8 2 4 9 act 9 1 2 10 active 10 3 3 # ... with 970 more rows

注意：匹配从来不会重叠。

> str_count("abababa", "aba") # "abababa"中，模式 "aba" 会匹配2次，而不是3次 [1] 2

4.2 提取匹配内容：str_extract() 函数

功能：提取匹配的实际文本

# 找出包含一种颜色的所有句子 > colors <- c("red", "orange", "yellow", "green", "blue", "purple") #创建一个颜色名称向量 > color_match <- str_c(colors, collapse = "|") #将颜色名称向量转换成一个正则表达式 > has_color <- str_subset(sentences, color_match) #选取出包含一种颜色的句子 > matches <- str_extract(has_color, color_match) #从选取出的句子中提取出颜色 > head(matches) #显示前6个匹配结果 [1] "blue" "blue" "red" "red" "red" "blue"

str_extract(string, pattern) 只提取第一个匹配
str_extract_all(string, pattern, simplify = FALSE) 可以提取全部匹配。

# 逻辑向量取子集方式一般与比较函数结合起来使用效果更佳，提取出TRUE值对应的所有元素（见课本15.4.5向量取子集） > (more <- sentences[str_count(sentences, color_match) > 1]) [1] "It is hard to erase blue or red ink." [2] "The green light in the brown box flickered." [3] "The sky in the west is tinged with orange red." - # str_extract() 只提取第一个匹配 > str_extract(more, color_match) [1] "blue" "green" "orange"


# str_extract() 可以提取全部匹配，并返回为一个列表

> str_extract_all(more, color_match)

[[1]]

[1] "blue" "red"
[[2]]

[1] "green" "red"

[[3]] [1] "orange" "red"

str_extract_all()的参数 simplify 默认为FALSE，返回字符向量列表；如果为TRUE，则返回一个字符矩阵，其中较短的匹配会扩展到与最长的匹配具有同样的长度：

# simplify = TRUE，返回一个矩阵 > str_extract_all(more, color_match, simplify = TRUE) [,1] [,2] [1,] "blue" "red" [2,] "green" "red" [3,] "orange" "red"

# 较短的匹配会扩展到与最长的匹配具有同样的长度 > x <- c("a", "a b", "a b c") > str_extract_all(x, "[a-z]", simplify = TRUE) [,1] [,2] [,3] [1,] "a" "" "" [2,] "a" "b" "" [3,] "a" "b" "c"

练习

从 Harvard sentences 数据集中提取以下内容。 a. 每个句子的第一个单词。 pattern <- "[A-Za-z][A-Za-z']*" b. 以 ing 结尾的所有单词。 pattern <- "\\b[A-Za-z]+ing\\b" c. 所有复数形式的单词。 pattern <- "\\b[A-Za-z]{3,}s\\b"

4.3 分组匹配：str_match() 函数

功能：可以给出每个独立分组。
用法：
str_match(string, pattern)
str_match_all(string, pattern)
结果：str_match() 返回的不是字符向量，而是一个矩阵，其中一列是完整匹配，后面的列是每个分组的匹配：

# 用括号来提取一个复杂匹配的各个部分 > noun <- "(a|the) ([^ ]+)" > has_noun <- sentences %>% str_subset(noun) %>% head(10)


# str_extract()函数可以给出完整匹配，返回的是字符向量

> has_noun %>% str_extract(noun)

[1] "the smooth" "the sheet" "the depth" "a chicken" "the parked" "the sun" "the huge"

[8] "the ball" "the woman" "a helps"

# str_match()函数则可以给出每个独立分组，返回的是一个矩阵，其中一列是完整匹配，后面的列是每个分组的匹配： > has_noun %>% str_match(noun) [,1] [,2] [,3] [1,] "the smooth" "the" "smooth" [2,] "the sheet" "the" "sheet" [3,] "the depth" "the" "depth" [4,] "a chicken" "a" "chicken" [5,] "the parked" "the" "parked" [6,] "the sun" "the" "sun" [7,] "the huge" "the" "huge" [8,] "the ball" "the" "ball" [9,] "the woman" "the" "woman" [10,] "a helps" "a" "helps"

如果数据是保存在 tibble 中的，那么使用 tidyr::extract() 会更容易。这个函数的工作方式与 str_match() 函数类似，只是要求为每个分组提供一个名称，以作为新列放在 tibble 中：

# tidyr::extract()的第一个参数是数据框，第2个参数是列名，第3个参数是正则表达式，remove = TRUE表示从输出数据帧中移除输入列。 > tibble(sentence = sentences) %>% tidyr::extract(sentence, c("article", "noun"), "(a|the) ([^ ]+)", remove = FALSE ) # A tibble: 720 x 3 sentence article noun <chr> <chr> <chr> 1 The birch canoe slid on the smooth planks. the smooth 2 Glue the sheet to the dark blue background. the sheet 3 It's easy to tell the depth of a well. the depth 4 These days a chicken leg is a rare dish. a chicken 5 Rice is often served in round bowls. NA NA 6 The juice of lemons makes fine punch. NA NA # ... with 714 more rows

4.4 替换匹配内容：str_replace() 函数

功能：用新字符串替换匹配内容
用法：str_replace(string, pattern, replacement) replacement表示替换的字符向量，即把pattern匹配到的内容替换为replacement
用法1：用固定字符串替换匹配内容（replacement为固定字符串）

> x <- c("apple", "pear", "banana") > str_replace(x, "[aeiou]", "-") #将x中的第1个元音字母替换为- [1] "-pple" "p-ar" "b-nana" > str_replace_all(x, "[aeiou]", "-") #将x中的所有元音字母替换为- [1] "-ppl-" "p--r" "b-n-n-"

用法2：通过提供一个命名向量，使用 str_replace_all() 函数可以同时执行多个替换

> x <- c("1 house", "2 cars", "3 people") > str_replace_all(x, c("1" = "one", "2" = "two", "3" = "three")) [1] "one house" "two cars" "three people"

用法3：用回溯引用来插入匹配中的分组

# 交换句子中第二个单词和第三个单词的顺序 > sentences %>% + str_replace("([^ ]+) ([^ ]+) ([^ ]+)", "\\1 \\3 \\2") %>% + head(3) [1] "The canoe birch slid on the smooth planks." "Glue sheet the to the dark blue background." [3] "It's to easy tell the depth of a well."

练习

(1) 使用反斜杠替换字符串中的所有斜杠。 str_replace_all("past/present/future", "/", "\\\\")


(2) 使用 replace_all() 函数实现 str_to_lower() 函数的一个简单版。

replacements <- c("A" = "a", "B" = "b", "C" = "c", "D" = "d", "E" = "e", "F" = "f", "G" = "g", "H" = "h", "I" = "i", "J" = "j", "K" = "k", "L" = "l", "M" = "m", "N" = "n", "O" = "o", "P" = "p", "Q" = "q", "R" = "r", "S" = "s", "T" = "t", "U" = "u", "V" = "v", "W" = "w", "X" = "x", "Y" = "y", "Z" = "z")

lower_words <- str_replace_all(words, pattern = replacements)

head(lower_words)

(3) 交换 words 中单词的首字母和末尾字母，其中哪些字符串仍然是个单词？ swapped <- str_replace_all(words, "^([A-Za-z])(.*)([A-Za-z])$", "\\3\\2\\1") intersect(swapped, words)

4.5 拆分：str_split() 函数

功能：将字符串拆分为多个片段
用法：
str_split(string, pattern, n = Inf, simplify = FALSE)
str_split_fixed(string, pattern, n)
参数simplify：默认为FALSE，返回的是列表；为TRUE时返回矩阵

# 将句子拆分成单词 # simplify默认为FALSE，返回的是列表 > sentences %>% head(3) %> str_split(" ") #在空格处拆开。 [[1]] [1] "The" "birch" "canoe" "slid" "on" "the" "smooth" "planks."


[[2]]

[1] "Glue" "the" "sheet" "to" "the" "dark"

[7] "blue" "background."
[[3]]

[1] "It's" "easy" "to" "tell" "the" "depth" "of" "a" "well."

# simplify为TRUE时返回矩阵 > sentences %>% head(3) %>% str_split(" ", simplify = TRUE) [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [1,] "The" "birch" "canoe" "slid" "on" "the" "smooth" "planks." "" [2,] "Glue" "the" "sheet" "to" "the" "dark" "blue" "background." "" [3,] "It's" "easy" "to" "tell" "the" "depth" "of" "a" "well."

因为字符向量的每个分量会包含不同数量的片段，所以 str_split() 会返回一个列表。如果拆分的是长度为 1 的向量，那么只要简单地提取列表的第一个元素即可，.[[1]]的功能类似于head(1)

> "a|b|c|d" %>% + str_split("\\|") %>% + .[[1]] #[[是取子集函数[的变体，只提取单个元素，并丢弃名称 [1] "a" "b" "c" "d"

参数n：表示拆分的片段数，默认为Inf，即返回所有片段还可以设定拆分片段的最大数量：

> fields <- c("Name: Hadley: baf", "Country: NZ", "Age: 35")

# 拆分成2段，返回为矩阵 > fields %>% str_split(": ", n = 2, simplify = TRUE) [,1] [,2] [1,] "Name" "Hadley: baf" [2,] "Country" "NZ" [3,] "Age" "35"

参数pattern：除了模式，你还可以用boundary()来匹配字符、单词、行和句子的边界，以这些边界来拆分字符串。

> x <- "This is a sentence. This is another sentence." > str_split(x, " ")[[1]] [1] "This" "is" "a" "sentence." "This" "is" "another" "sentence." > str_split(x, boundary("word"))[[1]] [1] "This" "is" "a" "sentence" "This" "is" "another" "sentence"

# 用boundary("word")的拆分效果比" "更灵活，前者结果中只有单词，后者结果中还有.

4.6 定位匹配内容：str_locate()

功能：定位模式在字符串中的位置。可以返回每个匹配的开始位置和结束位置。
用法：
str_locate(string, pattern)
str_locate_all(string, pattern)

> fruit <- c("apple", "banana", "pear", "pineapple") > str_locate(fruit, "a") start end [1,] 1 1 [2,] 2 2 [3,] 3 3 [4,] 5 5

5. 其他类型的模式

以下3个函数是同一类型函数，都使用修饰函数控制匹配行为

5.1 regex() 函数

当使用一个字符串作为模式时， R 会自动调用 regex() 函数对其进行包装。

# 正常调用：当所有参数都为默认设置时，简写为仅字符串（模式） > str_view(fruit, "nana") # 上面形式是以下形式的简写：当需要修改默认参数时，就需要写出regex()函数 > str_view(fruit, regex("nana"))

用法：regex(pattern, ignore_case = FALSE, multiline = FALSE, comments = FALSE, dotall = FALSE, ...)
参数：后面这几个参数的默认设置都是FALSE，也就是说，当它们都是FALSE时即为我们前面所学，regex()也可以简写为仅字符串（模式），只是前面学习时未写出默认参数而已，换言之，如果这些参数为TRUE，那就是不同的意思，可以通过修改参数来控制具体的匹配方式
ignore_case（忽略字母大小写）：默认为FALSE，匹配时字母区分有大小写。当 ignore_case = TRUE 时，忽略字母大小写，既可以匹配大写字母，也可以匹配小写字母，它总是使用当前的区域设置：

> bananas <- c("banana", "Banana", "BANANA") # 默认区分大小写，只能匹配到第1个字符串 > str_view(bananas, "banana") # 不区分大小写，3个字符串都能匹配到 > str_view(bananas, regex("banana", ignore_case = TRUE))

multiline（多行）：默认为FALSE，即没有多行的说法， ^ 和 $ 从完整字符串的开头和末尾开始匹配。当 multiline = TRUE 时，可使 ^ 和 $ 从每行的开头和末尾开始匹配：

> x <- "Line 1\nLine 2\nLine 3" # 默认只能从完整字符串的开头开始匹配，即只能匹配到第1个Line > str_extract_all(x, "^Line")[[1]] [1] "Line" # ^可以从每行的开头开始匹配，即3个Line都能匹配到 > str_extract_all(x, regex("^Line", multiline = TRUE))[[1]] [1] "Line" "Line" "Line"

comments（注释）：如果为TRUE，可以在复杂的正则表达式中加入注释和空白字符，以便更易理解。匹配时会忽略空格和 # 后面的内容。如果想要匹配一个空格，你需要对其进行转义："\\ "：

phone <- regex(" \\(? # 可选的开括号 (\\d{3}) # 地区编码 [)- ]? # 可选的闭括号、短划线或空格 (\\d{3}) # 另外3个数字 [ -]? # 可选的空格或短划线 (\\d{3}) # 另外3个数字 ", comments = TRUE)

> str_match("514-791-8141", phone) [,1] [,2] [,3] [,4] [1,] "514-791-814" "514" "791" "814"

dotall：为 TRUE 时 . 可以匹配包括 \n（换行符）在内的所有字符

5.2 fixed() 函数

功能：可以按照字符串的字节形式进行精确匹配，它会忽略正则表达式中的所有特殊字符，并在非常低的层次上进行操作。这样可以不用进行那些复杂的转义操作，而且速度比普通正则表达式要快很多。
用法：fixed(pattern, ignore_case = FALSE)

microbenchmark::microbenchmark( fixed = str_detect(sentences, fixed("the")), # 用fixed() 函数精确匹配 regex = str_detect(sentences, "the"), # 用regex()函数匹配 times = 20 )

# 可见，用fixed()函数匹配到的结果要比regex()函数匹配到的少 #> Unit: microseconds #> expr min lq mean median uq max neval cld #> fixed 116 117 136 120 125 389 20 a #> regex 333 337 346 338 342 467 20 b

在匹配非英语数据时，要慎用 fixed() 函数。它可能会出现问题，因为此时同一个字符经常有多种表达方式。如，定义 á 的方式有两种：一种是单个字母 a，另一种是 a 加上重音符号：

> a1 <- "\u00e1" > a2 <- "a\u0301" > c(a1, a2) #可见 a1 和 a2 表示的是同一字符 [1] "á" "a" > a1 == a2 #但比较得到的结果是FALSE [1] FALSE

# 这两个字母的意义相同，但因为定义方式不同，所以 fixed() 函数找不到匹配。 > str_detect(a1, fixed(a2)) [1] FALSE

5.3 coll() 函数

功能：使用标准排序规则来比较字符串，这在进行不区分大小写的匹配时是非常有效的。
用法：coll(pattern, ignore_case = FALSE, locale = "en", ...)
参数：可以通过设置 locale 参数（区域设置，默认"en"（英语）），以确定使用哪种规则来比较字符。

> i <- c("I", "İ", "i", "ı") > str_subset(i, coll("i", ignore_case = TRUE)) #不区分大小写，默认用英语匹配，i匹配到的是I和i [1] "I" "i" > str_subset(i, coll("i", ignore_case = TRUE, locale = "tr")) #不区分大小写，区域设置用土耳其语匹配，i匹配到的是İ和i [1] "İ" "i"

fixed() 和 regex() 函数中都有 ignore_case 参数，但都无法选择区域设置，而coll()函数可以选择区域设置
coll()函数的弱点是速度，因为确定哪些是相同字符的规则比较复杂，与 regex() 和 fixed() 函数相比， coll() 确实比较慢。

5.4 boundary() 函数

功能：匹配（字母、行、句子和单词）边界
用法：boundary(type = c("character", "line_break", "sentence", "word"), skip_word_none = NA, ...)
参数：
type：要检测的边界类型，可以选c("character", "line_break", "sentence", "word")，即字母、行、句子和单词，前面例子中用到的是匹配单词边界。

> x <- "This is a sentence." > str_extract_all(x, boundary("word")) [[1]] [1] "This" "is" "a" "sentence"

练习

(1) 如何找出包含 \ 的所有字符串？分别使用 regex() 和 fixed() 函数来完成这个任务。 > str_subset(c("a\\b", "ab"), "\\\\") [1] "a\\b" > str_subset(c("a\\b", "ab"), fixed("\\")) #尽管fixed()函数可以忽略正则表达式中的所有特殊字符，但书写字符串使还是应该注意特殊字符的特殊含义，比如\表示转义。 [1] "a\\b" > writeLines("a\\b") a\b


(2) sentences 数据集中最常见的 5 个单词是什么？
tibble(word = unlist(str_extract_all(sentences, boundary("word")))) %>% # 以单词为边界提取出句子中的所有单词

mutate(word = str_to_lower(word)) %>% # 将单词中的大写转化为小写

count(word, sort = TRUE) %>% # 以单词分组进行计数，并倒序排

head(5) # 选出前5个

# A tibble: 5 x 2 word n <chr> <int> 1 the 751 2 a 202 3 of 132 4 to 123 5 and 118

6. 正则表达式的其他应用

R 基础包中有两个常用函数，它们也可以使用正则表达式。

6.1 apropos() 函数

功能：通过(部分)名称查找对象，可以在全局环境空间中搜索所有可用对象。当不能确切想起函数名称时，这个函数特别有用：
用法：

> apropos("replace") [1] "%+replace%" ".rs.registerReplaceHook" ".rs.replaceBinding" [4] ".rs.rpc.replace_comment_header" "replace" "replace_na" [7] "replacements" "setReplaceMethod" "str_replace" [10] "str_replace_all" "str_replace_na" "theme_replace"

6.2 dir() 函数

功能：可以列出一个目录下的所有文件
用法：
dir() 函数的 patten 参数可以是一个正则表达式，此时它只返回与这个模式相匹配的文件名。

# 返回当前目录中的所有CSV文件 > head(dir(pattern = "\\.csv$")) [1] "diamonds.csv"

7. stirngi

stringr 建立于 stringi 的基础之上。
stringr 非常容易学习，因为它只提供了非常少的函数（只有42个）
与 stringr 不同， stringi 的设计思想是尽量全面，几乎包含了我们可以用到的所有函数（有 234 个函数）。
练习

(1) 找出可以完成以下操作的 stringi 函数。


a. 计算单词的数量。 #用stri_count_words()函数

> stri_count_words(head(sentences))

[1] 8 8 9 9 7 7
b. 找出重复字符串。 #用stri_duplicated()函数

> stri_duplicated(c("the", "brown", "cow", "jumped", "over", "the", "lazy", "fox"))

[1] FALSE FALSE FALSE FALSE FALSE TRUE FALSE FALSE
c. 生成随机文本。

> stri_rand_strings(4, 5) #用stri_rand_strings()生成随机字符串

[1] "BabVd" "ozkiF" "PtBxp" "BRy6A"

> stri_rand_shuffle("The brown fox jumped over the lazy cow.") #用stri_rand_shuffle()打乱顺序

[1] "ojr mty.eTnowveo zo fbwe pulchhxed ar"

(2) 如何控制 stri_sort() 函数用来排序的语言设置？ # 通过区域设置 > string1 <- c("hladny", "chladny") > stri_sort(string1, locale = "pl_PL") [1] "chladny" "hladny" > stri_sort(string1, locale = "sk_SK") [1] "hladny" "chladny"

《R数据科学》第10章-用stringr处理字符串