使用stringr处理字符串

2020-04-20

字数统计: 2.2k字 | 阅读时长: 9分

1 字符串

字符串的打印形式与其本身的内容是不相同的，因为打印形式中会显示出转义字符。如果要查看字符串的初始内容，可以使用writeLines()函数。
字符串长度：str_length()
字符串组合：str_c()，可以用sep参数控制字符串的分隔方式；如果想将字符向量合并为字符串，可以用collapse参数；该函数是向量化的，可以自动循环短向量，使得其与最长的向量具有相同的长度；如果希望输出缺失值为“NA”，可使用str_replace_na()

字符串取子集：str_sub()，包括字符串参数和start、end参数（标识子串的位置）
转换大小写：转小写str_to_lower()，转大写str_to_upper()或str_to_title()
字符串排序：str_sort()和str_order()

> (x <- c("\''", "\\", "a"))
[1] "''" "\\" "a" 
> writeLines(x)
''
\
a
> str_c("x", "y", "z", sep = ',')  #组合两个或更多的字符串
[1] "x,y,z"
> str_c(c("x", "y", "z"), collapse = ", ")  #将字符向量合并为字符串
[1] "x, y, z"
> x <- c("abc", "efg", NA)  
> str_c("|-", str_replace_na(x), "-|")
[1] "|-abc-|" "|-efg-|" "|-NA-|" 

> x <- c("Apple", "Pear","Banana")
> str_sub(x, 1, 1) <- str_to_lower(str_sub(x, 1, 1))
> x
[1] "apple"  "pear"   "banana"
> str_sort(x, locale = "en")
[1] "apple"  "banana" "pear"

2 正则表达式

^：从字符串开头进行匹配
$：从字符串末尾进行匹配
.：匹配任意字符（除了换行符）
\d：匹配任意数字
\s：匹配任意空白字符
[abc]：匹配a、b或c
[^abc]：匹配除abc外的任意字符
?：0次或1次
+：1次或多次
*：0次或多次
{n}：匹配n次
{n，}：匹配n次或更多次
{，m}：最多匹配m次
{n,m}：匹配n到m次

> sub("^a", "", x)
[1] "pple"   "pear"   "banana"
> sub("a$", "", x)
[1] "apple" "pear"  "banan"
> sub("a.c", "", c("abcd", "sdacd"))
[1] "d"     "sdacd"
> sub("[ab]", "", c("abcd", "dcba"))
[1] "bcd" "dca"
> sub("[^ab]", "", c("abcd", "dcba"))
[1] "abd" "cba"
> sub("a*b", "", c("aadcd", "dcaaaba"))
[1] "aadcd" "dca"

转义符号的字符串表达：利用反斜杠\去除某些字符的特殊含义，如匹配.这个符号，正则表达式是\.，该表达式的字符串写作“\\.”；而如果要匹配\这个字符，其正则表达式是\\，该表达式的字符串则写作“\\\\”！

> dot <- "\\."  
> writeLines(dot)    #实际上表达式本身只包含一个\
\.
> sub("a\\.c", "___", c("abc", "gfa.cd", "bef"))   #这个表达式告诉R搜索一个.
[1] "abc"    "gf___d" "bef" 

> writeLines("a\\b")   #查看该字符串的初始内容
a\b
> sub("\\\\", "_", "a\\b")   #匹配该字符串的一个\
[1] "a_b"

3 工具

匹配检测：
str_detect()确定一个字符向量能否匹配一种模式，返回逻辑向量可以计算总数或者平均数
str_subset()通过逻辑取子集
str_count()返回字符串中匹配的数量

> x
[1] "apple"  "pear"   "banana"
> str_detect(x, "e")
[1]  TRUE  TRUE FALSE
> sum(str_detect(words, "^t"))
[1] 65
> str_subset(words, "x$")
[1] "box" "sex" "six" "tax"
> str_count(x, "a")
[1] 1 1 3
> mean(str_count(words, "[aeiou]"))  #平均来看，每个单词中有多少个元音字母？
[1] 1.991837

提取匹配内容：
str_extract()提取匹配到的实际文本，得到第一个匹配。
str_extract_all()得到所有匹配，返回列表，设置simplify = TRUE则会返回一个矩阵。
分组匹配：
str_match()给出每个匹配的独立分组，返回一个矩阵。
str_match_all()返回每个字符串的所有匹配，返回一个列表。
如果数据是保存在tibble 中的，那么使用tidyr::extract()会更容易，这个函数的工作方式与str_match()函数类似，只是要求为每个分组提供一个名称，以作为新列放在tibble中。

> x <- c("a", "a b", "a b c")
> str_extract(x, "[a-z]")
[1] "a" "a" "a"
> str_extract_all(x, "[a-z]", simplify = TRUE)
     [,1] [,2] [,3]
[1,] "a"  ""   ""  
[2,] "a"  "b"  ""  
[3,] "a"  "b"  "c" 

#找出sentences中的名词（定义：跟在a或the后面的所有单词）
> length(sentences)
[1] 720
> nouns <- "(a|the|A|The) ([^ ]+)"    #匹配名词的正则表达式
> has_nouns <- str_subset(sentences, nouns)  #提取出满足该正则表达式的子集
> head(has_nouns)
[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."     
[4] "These days a chicken leg is a rare dish."   
[5] "The juice of lemons makes fine punch."      
[6] "The box was thrown beside the parked truck."
> head(str_extract(has_nouns, nouns))     #提取出匹配得到的名词
[1] "The birch" "the sheet" "the depth" "a chicken" "The juice" "The box"    
> head(str_match(has_nouns, nouns))    #给每个匹配给出独立分组，得到一个矩阵
     [,1]        [,2]  [,3]     
[1,] "The birch" "The" "birch"  
[2,] "the sheet" "the" "sheet"  
[3,] "the depth" "the" "depth"  
[4,] "a chicken" "a"   "chicken"
[5,] "The juice" "The" "juice"  
[6,] "The box"   "The" "box" 
#如果数据是保存在tibble 中的，那么使用tidyr::extract() 会更容易
> tibble(sentence = sentences) %>%
+     tidyr::extract(
+         sentence, c("article", "noun"), nouns,
+         remove = FALSE
+     )
# A tibble: 720 x 3
   sentence                                    article noun   
   <chr>                                       <chr>   <chr>  
 1 The birch canoe slid on the smooth planks.  The     birch  
 2 Glue the sheet to the dark blue background. the     sheet  
 3 It is 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.       The     juice  
 7 The box was thrown beside the parked truck. The     box    
 8 The hogs were fed chopped corn and garbage. The     hogs   
 9 Four hours of steady work faced us.         NA      NA     
10 Large size in stockings is hard to sell.    NA      NA     
# ... with 710 more rows

替换匹配内容：str_replace()和str_replace_all()可以使用新字符串替换匹配内容
拆分：str_split()可以将字符串拆分为多个片段，返回一个列表，设置simplify = TRUE返回一个矩阵。还可以设定拆分片段的最大数量；除了模式，还可以通过字母、行、句子和单词边界（boundary()函数）来拆分字符串。
定位匹配内容：str_locate()和str_locate_all()

> x <- c("apple", "pear", "banana")
> str_replace(x, "[aeiou]", "-")
[1] "-pple"  "p-ar"   "b-nana"
> str_replace_all(x, "[aeiou]", "-")
[1] "-ppl-"  "p--r"   "b-n-n-"
> y <- c("1 house", "2 cars", "3 people")
> str_replace_all(y, c("1" = "one", "2" = "two", "3" = "three"))
[1] "one house"    "two cars"     "three people"

> head(str_split(sentences, " ", n = 8, simplify = TRUE))
     [,1]    [,2]    [,3]    [,4]      [,5]    [,6]    [,7]     [,8]         
[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."    
[4,] "These" "days"  "a"     "chicken" "leg"   "is"    "a"      "rare dish." 
[5,] "Rice"  "is"    "often" "served"  "in"    "round" "bowls." ""           
[6,] "The"   "juice" "of"    "lemons"  "makes" "fine"  "punch." ""   
> x <- "This is a sentence. This is another sentence."
> str_split(x, " ")[[1]]
[1] "This"      "is"        "a"         "sentence." "This"      "is"       
[7] "another"   "sentence."
> str_split(x, boundary("word"))[[1]]
[1] "This"     "is"       "a"        "sentence" "This"     "is"       "another" 
[8] "sentence"
> str_locate(x, " ")
     start end
[1,]     5   5
> str_locate_all(x, " ")
[[1]]
     start end
[1,]     5   5
[2,]     8   8
[3,]    10  10
[4,]    20  20
[5,]    25  25
[6,]    28  28
[7,]    36  36

4 其他类型的模式

4.1 regex()函数

当使用一个字符串作为模式时，R会自动调用regex()函数对其进行包装，调用该函数时，可以通过设置一些参数来控制具体的匹配方式：
ignore_case = TRUE既可以匹配大写字母，也可以匹配小写字母，它总是使用当前的区域设置。
multiline = TRUE可以使得^和$从每行的开头和末尾开始匹配，而不是从完整字符串的开头和末尾开始匹配。
comments = TRUE可以在复杂的正则表达式中加入注释和空白字符，以便更易理解。匹配时会忽略空格和# 后面的内容。
dotall = TRUE可以使得.匹配包括\n 在内的所有字符。

> bananas <- c("banana", "Banana", "BANANA")
> str_replace_all(bananas, regex("b|a|n", ignore_case = TRUE), "*")
[1] "******" "******" "******"

> x <- "Line 1\nLine 2\nLine 3"
> writeLines(x)
Line 1
Line 2
Line 3
> str_extract_all(x, "^Line")[[1]]
[1] "Line"
> str_extract_all(x, regex("^Line", multiline = TRUE))[[1]]
[1] "Line" "Line" "Line"

> 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"

4.2 fixed()和coll()函数

fixed()函数可以按照字符串的字节形式进行精确匹配，它会忽略正则表达式中的所有特殊字符，并在非常低的层次上进行操作。这样可以让你不用进行那些复杂的转义操作，而且速度比普通正则表达式要快很多。但在匹配非英语数据时，要慎用fixed() 函数。它可能会出现问题，因为此时同一个字符经常有多种表达方式。

coll()函数使用标准排序规则来比较字符串，这在进行不区分大小写的匹配时是非常有效的。注意，可以在coll() 函数中设置locale 参数，以确定使用哪种规则来比较字符。其弱点是慢。

本笔记参考书目：Hadley Wickham的《R数据科学》