R----stringr包介绍学习

快来打我* 2022-03-30 06:39 408阅读 0赞

1. stringr介绍

stringr包被定义为一致的、简单易用的字符串工具集。所有的函数和参数定义都具有一致性，比如，用相同的方法进行NA处理和0长度的向量处理。

字符串处理虽然不是R语言中最主要的功能，却也是必不可少的，数据清洗、可视化等的操作都会用到。对于R语言本身的base包提供的字符串基础函数，随着时间的积累，已经变得很多地方不一致，不规范的命名，不标准的参数定义，很难看一眼就上手使用。字符串处理在其他语言中都是非常方便的事情，R语言在这方面确实落后了。stringr包就是为了解决这个问题，让字符串处理变得简单易用，提供友好的字符串操作接口。

stringr的项目主页：[https://cran.r-project.org/web/packages/stringr/index.html][https_cran.r-project.org_web_packages_stringr_index.html]

## 2. stringr的API介绍 ##

stringr包1.0.0版本，一共提供了30个函数，方便我们对字符串处理。**常用的字符串的处理以str\_开头来命名，方便更直观理解函数的定义**。我们可以根据使用习惯对函数进行分类：

**字符串拼接函数**

*  str\_c: 字符串拼接。
 *  str\_join: 字符串拼接，同str\_c。
 *  str\_trim: 去掉字符串的空格和TAB(\\t)
 *  str\_pad: 补充字符串的长度
 *  str\_dup: 复制字符串
 *  str\_wrap: 控制字符串输出格式
 *  str\_sub: 截取字符串
 *  str\_sub<- 截取字符串，并赋值，同str\_sub

**字符串计算函数**

*  str\_count: 字符串计数
 *  str\_length: 字符串长度
 *  str\_sort: 字符串值排序
 *  str\_order: 字符串索引排序，规则同str\_sort

**字符串匹配函数**

*  str\_split: 字符串分割
 *  str\_split\_fixed: 字符串分割，同str\_split
 *  str\_subset: 返回匹配的字符串
 *  word: 从文本中提取单词
 *  str\_detect: 检查匹配字符串的字符
 *  str\_match: 从字符串中提取匹配组。
 *  str\_match\_all: 从字符串中提取匹配组，同str\_match
 *  str\_replace: 字符串替换
 *  str\_replace\_all: 字符串替换，同str\_replace
 *  str\_replace\_na:把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

**参数控制函数**，仅用于构造功能的参数，不能独立使用。

*  boundary: 定义使用边界
 *  coll: 定义字符串标准排序规则。
 *  fixed: 定义用于匹配的字符，包括正则表达式中的转义符
 *  regex: 定义正则表达式

### `stringr`包中的重要函数 ###

<table style="width:591px;"> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>功能说明</th> 
   <th>R Base中对应函数</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>使用正则表达式的函数</td> 
   <td>&nbsp;</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>str_extract()</code></td> 
   <td>提取首个匹配模式的字符</td> 
   <td><code>regmatches()</code></td> 
  </tr> 
  <tr> 
   <td><code>str_extract_all()</code></td> 
   <td>提取所有匹配模式的字符</td> 
   <td><code>regmatches()</code></td> 
  </tr> 
  <tr> 
   <td><code>str_locate()</code></td> 
   <td>返回首个匹配模式的字符的位置</td> 
   <td><code>regexpr()</code></td> 
  </tr> 
  <tr> 
   <td><code>str_locate_all()</code></td> 
   <td>返回所有匹配模式的字符的位置</td> 
   <td><code>gregexpr()</code></td> 
  </tr> 
  <tr> 
   <td><code>str_replace()</code></td> 
   <td>替换首个匹配模式</td> 
   <td><code>sub()</code></td> 
  </tr> 
  <tr> 
   <td><code>str_replace_all()</code></td> 
   <td>替换所有匹配模式</td> 
   <td><code>gsub()</code></td> 
  </tr> 
  <tr> 
   <td><code>str_split()</code></td> 
   <td>按照模式分割字符串</td> 
   <td><code>strsplit()</code></td> 
  </tr> 
  <tr> 
   <td><code>str_split_fixed()</code></td> 
   <td>按照模式将字符串分割成指定个数</td> 
   <td>-</td> 
  </tr> 
  <tr> 
   <td><code>str_detect()</code></td> 
   <td>检测字符是否存在某些指定模式</td> 
   <td><code>grepl()</code></td> 
  </tr> 
  <tr> 
   <td><code>str_count()</code></td> 
   <td>返回指定模式出现的次数</td> 
   <td>-</td> 
  </tr> 
  <tr> 
   <td>其他重要函数</td> 
   <td>&nbsp;</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>str_sub()</code></td> 
   <td>提取指定位置的字符</td> 
   <td><code>regmatches()</code></td> 
  </tr> 
  <tr> 
   <td><code>str_dup()</code></td> 
   <td>丢弃指定位置的字符</td> 
   <td>-</td> 
  </tr> 
  <tr> 
   <td><code>str_length()</code></td> 
   <td>返回字符的长度</td> 
   <td><code>nchar()</code></td> 
  </tr> 
  <tr> 
   <td><code>str_pad()</code></td> 
   <td>填补字符</td> 
   <td>-</td> 
  </tr> 
  <tr> 
   <td><code>str_trim()</code></td> 
   <td>丢弃填充，如去掉字符前后的空格</td> 
   <td>-</td> 
  </tr> 
  <tr> 
   <td><code>str_c()</code></td> 
   <td>连接字符</td> 
   <td><code>paste(),paste0()</code></td> 
  </tr> 
 </tbody> 
</table>

**3.1 字符串拼接函数**

**3.1.1 str\_c，字符串拼接操作，与str\_join完全相同，与paste()行为不完全一致。**

函数定义：  
str\_c(..., sep = "", collapse = NULL)  
str\_join(..., sep = "", collapse = NULL)  
参数列表：  
…: 多参数的输入  
sep: 把多个字符串拼接为一个大的字符串，用于字符串的分割符。  
collapse: 把多个向量参数拼接为一个大的字符串，用于字符串的分割符。

str\_c(c('a','a1'),c('b','b1'),sep='-')  
str\_c(letters\[1:5\], " is for", "...")   
str\_c('a','b',sep='-')\#sep可设置连接符  
str\_c('a','b',collapse = "-") \# collapse参数，对多个字符串无效  
str\_c(c('a','a1'),c('b','b1'),collapse='-')   
str\_c(head(letters), collapse = "") \#把多个向量参数拼接为一个大的字符串  
str\_c(head(letters), collapse = ", ")  
str\_c(letters\[-26\], " comes before ", letters\[-1\])  
str\_c(letters)  
\#\#\#\#\#\#\#\#\#\#\#\#  
\#对比str\_c()函数和paste()函数之间的不同点。  
\#\#\#\#\#\#\#\#\#\#\#\#  
str\_c('a','b') \#把多个字符串拼接为一个大的字符串。  
paste('a','b') \# 多字符串拼接，默认的sep参数行为不一致  
\# 向量拼接字符串，collapse参数的行为一致  
str\_c(letters, collapse = "") \#collapse 将一个向量的所有元素连接成一个字符串，collapse设置元素间的连接符  
paste(letters, collapse = "")  
\#拼接有NA值的字符串向量，对NA的处理行为不一致  
str\_c(c("a", NA, "b"), "-d") \#若为空，则无法连接  
paste(c("a", NA, "b"), "-d") \#即使空，也可连接  
str\_c(str\_replace\_na(c("a", NA, "b")), "-d") \#即使空，也可连接

![1062315-20161114221954248-1978551204.png][]

![1062315-20161114222128935-1808122621.png][]

**3.1.2 str\_trim:去掉字符串的空格和TAB(\\t)**

函数定义：str\_trim(string, side = c("both", "left", "right"))  
参数列表：  
string: 字符串，字符串向量。  
side: 过滤方式，both两边都过滤，left左边过滤，right右边过滤  
去掉字符串的空格和TAB(\\t)

str\_trim(string, side = c(“both”, “left”, “right”))  
string：需要处理的字符串  
side：指定剔除空格的位置，both表示剔除首尾两端空格，left表示剔除字符串首部空格，right表示剔除字符串末尾空格  
string <- ‘ Why is me? I have worded hardly! ‘  
str\_trim(string, side = ‘left’)  
str\_trim(string, side = ‘right’)  
str\_trim(string, side = ‘both’)

![1062315-20161114222425107-1356769280.png][]

**3.1.3 str\_pad:补充字符串的长度**

函数定义：str\_pad(string, width, side = c("left", "right", "both"), pad = " ")  
参数列表：  
string: 字符串，字符串向量。  
width: 字符串填充后的长度  
side: 填充方向，both两边都填充，left左边填充，right右边填充  
pad: 用于填充的字符

> string<-'ning xiao li'  
> str\_pad(string,10)  
\[1\] "ning xiao li"  
> str\_pad(string,20)  
\[1\] " ning xiao li"  
> str\_pad(string,20,side = 'both',pad = '\*')  
\[1\] "\*\*\*\*ning xiao li\*\*\*\*"  
> string<-'ning xiao li'  
> str\_pad(string,10) \#\#注若指定的长度少于string长度时，将只返回原string  
\[1\] "ning xiao li"  
> str\_pad(string,20) \#\# 从右边补充空格，直到字符串长度为20  
\[1\] " ning xiao li"  
> str\_pad(string,20,side = 'left',pad = '\*') \# \# 从左边补充空格，直到字符串长度为20  
\[1\] "\*\*\*\*\*\*\*\*ning xiao li"  
> str\_pad(string,20,side = 'left',pad = '\*') \# \# 从右边补充空格，直到字符串长度为20  
\[1\] "\*\*\*\*\*\*\*\*ning xiao li"  
> str\_pad(string,20,side = 'both',pad = '\*') \# 从左右两边各补充x字符，直到字符串长度为20  
\[1\] "\*\*\*\*ning xiao li\*\*\*\*"

![1062315-20161114213259795-493609959.png][]

**3.1.4 str\_dup: 复制字符串**

函数定义：str\_dup(string, times)  
参数列表：

string：需要重复处理的字符串

times：指定重复的次数

复制一个字符串向量。  
> val <- c("abca4", 123, "cba2")  
**\# 复制2次**  
**> str\_dup(val, 2)**  
\# 按位置复制  
> str\_dup(val, 1:3)

![1062315-20161114222644638-553346539.png][]

**3.1.5 str\_wrap，控制字符串输出格式**

函数定义：`str_wrap(string, width = 80, indent = 0, exdent = 0)`

参数列表：

*  string: 字符串，字符串向量。
 *  width: 设置一行所占的宽度。
 *  indent: 段落首行的缩进值
 *  exdent: 设置第二行后每行缩进` `

thanks\_path <- file.path(R.home("doc"), "THANKS")   
thanks <- str\_c(readLines(thanks\_path), collapse = "\\n")   
thanks <- word(thanks, 1, 3, fixed("\\n\\n"))   
cat(str\_wrap(thanks), "\\n")   
cat(str\_wrap(thanks, width = 70), "\\n") \# 设置宽度为70个字符  
cat(str\_wrap(thanks, width = 80, indent = 6, indent = 2), "\\n") \# 设置宽度为80字符，首行缩进2字符  
cat(str\_wrap(thanks, width = 80, indent = 6, exdent = 2), "\\n") \# 设置宽度为80字符，非首行缩进2字符

### **3.1.6 str\_sub,截取字符串** ###

函数定义：`str_sub(string, start = 1L, end = -1L)`

参数列表：

*  string: 字符串，字符串向量。
 *  start : 开始位置
 *  end : 结束位置

str\_sub(string, start = 1L, end = -1L) 提取子字符串

str\_sub(string, start = 1L, end = -1L) <- value 替换子字符串

截取字符串。

txt <- "I am a little bird"  
str\_sub(txt, 1, 4) \# 截取1-4的索引位置的字符串  
str\_sub(txt, end=6) \# 截取1-6的索引位置的字符串  
str\_sub(txt, 6) \# 截取6到结束的索引位置的字符串  
str\_sub(txt, c(1, 4), c(6, 8)) \# 分2段截取字符串  
str\_sub(txt, -3) \# 通过负坐标截取字符串  
str\_sub(txt, end = -3)  
x <- "AAABBBCCC" \#对截取的字符串进行赋值。  
str\_sub(x, 1, 1) <- 1; x \#\# 在字符串的1的位置赋值为1  
str\_sub(x, 2, -2) <- "2345"; x \#\# 在字符串从2到-2的位置赋值为2345

![1062315-20161114225437310-1320209603.png][]

**3.2 字符串计算函数**

**3.2.1 str\_count, 字符串计数**

函数定义：`str_count(string, pattern = "")`

参数列表：

*  string: 字符串，字符串向量。
 *  pattern: 匹配的字符。

\# Word boundaries 单词边界

words <- c("These are some words.")

str\_count(words) \#统计语句中单词的个数  
\[1\] 21

str\_count(words, boundary("word"))   
**str\_split(words, " ")\[\[1\]\] \#将语句分割成单个词组，最后一个单词带有标点**  
**str\_split(words, boundary("word"))\[\[1\]\]\#最后一个单词不带有标点**

![1062315-20161114225807826-1690279174.png][]

string<-c('ning xiao li','zhang san','zhao guo nan')  
str\_count(string,'i')

![1062315-20161114214435013-1020630642.png][]

**3.2.2 str\_length,字符串长度**

函数定义：str\_length(string)  
参数列表：  
string: 字符串，字符串向量。  
计算字符串的长度:  
> str\_length(c("I", "am", "宁小丽", NA))  
\[1\] 1 2 3 NA

### str\_length()，字符长度函数，该函数类似于nchar()函数，但前者将NA返回为NA，而nchar则返回2 ###

**3.2.3 str\_sort, 字符串值排序，同str\_order索引排序**

函数定义：  
str\_sort(x, decreasing = FALSE, na\_last = TRUE, locale = "", ...)  
str\_order(x, decreasing = FALSE, na\_last = TRUE, locale = "", ...)

str\_order和str\_sort的区别在于前者返回排序后的索引（下标），后者返回排序后的实际值  
参数列表：  
x: 字符串，字符串向量。  
decreasing: 排序方向。  
na\_last:NA值的存放位置，一共3个值，TRUE放到最后，FALSE放到最前，NA过滤处理  
locale:按哪种语言习惯排序

\#str\_sort, 字符串值排序，同str\_order索引排序  
str\_order(c('wo','love','five','stars','red','flag'),locale = "en")   
str\_sort(c('wo','love','five','stars','red','flag'),locale = "en") \# 按ASCII字母排序  
str\_sort(c('wo','love','five','stars','red','flag'),,decreasing=TRUE) \# 倒序排序  
str\_sort(c('我','爱','五','星','红','旗'),locale = "zh") \# 按拼音排序

![1062315-20161114230413904-70324205.png][]

对NA值的排序处理

#把NA放最后面 > str_sort(c(NA,'1',NA),na_last=TRUE) [1] "1" NA NA #把NA放最前面 > str_sort(c(NA,'1',NA),na_last=FALSE) [1] NA NA "1" #去掉NA值 > str_sort(c(NA,'1',NA),na_last=NA) [1] "1"

**3.3 字符串匹配函数**

**3.3.1 str\_split,字符串分割，同str\_split\_fixed**

函数定义：

str\_split(string, pattern, n = Inf)  
str\_split\_fixed(string, pattern, n)  
参数列表：  
string: 字符串，字符串向量。  
pattern: 匹配的字符。  
n: 分割个数  \#最后一组就不会被分割  
对字符串进行分割。

\#\#\# str\_split与str\_split\_fixed的区别  
\#\#\# 在于前者返回列表格式，后者返回矩阵格式  
val <- "abc,123,234,iuuu"  
s1<-str\_split(val, ","); s1 \# 以,进行分割  
s2<-str\_split(val, ",",2); s2 \# 以,进行分割，保留2块  
class(s1) \# 查看str\_split()函数操作的结果类型list  
s3<-str\_split\_fixed(val, ",",2); s3 \# 用str\_split\_fixed()函数分割，结果类型是matrix  
class(s3)

![1062315-20161114230845263-1116519881.png][]

3.3.2 str_subset:返回的匹配字符串

函数定义：  
str\_subset(string, pattern)  
参数列表：  
string: 字符串，字符串向量。  
pattern: 匹配的字符。

fruit <- c("apple", "banana", "pear", "pinapple")   
str\_subset(fruit, "a") \#\# 全文匹配  
str\_subset(fruit, "ap") \#\#返回含字符'ap'的单词  
str\_subset(fruit, "^a") \#\# 开头匹配  
str\_subset(fruit, "a$") \#\# 结尾匹配  
str\_subset(fruit, "b") \#\#返回含字符'b'的单词  
str\_subset(fruit, "\[aeiou\]") \#\#返回含'aeiou'任一个字符的单词  
str\_subset(c("a", NA, "b"), ".") \#丢弃空值  
\#该函数与word()函数的区别在于前者提取字符串的子串，后者提取的是单词，而且str\_sub也可以其替换的作用。  
string <- 'My name is ABDATA, I’m 27.'  
str\_sub(string, -3,-2) <- 25; string

![1062315-20161114231653607-1441866446.png][]

str\_subset()函数与word()函数的区别在于前者提取字符串的子串，后者提取的是单词,而且str\_sub也可以其替换的作用。

**3.3.3 word, 从文本中提取单词**（适用于英语环境下的使用）

函数定义：`word(string, start = 1L, end = start, sep = fixed(" "))`

参数列表：

*  string: 字符串，字符串向量。
 *  start: 开始位置。
 *  end: 结束位置。
 *  sep: 匹配字符。

sentences <- c("nxl saw a cat", "nxl sat down")  
word(sentences, 1) \#提取第一个单词  
word(sentences, 2) \#提取第二个单词  
word(sentences, -1) \#提取句子的最后一个单词  
word(sentences, 2, -1) \#提取第二个单词到最后一个单词  
word(sentences\[1\], 1:3, -1) \#整个句子从第一个单词递减掉三个单词  
word(sentences\[1\], 1:6, -1) \#整个句子从第一个单词递减掉的单词  
word(sentences\[1\], 1, 1:4) \#从句子的第一个单词递增到第四个单词  
str <- 'abc.def..123.4568.999'   
word(str, 1, sep = fixed('..')) \# 指定分隔符   
word(str, 2, sep = fixed('..'))  
word(str, 3, sep = fixed('..'))  
val<-'111,222,333,444'  
word(val, 1, sep = fixed(',')) \# 以,分割，取第一个位置的字符串   
word(val, 3, sep = fixed(','))

![1062315-20161114224338013-264428302.png][]

**3.3.4 str\_detect匹配字符串的字符－－ 检测函数，用于检测字符串中是否存在某种匹配模式**

函数定义：str\_detect(string, pattern)  
参数列表：  
string: 字符串，字符串向量。  
pattern: 匹配字符。  
> val <- c("abca4", 123, "cba2")  
\# 检查字符串向量，是否包括a  
> str\_detect(val, "a")  
\# 检查字符串向量，是否以a为开头  
> str\_detect(val, "^a")  
\# 检查字符串向量，是否以a为结尾  
> str\_detect(val, "a$")  
![1062315-20161114224847842-1695762064.png][]

**3.3.6 str\_match,从字符串中提取匹配组**

函数定义：  
str\_match(string, pattern)  
str\_match\_all(string, pattern)  
参数列表：  
string: 字符串，字符串向量。  
pattern: 匹配字符。

val <- c("abc", 123, "cba") \# 从字符串中提取匹配组  
str\_match(val, "a") \# 匹配字符a，并返回对应的字符  
str\_match(val, "\[0-9\]") \# 匹配字符0-9，限1个，并返回对应的字符  
str\_match(val, "\[0-9\]\*") \# 匹配字符0-9，不限数量，并返回对应的字符  
str\_match\_all(val, "a") \#从字符串中提取匹配组，以字符串matrix格式返回  
str\_match\_all(val, "\[0-9\]")

![1062315-20161114232145185-390292827.png][]

![1062315-20161114232232076-1217546442.png][]

str\_match()和str\_match\_all()区别在于前者只提取一次满足条件的匹配对象，而后者可以提取所有匹配对象

**3.3.7 str\_replace，字符串替换**

函数定义：str\_replace(string, pattern, replacement)  
参数列表：  
string: 字符串，字符串向量。  
pattern: 匹配字符。  
replacement: 用于替换的字符。

val <- c("abc", 123, "cba")  
str\_replace(val, "\[ab\]", "-") \#替换**第一个**匹配的字符\# 把目标字符串第一个出现的a或b，替换为-  
str\_replace\_all(val, "\[ab\]", "-") \#替换**所有匹配**的字符 \# 把目标字符串所有出现的a或b，替换为-  
str\_replace\_all(val, "\[a\]", "\\1\\1") \# 把目标字符串所有出现的a，替换为被转义的字符

**str\_replace与str\_replace\_all的区别在于前者只替换一次匹配的对象，而后者可以替换所有匹配的对象**

![1062315-20161114232545592-641449497.png][]

**3.3.8 str\_replace\_na把NA替换为NA字符串**

函数定义：`str_replace_na(string, replacement = "NA")`

参数列表：

*  string: 字符串，字符串向量。
 *  replacement : 用于替换的字符。

把NA替换为字符串

> str_replace_na(c(NA,'NA',"abc"),'x') [1] "x" "NA" "abc"

**3.3.9 str\_locate，找到的模式在字符串中的位置。**

str\_locate()和str\_locate\_all()的区别在于前者只匹配首次，而后者可以匹配**所有**可能的值

> str\_locate(val, "a")  
 start end  
\[1,\] 1 1  
\[2,\] NA NA  
\[3,\] 3 3  
**\# 用向量匹配**  
> str\_locate(val, c("a", 12, "b"))  
 start end  
\[1,\] 1 1  
\[2,\] 1 2  
\[3,\] 2 2  
**\# 以字符串matrix格式返回**  
> str\_locate\_all(val, "a")  
\[\[1\]\]  
 start end  
\[1,\] 1 1  
\[2,\] 4 4  
\[\[2\]\]  
 start end  
\[\[3\]\]  
 start end  
\[1,\] 3 3  
\# 匹配a或b字符，以字符串matrix格式返回  
> str\_locate\_all(val, "\[ab\]")  
\[\[1\]\]  
 start end  
\[1,\] 1 1  
\[2,\] 2 2  
\[3,\] 4 4  
\[\[2\]\]  
 start end  
\[\[3\]\]  
 start end  
\[1,\] 2 2  
\[2,\] 3 3

string <- c('nxl123','zhazha234')  
str\_locate(string,'z')  
str\_locate(string,'n')  
str\_locate\_all(string,'n')

![1062315-20161114233010654-27807222.png][]

**3.3.10 str\_extract从字符串中提取匹配模式**

函数定义：  
str\_extract(string, pattern)  
str\_extract\_all(string, pattern, simplify = FALSE)  
参数列表：  
string: 字符串，字符串向量。  
pattern: 匹配字符。  
simplify: 返回值，TRUE返回matrix，FALSE返回字符串向量

**shopping\_list <- c("apples 4x4", "bag of flour", "bag of sugar", "milk x2")**   
**str\_extract(shopping\_list, "\\\\d") \# 提取数字 \#提取匹配模式的第一个字符串**  
**str\_extract(shopping\_list, "\[a-z\]+") \#提取字母**  
str\_extract\_all(shopping\_list, "\[a-z\]+") \# 提取所有匹配模式的字母，结果返回一个列表  
str\_extract\_all(shopping\_list, "\\\\d") \# 提取所有匹配模式的数字  
\# 提取所有匹配模式的字符串，结果返回一个矩阵，通过simplify = TRUE设置  
str\_extract\_all(shopping\_list, "\\\\b\[a-z\]+\\\\b", simplify = TRUE)   
str\_extract\_all(shopping\_list, "\\\\d", simplify = TRUE)

![1062315-20161114233917185-1351631581.png][]

![1062315-20161114233959748-674012210.png][]

*str\_extract(string, pattern) 提取匹配的第一个字符串*

str\_extract\_all(string, pattern, simplify = FALSE) 提取匹配的所有字符串

功能与str\_match(),str\_match\_all()函数类似

3.4 字符串变换函数

**3.4.1 str\_conv:字符编码转换**

函数定义：*`str_conv(string, encoding)`*

参数列表：

*  string: 字符串，字符串向量。
 *  encoding: 编码名。

对中文进行转码处理。

# 把中文字符字节化 > x <- charToRaw('你好');x [1] c4 e3 ba c3 # 默认win系统字符集为GBK，GB2312为GBK字集，转码正常 > str_conv(x, "GBK") [1] "你好" > str_conv(x, "GB2312") [1] "你好" # 转UTF-8失败 > str_conv(x, "UTF-8") [1] "���" Warning messages: 1: In stri_conv(string, encoding, "UTF-8") : input data \xffffffc4 in current source encoding could not be converted to Unicode 2: In stri_conv(string, encoding, "UTF-8") : input data \xffffffe3\xffffffba in current source encoding could not be converted to Unicode 3: In stri_conv(string, encoding, "UTF-8") : input data \xffffffc3 in current source encoding could not be converted to Unicode

**把unicode转UTF-8**

> x1 <- "\u5317\u4eac" > str_conv(x1, "UTF-8") [1] "北京"

**3.4.2 str\_to\_upper,字符串大写转换。**

函数定义：

str_to_upper(string, locale = "") str_to_lower(string, locale = "") str_to_title(string, locale = "")

参数列表：

*  string: 字符串。
 *  locale:按哪种语言习惯排序

字符串大写转换:

> val <- "I am conan. Welcome to my blog! http://fens.me" # 全大写 > str_to_upper(val) [1] "I AM CONAN. WELCOME TO MY BLOG! HTTP://FENS.ME" # 全小写 > str_to_lower(val) [1] "i am conan. welcome to my blog! http://fens.me" # 首字母大写 > str_to_title(val) [1] "I Am Conan. Welcome To My Blog! Http://Fens.Me"

字符串在平常的数据处理中经常用过，需要对字符串进行分割、连接、转换等操作，本篇中通过介绍stringr，灵活的字符串处理库，可以有效地提高代码的编写效率。有了好的工具，在用R语言处理字符串就顺手了。

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

常用功能：  
\# 合并字符串  
fruit <- c("apple10", "banana"," ", "pe1ar", "pina22222pple","NA")  
res <- str\_c(1:4,fruit,sep=' ',collapse=' ')  
str\_c('I want to buy ',res,collapse=' ')  
\# 计算字符串长度  
str\_length(c("i", "like", "programming R", 123,res))  
\# 按位置取子字符串  
str\_sub(fruit, 1, 3)  
\# 子字符串重新赋值  
capital <-toupper(str\_sub(fruit,1,1))  
str\_sub(fruit, rep(1,4),rep(1,4)) <- capital   
\# 重复字符串  
str\_dup(fruit, c(1,2,3,4))  
\# 加空白  
str\_pad(fruit, 10, "both")  
\# 去除空白  
str\_trim(fruit)  
\# 根据正则表达式检验是否匹配  
str\_detect(fruit, "a$")  
str\_detect(fruit, "\[aeiou\]")   
\# 找出匹配的字符串位置(字符定位函数，返回匹配对象的首末位置)  
str\_locate(fruit, "a")  
\# 提取匹配的部分  
str\_extract(fruit, "\[a-z\]+")  
str\_match(fruit, "\[a-z\]+")  
\# 替换匹配的部分  
str\_replace(fruit, "\[aeiou\]", "-")   
\# 分割  
str\_split(res, " ")  
**str\_extract(fruit, "\\\\d") \# 提取数字**   
**str\_extract(fruit, "\[a-z\]+") \#提取字母  **

**注：R语言中正则表达式的不同之处是转义符号是“\\\\”，其他方面和通常的“正则表达式”是一样的**

正则表达式定义  
转义字符  
\\o NUL字符（\\u0000）  
\\t 制表符（\\0009）  
\\n 换行符（\\000A）  
\\v 垂直制表符（\\u000B）  
\\f 换页符（\\000C）  
\\r 回车符（\\000D）  
\\xnn 十六进制拉丁字符  
\\uxxxx十六进制unicode字符  
\\cX 控制字符  
这些转义字符中比较常用的就是换行符了，其他记不住可以上网查。还有一些字符具有特殊含义，如果需要匹配这些字符的时候需要在前面加上反斜杠进行转义。  
^ $ . \* + ? = ! : | \\ / ( ) \[ \] \{ \}  
字符类  
\[...\] 方括号内任意字符  
\[^...\] 不在方括号内任意字符  
. 除换行符和其他unicode行终止符之外的任意字符  
\\w 等价于\[a-zA-Z0-9\]  
\\W 等价于\[^a-zA-Z0-9\]  
\\s 任何unicode空白符  
\\S 任何非unicode空白符  
\\d 等价于\[0-9\]  
\\D 等价于\[^0-9\]  
\[\\b\] 退格  
这个字符类很重要，需要记忆。  
描述方式：重复  
知识点  
\{n,m\} 匹配前一项至少n次，不超过m次  
\{n,\} 匹配前一项至少n次  
\{n\} 匹配前一项n次  
? 等价于\{0,1\}  
\+ 等价于\{1,\}  
\* 等价于\{0,\}  
x? 描述符后跟随一个"?"表示非贪婪匹配：从字符串中第一个可能匹配的位置，尽量少的匹配。如“??”、“\{1,5\}?”等。

描述方式：选择、分组和引用  
“|”与逻辑表达式中的或类似，前后两者任意一个匹配，很好理解。而圆括号用来分组和引用，功能就比较复杂了。  
把单独的项组合成子表达式，以便重复、选择等操作。  
完整的模式中定义子模式，从而在匹配成功后从目标串中抽出和圆括号中的子模式匹配的部分。  
同一个正则表达式中后部引用前部的正则表达式，注意因为子表达式可以嵌套，所以它的位置是参与计数的左括号的位置。如果不创建带数字编码的引用，可以用"(?"和")"表示。  
举个简单的例子，如果要匹配单引号或双引号中的字符，可能会写成下面这样：  
/\['"\]\[^'"\]\*\['"\]/  
但是如果我们是想成对的匹配'abc'而不是匹配'abc"的话需要这么改写：  
/(\['"\])\[^'"\]\*\\1/  
锚  
指定匹配位置的元素称为锚。  
^ 匹配字符串开头，多行匹配一行的开头  
$ 匹配字符串结尾，多行匹配一行的结尾  
\\b 匹配一个单词的边界，位于\\w和\\W之间的位置  
\\B 匹配非单词边界  
(?=p) 要求接下来的字符都与p匹配，但不能包括匹配p的那些字符  
(?!p) 要求接下来的字符不与p匹配

修饰符  
i。忽略大小写  
m。多行匹配模式  
g。全局匹配  
字符串中的模式匹配  
search  
查找匹配的字符串，不支持全局匹配，返回第一个子串的起始位置。  
"JavaScript".search(/script/i) //4  
match  
返回由匹配结果组成的数组，默认返回第一个匹配的字符串，如果全局匹配则返回所有匹配字符串。当使用括号分组的时候第一个元素为匹配的字符串，其后为圆括号中各个匹配的子字符串。

split  
这是将字符串转化为数组的方法。一般用字符串做分隔符匹配，如果使用正则表达式，则在匹配字符串的前后方断开。同时注意以下几点：  
匹配到开头内容，返回数组第一个元素为空字符串。  
匹配到结尾内容，返回数组最后一个元素为空字符串。  
未匹配，返回数组只包含未切分的字符串。  
replace  
$n 匹配第n个匹配正则表达式中的圆括号子表达式文本  
$& 匹配正则表达式的子串  
$\` 匹配子串左边的文本  
$' 匹配子串右边的文本  
$$ 匹配美元符号

RegExp对象  
属性  
source 正则表达式文本  
global 只读布尔值，是否有修饰符g  
ignoreCase 只读布尔值，是否有修饰符i  
multiline 只读布尔值，是否有修饰符m  
lastIndex 下一次检索开始的位置，用于exec()和test()  
方法  
exec()  
类似String.match，不过不能使用全局匹配。匹配同时修改lastIndex值为紧挨着匹配子串的字符位置，如果未匹配则为0。  
test()  
返回布尔值，可以修改lastIndex从指定位置开始匹配。

### `stringr`包中的重要函数 ###

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>功能说明</th> 
   <th>R Base中对应函数</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>使用正则表达式的函数</td> 
   <td>&nbsp;</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>str_extract()</code></td> 
   <td>提取首个匹配模式的字符</td> 
   <td><code>regmatches()</code></td> 
  </tr> 
  <tr> 
   <td><code>str_extract_all()</code></td> 
   <td>提取所有匹配模式的字符</td> 
   <td><code>regmatches()</code></td> 
  </tr> 
  <tr> 
   <td><code>str_locate()</code></td> 
   <td>返回首个匹配模式的字符的位置</td> 
   <td><code>regexpr()</code></td> 
  </tr> 
  <tr> 
   <td><code>str_locate_all()</code></td> 
   <td>返回所有匹配模式的字符的位置</td> 
   <td><code>gregexpr()</code></td> 
  </tr> 
  <tr> 
   <td><code>str_replace()</code></td> 
   <td>替换首个匹配模式</td> 
   <td><code>sub()</code></td> 
  </tr> 
  <tr> 
   <td><code>str_replace_all()</code></td> 
   <td>替换所有匹配模式</td> 
   <td><code>gsub()</code></td> 
  </tr> 
  <tr> 
   <td><code>str_split()</code></td> 
   <td>按照模式分割字符串</td> 
   <td><code>strsplit()</code></td> 
  </tr> 
  <tr> 
   <td><code>str_split_fixed()</code></td> 
   <td>按照模式将字符串分割成指定个数</td> 
   <td>-</td> 
  </tr> 
  <tr> 
   <td><code>str_detect()</code></td> 
   <td>检测字符是否存在某些指定模式</td> 
   <td><code>grepl()</code></td> 
  </tr> 
  <tr> 
   <td><code>str_count()</code></td> 
   <td>返回指定模式出现的次数</td> 
   <td>-</td> 
  </tr> 
  <tr> 
   <td>其他重要函数</td> 
   <td>&nbsp;</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>str_sub()</code></td> 
   <td>提取指定位置的字符</td> 
   <td><code>regmatches()</code></td> 
  </tr> 
  <tr> 
   <td><code>str_dup()</code></td> 
   <td>丢弃指定位置的字符</td> 
   <td>-</td> 
  </tr> 
  <tr> 
   <td><code>str_length()</code></td> 
   <td>返回字符的长度</td> 
   <td><code>nchar()</code></td> 
  </tr> 
  <tr> 
   <td><code>str_pad()</code></td> 
   <td>填补字符</td> 
   <td>-</td> 
  </tr> 
  <tr> 
   <td><code>str_trim()</code></td> 
   <td>丢弃填充，如去掉字符前后的空格</td> 
   <td>-</td> 
  </tr> 
  <tr> 
   <td><code>str_c()</code></td> 
   <td>连接字符</td> 
   <td><code>paste(),paste0()</code></td> 
  </tr> 
 </tbody> 
</table>

[https_cran.r-project.org_web_packages_stringr_index.html]: https://cran.r-project.org/web/packages/stringr/index.html
[1062315-20161114221954248-1978551204.png]: /images/20220330/0a93f846795f43d9b8500b3cca600ed3.png
[1062315-20161114222128935-1808122621.png]: /images/20220330/27701b36193143888590e72d105e4843.png
[1062315-20161114222425107-1356769280.png]: /images/20220330/21ae7724b672491b9b8b9653ce543854.png
[1062315-20161114213259795-493609959.png]: /images/20220330/7b69bea0383548e0973ad4cfa2691ab4.png
[1062315-20161114222644638-553346539.png]: /images/20220330/72b4b6ef79c94fa0944c05864008f33e.png
[1062315-20161114225437310-1320209603.png]: /images/20220330/08a56a279be3473a92317f8a50605805.png
[1062315-20161114225807826-1690279174.png]: /images/20220330/662b769426814cb4b49554ecafa4faf9.png
[1062315-20161114214435013-1020630642.png]: /images/20220330/724793703a344f8cb4774c93a365e831.png
[1062315-20161114230413904-70324205.png]: /images/20220330/fcdbc3fdd3e14e60979c8cbb291b3115.png
[1062315-20161114230845263-1116519881.png]: /images/20220330/d0edd20683fe4d11b5167be067d5b2f8.png
[1062315-20161114231653607-1441866446.png]: /images/20220330/f3fb6d835afe4de4a31d47192c5794b6.png
[1062315-20161114224338013-264428302.png]: /images/20220330/8953c00589234a6785eceae11680e668.png
[1062315-20161114224847842-1695762064.png]: /images/20220330/bed40dbb55fa43b1bf1e382ec6e80fd4.png
[1062315-20161114232145185-390292827.png]: /images/20220330/a47b826a842a4ceb8ad1be965bf323a7.png
[1062315-20161114232232076-1217546442.png]: /images/20220330/f5bdbf8b0f7647f789cf812d7ed5fcc6.png
[1062315-20161114232545592-641449497.png]: /images/20220330/6ed05a64aeaf45b6bbcb5e7e0f117019.png
[1062315-20161114233010654-27807222.png]: /images/20220330/2c24b4fa3eb34e2f9cb20375e90593f9.png
[1062315-20161114233917185-1351631581.png]: /images/20220330/8c36a20d1892481b986b7719214613e7.png
[1062315-20161114233959748-674012210.png]: /images/20220330/1a509222430e47b68f308ae2e4951c9c.png