Jimmy那些事儿

R_字符串处理_stringr

发表 | 更新 | 分类 ， ， | 阅读次数

R_字符串处理_stringr

stringr：对一个单元格内的 [元素] 进行操作，而非把一个单元格看做一个整体来对待。

文本文件的读写

这里的文本文件指的是非表格式的文件，如纯文本文件，html文件


获取文件目录信息

  • file.info()
  • dir() 列出指定目录中所有的文件，可选参数recursive=T可递归列出所有的子目录文件
  • file.exists()：判断文件是否存在
  • getwd() ：获得当前工作目录
  • setwd() ：设置当前工作目录 setwd("C:/data")


读入

  • scan(“file.xxx”, what=double(), seq=””, n=-1, nmax=-1, skip=0, encoding=”utf-8”)

    读取文本文件，默认情况下读取文件中以[空格分割] 所有[浮点数值]

    • 如果文件中包含非数值，可以字符串形式读入 scan("a.txt",what="")
    • 指定分隔符为换行，scan(“a.txt”,what=””,sep=”\n”) 返回以换行分割的字符串向量
    • 如果数据为表格形式：因为有表头，用scan不能读入

what：读入的数据类型；The supported types are [ logical, integer, numeric, complex, character, raw and list. ]

  • character(0)：每个单词作为字符向量的一个元素

sep：分隔符，默认为空格" "

n = -1：显示至最后一行

nmax = -1：读取至最后一行

skip=0：跳过的行数

encoding=”utf-8” / “Latin1”


  • readline() 可以从键盘读取单行数据，如 age<-readline("input the age: ")


  • readLines(“file.xxx”, encoding=”utf-8”) ：每一行当做一个字符串。等价于scan中指定分隔符为换行
    • 用于读取字符型的格式文件；常用于文本文件

encoding = “utf-8” / “Latin1” ; Lattin1是[ISO-8859-1]的别名，有些环境下写作Latin-1。ISO-8859-1编码是单字节编码，向下兼容ASCII


写出


  • cat(x, file=””, sep=””, fill=False, labels=NULL, append=False)：拼接后输出对象，也可以把结果写到指定的文件中

x：R的对象

file：一个连接，或命名的文件打印到一个字符串；默认情况下打印到标准输出连接

sep=” “：每个元素后追加一个字符串的字符向量；默认为空格

append = False 覆盖file内容；若为True，表示附加到file

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
> cat(c("AB", "C"), c("E", "F"), "\n", sep="")
[1] ABCDEF
#----可以把结果写到指定的文件中-----------------#
cat("i = ", 1, "\n", file="c:/work/result.txt")
# 加上一个append=TRUE参数可以不覆盖原文 件而是在文件末尾附加，这很适用于运行中的结果记录。
> cat("hello", "bob", "\b.\n", "Is\'t R", "\t", "Great?\n","!")  # 拼接后进行输出
hello bob.
 Is't R 	 Great?
 !
> paste("hello", "bob", "\b.\n", "Is\'t R", "\t", "Great?\n","!")
[1] "hello bob \b.\n Is't R \t Great?\n !"


  • writeLines


字符串统计

str_length

符串长度

  • str_length(string)


str_count

字符串计数

  • str_count(string, pattern = “”)

string: 字符串，字符串向量。

pattern: 匹配的字符。

  • 若不匹配字符，即等价于 str_length
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
> str_count('aaa444sssddd', "a")
[1] 3
# 对字符串向量中匹配的字符计数
> fruit <- c("apple", "banana", "pear", "pineapple")
> str_count(fruit, "a")
[1] 1 3 1 1
# 对字符串中的'.'字符计数，由于.是正则表达式的匹配符，直接判断计数的结果是不对的。
> str_count(c("a.", ".", ".a.",NA), ".")
[1]  2  1  3 NA
> str_count(c("a.", ".", ".a.",NA), fixed(".")) # 用fixed匹配字符
[1]  1  1  2 NA
> str_count(c("a.", ".", ".a.",NA), "\\.") # 用\\匹配字符
[1]  1  1  2 NA


字符串查询

str_locate - 位置

找到的模式在字符串中的位置

  • str_locate(string, pattern)
  • str_locate_all(string, pattern)
    • 以字符串matrix格式返回
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
> val <- c("abca", 123, "cba")
# 匹配a在字符串中的位置
> 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


str_detect - 逻辑值

匹配字符串的字符，返回逻辑值

  • str_detect(string, pattern)
1
2
3
4
5
6
7
8
9
> val <- c("abca4", 123, "cba2")
# 检查字符串向量，是否包括a
> str_detect(val, "a")
[1]  TRUE FALSE  TRUE
# 检查字符串向量，是否以a为开头
> str_detect(val, "^a")
[1]  TRUE FALSE FALSE


字符串提取

strsub - 截取位置

截取字符串

  • str_sub(string, start = 1L, end = -1L)

string: 字符串，字符串向量。

start : 开始位置 (若只出现一个数字，默认为开始位置)

end : 结束位置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
> txt <- "I am Conan."
# 截取1-6的索引位置的字符串
> str_sub(txt, end=6)
[1] "I am C"
# 截取6到结束的索引位置的字符串
> str_sub(txt, 6)   # 若只出现一个数字，默认为开始位置
[1] "Conan."
# 通过负坐标截取字符串
> str_sub(txt, -3)  # [截取] 最后3个字符
[1] "an."
> str_sub(txt, end = -3)  # [截止] 到最后第三个字符
[1] "I am Cona"
#----对截取的字符串进行赋值-----------------------------------------#
> x <- "AAABBBCCC"
# 在字符串的1的位置赋值为1
> str_sub(x, 1, 1) <- 1; x
[1] "1AABBBCCC"
> str_sub(x, 1, 1) <- 123; x   # [若数量超过截取的位数，则进行填充]
[1] "123AABBBCCC"


str_subset - 提取值

返回的匹配字符串

  • str_subset(string, pattern)

pattern: 匹配的字符

1
2
3
4
5
6
7
8
9
10
11
12
13
> val <- c("abc", 123, "cba")
# 全文匹配
> str_subset(val, "a")
[1] "abc" "cba"
# 开头匹配
> str_subset(val, "^a")
[1] "abc"
# 结尾匹配
> str_subset(val, "a$")
[1] "cba"


str_match - 匹配

从字符串中提取匹配组

  • str_match(string, pattern)
  • str_match_all(string, pattern)
    • 以字符串matrix格式返回
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
> val <- c("abc", 123, "cba")
# 匹配字符a，并返回对应的字符
> str_match(val, "a")
     [,1]
[1,] "a" 
[2,] NA  
[3,] "a" 
# 匹配字符0-9，限1个，并返回对应的字符
> str_match(val, "[0-9]")
     [,1]
[1,] NA  
[2,] "1" 
[3,] NA  
# 匹配字符0-9，不限数量，并返回对应的字符
> str_match(val, "[0-9]*")
     [,1] 
[1,] ""   
[2,] "123"
[3,] ""  
#----以字符串matrix格式返回------------------------------------------#
> str_match_all(val, "a")
[[1]]
     [,1]
[1,] "a" 
[[2]]
     [,1]
[[3]]
     [,1]
[1,] "a"


str_extract - 匹配_Regex

从字符串中根据 [正则表达式] 提取匹配的值

  • str_extract(string, pattern)
  • str_extract_all(string, pattern, simplify = FALSE)

simplify: 返回值，TRUE返回matrix，FALSE返回字符串向量；(默认为False)

1
2
3
4
5
6
7
8
9
> val <- c("abca4", 123, "cba2")
# 返回匹配的数字
> str_extract(val, "\\d")
[1] "4" "1" "2"
# 返回匹配的字符
> str_extract(val, "[a-z]+")
[1] "abca" NA     "cba"



word - 单词

从文本中提取 [单词]

  • word(string, start = 1L, end = start, sep = fixed(“ “))

start: 开始位置。

end: 结束位置。

sep: 匹配字符。 (默认为 空格)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
> val <- c("I am Conan.", "http://fens.me, ok")
# 默认以空格分割，取第一个位置的字符串
> word(val, 1)
[1] "I"               "http://fens.me,"
> word(val, -1)
[1] "Conan." "ok"    
> word(val, 2, -1)
[1] "am Conan." "ok"       
# 以,分割，取第一个位置的字符串 
> val<-'111,222,333,444'
> word(val, 1, sep = fixed(','))
[1] "111"
> word(val, 3, sep = fixed(','))
[1] "333"



字符串替换

str_replace

字符串替换

  • str_replace(string, pattern, replacement)
    • 替换出现的 [第一个]字符
  • str_replcae_all(string, pattern, replacement)
    • 替换出现的 [所有]字符
  • str_repclea_na(string, repalcement= “NA”)
    • 把NA替换为其他字符串

string: 字符串，字符串向量。

pattern: 匹配字符。

replacement: 用于替换的字符。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
> val <- c("abc", 123, "cba")
# 把目标字符串 [第一个] 出现的a或b，替换为- 
> str_replace(val, "[ab]", "-")  # 表示或者
[1] "-bc" "123" "c-a"
# 把目标字符串 [所有] 出现的a或b，替换为-
> str_replace_all(val, "[ab]", "-")
[1] "--c" "123" "c--"
#----把NA替换为字符串------------------------#
> str_replace_na(c(NA,'NA',"abc"),'x')  # 把NA替换为x
[1] "x"   "NA"  "abc"


字符串拆分

str_split & str_split_fixed

字符串分割，同str_split_fixed

  • str_split(string, pattern, n = Inf)
    • str_split()函数操作的结果类型为list > class(s1) [1] "list"
  • str_split_fixed(string, pattern, n)
    • str_split_fixed()函数分割，结果类型是matrix > class(s3) [1] "matrix"

pattern: 匹配的字符。

n: 分割个数

1
2
3
4
5
6
7
8
9
10
11
> val <- "abc,123,234,iuuu"
# 以,进行分割
> s1<-str_split(val, ",");s1
[[1]]
[1] "abc"  "123"  "234"  "iuuu"
# 以,进行分割，保留2块
> s2<-str_split(val, ",",2);s2
[[1]]
[1] "abc"          "123,234,iuuu"


字符串拼接

str_c & str_join

字符串拼接操作，与str_join完全相同，与paste()行为不完全一致。

  • str_c(…, sep = “”, collapse = NULL)
    • 拼接有NA值的字符串向量时，NA还是NA > str_c(c("a", NA, "b"), "-d") > "a-d" NA "b-d"
  • str_join(…, sep = “”, collapse = NULL)

…: 多参数的输入

sep: 把多个 [字符串] 拼接为一个大的字符串，用于字符串的分割符。

collapse: 把多个 [向量] 参数拼接为一个大的字符串，用于字符串的分割符。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#----------------示例--------------------------#
多个 [字符串] 拼接为一个大的字符串
> str_c('a','b',sep='-')
[1] "a-b"
> str_c(c('a','a1'),c('b','b1'),sep='-')
[1] "a-b"   "a1-b1"
多个 [向量] 参数拼接为一个大的字符串
> str_c(head(letters), collapse = ", ")
[1] "a, b, c, d, e, f"
# collapse参数，对多个字符串无效
> str_c('a','b',collapse = "-")   
[1] "ab"
> str_c(c('a','a1'),c('b','b1'),collapse='-')
[1] "ab-a1b1"

对比str_c()函数和paste()函数之间的不同点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
> # [字符串] 拼接，默认的sep参数行为 [不一致]
> > str_c('a','b')  # 默认分隔符为""
> [1] "ab"
> > paste('a','b')  # 默认分隔符为" "
> [1] "a b"
>
> # [向量] 拼接字符串，collapse参数的行为 [一致]
> > str_c(head(letters), collapse = "")
> [1] "abcdef"
> > paste(head(letters), collapse = "")
> [1] "abcdef"
>
>
> #拼接有 [NA值] 的字符串向量，对NA的处理行为 [不一致]
> > str_c(c("a", NA, "b"), "-d")
> [1] "a-d"   NA    "b-d" 
> > paste(c("a", NA, "b"), "-d")  # 将NA作为一个普通字符串来对待
> [1] "a -d"  "NA -d" "b -d" 
>

对比str_c() & paste() 与 cat() 的区别：

  • paste()：转为字符串后进行连接；
  • cat() ：连接后输出为对象
1
2
3
4
5
6
7
8
> > paste("hello", "bob", "\b.\n", "Is\'t R", "\t", "Great?\n","!")
> [1] "hello bob \b.\n Is't R \t Great?\n !"
>
> > cat("hello", "bob", "\b.\n", "Is\'t R", "\t", "Great?\n","!")
> hello bob.
>  Is't R 	 Great?
>  !
>

>


str_conv - 转码

字符编码转换

  • str_conv(string, encoding)

encoding: 编码名。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#----对中文进行转码处理---------------------------#
> 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] ""
#----把unicode转UTF-8------------------------------#
> x1 <- "\u5317\u4eac"
> str_conv(x1, "UTF-8")
[1] "北京"



字符串输出

str_trim - 空格

去掉字符串的空格和TAB(\t)

  • str_trim(string, side = c(“both”, “left”, “right”))

string: 字符串，字符串向量。

side: 过滤方式，both两边都过滤，left左边过滤，right右边过滤 “both”（默认）


str_to_upper/title - 大小写

字符串大小写转换

  • str_to_upper(string, locale = “”) ：全大写
  • str_to_lower(string, locale = “”) ：全小写
  • str_to_title(string, locale = “”) ：首字母大写

locale:按哪种语言习惯排序


str_pad - 补充长度

补充字符串的长度

  • str_pad(string, width, side = c(“left”, “right”, “both”), pad = “ “)

string: 字符串，字符串向量。

width: 字符串填充后的长度

side: 填充方向，both两边都填充，left左边填充，right右边填充

pad: 用于填充的字符 （默认为 空格）

1
2
3
4
5
6
7
# 从左边补充空格，直到字符串长度为20
> str_pad("conan", 20, "left")
[1] "               conan"
# 从左右两边各补充x字符，直到字符串长度为20
> str_pad("conan", 20, "both",'x')
[1] "xxxxxxxconanxxxxxxxx"


str_dup - 复制

复制字符串 duplicate

  • str_dup(string, times)

string: 字符串，字符串向量。

times: 复制数量

1
2
3
4
5
6
7
8
9
> val <- c("abca4", 123, "cba2")
# 复制2次
> str_dup(val, 2)
[1] "abca4abca4" "123123"     "cba2cba2"  
# 按位置复制
> str_dup(val, 1:3)  # 复制的次数从1次增加到3次
[1] "abca4"        "123123"       "cba2cba2cba2"


str_sort & str_order - 排序

字符串值排序，同str_order索引排序

  • str_sort(x, decreasing = FALSE, na_last = TRUE, locale = “”, …)
  • str_order(x, decreasing = FALSE, na_last = TRUE, locale = “”, …)

decreasing: 排序方向。 decrease - 减少

na_last:NA值的存放位置，一共3个值，TRUE放到最后，FALSE放到最前，NA过滤处理

locale:按哪种语言习惯排序

  • loacle = “en” - ASCII字母 / “zh” - 拼音
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 按ASCII字母排序
> str_sort(c('a',1,2,'11'), locale = "en")  
[1] "1"  "11" "2"  "a" 
# 倒序排序
> str_sort(letters,decreasing=TRUE)         
 [1] "z" "y" "x" "w" "v" "u" "t" "s" "r" "q" "p" "o" "n" "m" "l" "k" "j" "i" "h"
[20] "g" "f" "e" "d" "c" "b" "a"
# 按拼音排序
> str_sort(c('你','好','粉','丝','日','志'),locale = "zh")  
[1] "粉" "好" "你" "日" "丝" "志"
#----对NA值的排序处理------------------------#
 #把NA放最后面
> str_sort(c(NA,'1',NA),na_last=TRUE) 
[1] "1" NA  NA
#去掉NA值 
> str_sort(c(NA,'1',NA),na_last=NA)    
[1] "1"



字符串变换

str_warp - 格式

控制字符串输出格式

  • str_wrap(string, width = 80, indent = 0, exdent = 0)

string: 字符串，字符串向量。

width: 设置一行所占的宽度。

indent: 段落首行的缩进值

exdent: 段落非首行的缩进值

1
2
3
4
5
6
7
8
txt<-'R语言作为统计学一门语言，一直在小众领域闪耀着光芒。直到大数据的爆发，R语言变成了一门炙手可热的数据分析的利器。随着越来越多的工程背景的人的加入，R语言的社区在迅速扩大成长。现在已不仅仅是统计领域，教育，银行，电商，互联网….都在使用R语言。'
# 设置宽度为60字符，首行缩进2字符
> cat(str_wrap(txt, width = 60, indent = 2), "\n")
  R语言作为统计学一门语言，一直在小众领域闪耀着光芒。直到大数
据的爆发，R语言变成了一门炙手可热的数据分析的利器。随着越来
越多的工程背景的人的加入，R语言的社区在迅速扩大成长。现在已
不仅仅是统计领域，教育，银行，电商，互联网….都在使用R语言。


参数控制函数

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

regex

定义正则表达式


stringr的API介绍

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

  • stringr包中的函数默认使用正则表达式的函数（pattern）
  • R中的转义字符则是双斜杠：\\
    • \\d 代表\d

字符串拼接函数

  • 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:定义正则表达式