R语言学习笔记-文本挖掘之字符处理(1)

在挖掘分析的过程当中对字符串的处理是极为重要的,且出现也较为频繁,R语言作为当前最为流行的开源数据分析和可视化平台,虽然文本的处理并不是它的强项, 但是R语言还是包含大量的字符串操作工具,本章着重整理了部分常用字符处理函数及其使用方法。

1) 字符长度统计

length(x)函数 — 返回向量x的长度,或者说向量中元素的个数;

nchar(x)函数  — 返回向量x中的每个元素的字符个数,对于非字符元素会得到不可预料的结果。

–举例1:

x <-c("R", "Rstudio", "Revolution R")

#返回3,向量x中共有3个元素

length(x)

#返回1 7 12,向量x中每个元素的字符个数

nchar(x)

–举例2:

#返回1,空向量长度为1

length("")

#返回0,空向量字符长度为0

nchar("")

#非字符元素NA,返回错误结果2

nchar(NA)

2) 字符大小写转换

toupper(x)函数 — 将字符矩阵x内各元素转化为大写形式;

tolower(x)函数 — 将字符矩阵x内各元素转化为小写形式;

casefold(x,upper = FALSE)函数 — 将字符矩阵x内各元素转化为大写或小写形式,默认为转换为小写,当upper =TRUE时转换为大写;

–举例1:

x <- c("r", "rstudio", "revolutionR", NA)

#转化x中的各元素为大写形式,NA依然返回NA

toupper(x)

#转化x中的各元素为小写形式,NA依然返回NA

tolower(x)

#转化x中的各元素为小写形式,默认upper = FALSE,NA依然返回NA

casefold(x)

#转化x中的各元素为大写形式,设置upper = TRUE,NA依然返回NA

casefold(x, upper =TRUE)

5.2字符串连接

字符串连接是较为常见的字符操作,在此R提供了强大的paste函数,它不仅可以实现字符串的连接,也可以实现字符向量的连接,无论是字符向量还是字符串,在连接前paste会把对象首先转换为字符而后进行连接,另外,当向量连接时,较短的向量会循环使用。

1) paste 函数

基本语法:

paste (...,sep= " ", collapse =NULL)

参数sep表示连接的分隔符,默认为一个空格,参数collapse作为合并成一个字符串时的分隔符,详情请见以下应用实例:

–举例1:

x <- "Hello"; y <- "world"

paste(x, y)

#不设置sep,默认以空格分割

paste("A", 1:4)

#设置sep,去掉空格分隔符

paste("A", 1:4,sep= "")

–举例2:

#字符向量的连接,较短的字符循环被使用

paste(c("a", "b"), 1:3,sep= "")

–举例3:

#连接前隐式转换为字符串

name <- c("Kingsley", "William","Tom");

age <- c(30, 20, 10);

person <- data.frame(name, age)

#返回结果"NJc(1,3, 2)"    "NJc(30, 20,10)"

paste("NJ", person,sep="")

注: 数据框内的字符串会默认转换为因子(依赖于stringsAsFactors参数的设置,默认为True,即字符会被转换为因子类型),然后paste连接的时候会进行隐式转换,默认转换为字符型连接,所以使用paste函数时,有时候并不能得到想要的结果。

–举例4:

#使用collapse参数, collapse的使用可使连接后的字符组成一个字符串

#返回字符串A1,A2,A3,A4

paste("A", 1:4,sep="" ,collapse = ",")

2) paste0 函数

基本语法:

paste0(..., collapse = NULL)

参数意义paste与函数相同, 不同之处在于sep默认设置为空字符。

–举例1:

#结果中没有空格分隔符

paste0("A", 1:4)

3) sprintf函数

基本语法:

sprintf(fmt,...)

sprintf表示字符串“打印”,把若干元素按照给定的格式组合赋值给字符串。fmt表示包含格式字符的字符向量,sprintf中的参数会循环使用。

–举例1:

#以固定长度输出月份的名称,fmt被循环使用,长度不足在字符前面补空格

sprintf("%09s", month.name)

#以固定长度输出月份的名称,fmt被循环使用,长度不足在字符后面补空格

sprintf("%-9s", month.name)

–举例2:

#向量元素按顺序组合

sprintf(c("Name:%s", "Age: %s"), c("Kingsley", "30"))

–举例3:

#以指定格式输出圆周率

sprintf("%f",pi)

sprintf("%.3f",pi)

sprintf("%1.0f",pi)

sprintf("%5.1f",pi)

sprintf("%05.1f",pi)

sprintf("%+f",pi)

sprintf("%f", pi)

sprintf("%-10f",pi) # left justified

sprintf("%e",pi)

sprintf("%E",pi)

sprintf("%g",pi)

sprintf("%g",   1e6 * pi) # -> exponential

sprintf("%.9g",1e6 * pi) # -> "fixed"

sprintf("%G",1e-6 * pi)

4) cat函数

基本语法:

cat(... , file ="", sep = " ", fill = FALSE, labels = NULL,

append = FALSE)

cat函数用于连接字符串并输出到文件,默认file为空直接输出;sep表示连接的分隔符,默认为一个空格;fill逻辑值,为FALSE只有显式地使用“\n”才会换行输出,为TRUE只要达到选择宽度即可换行;labels为行标签,只在fill = TRUE时有效,若设定的行数小于实际行数,则会循环使用。append逻辑值,为FALSE会覆盖之前的输出,否则在原来内容后添加新输出。

–举例1:

#连接字符串,此处A不会循环使用

cat("A", 1:4, sep= " ")

–举例2:

#换行输出到文件abc.txt,每行都有相应的行标签

cat(paste(letters, 100*1:26), file = "abc.txt", fill = T, labels = paste0("{",1:10, "}:"))

5.3字符匹配

R语言有多重方法判断特定元素(vector)在另一个元素(vector)中是否存在匹配的元素。下面逐一介绍各种方法:

1.    match函数族

match函数族用于匹配字符时返回匹配或部分匹配的元素下标,匹配参数不支持正则表达式。

1)    match函数

基本语法:

match(x, table,nomatch = NA_integer_, incomparables = NULL)

其中参数nomatch表示不匹配时的返回值(默认为NA,强制为integer型),incomparables指定不能用来匹配的值(vector),因此incomparables中配置的值,即使x在table中得到匹配也会由nomatch代替。match函数要求完全匹配

–举例1:

#return 2,字符mn匹配字符向量第二个元素的值

match("mn",c("ab", "mn", "xy"), nomatch =NA)

–举例2:

#return 1,字符mn匹配字符向量第一以及第二个元素的值,返回第一个元素下标

match("mn",c("mn", "mn", "xy"), nomatch =NA)

–举例3:

#return NA,incomparables包含了字符值mn,因此即使匹配也返回NA

match("xy",c("ab", "mn", "xy"), nomatch =NA,incomparables = c("mn", "xy"))

函数%in%,实际可表示为match函数,不同的是返回值为逻辑向量

"%in%"<- function(x, table) match(x, table, nomatch = 0) > 0

–举例1:

#返回长度为10的逻辑向量,存在的为TRUE,不存在为FALSE

1:10 %in%c(1,3,5,9)

–举例2:

#返回sstr中存在于26个字符中的元素,包括大小写

sstr <-c("c","ab","B","bba","c",NA,"@","bla","a","Ba","%")

sstr[sstr %in%c(letters, LETTERS)]

2)    pmatch函数

基本语法:

pmatch(x, table,nomatch = NA_integer_, duplicates.ok = FALSE)

其中参数nomatch表示不匹配时的返回值(默认为NA,强制为integer型),

duplicates.ok表示table里面的元素是否可以适用多次。 pmatch函数是一个部分匹配函数, 依次从x里面挑出元素, 对照table进行匹配, 若匹配上则从table中剔除匹配上的值(部分匹配要求从元素的开始进行匹配,若x出现在table元素的中间不予匹配), 不再参与下次匹配, duplicate.ok可设置是否剔除; 对于某一个元素, 匹配一共分成三步:

l  如果可以完全匹配, 则认为匹配上了, 返回table中的位置;

l  不满足上述条件, 如果是唯一部分匹配, 则返回table中的位置;

l  不满足上述条件, 则认为没有值与其匹配上.

–举例1:

#return2,完成匹配第二个元素,忽略第一个元素的部分匹配

pmatch("me",   c("mean", "me","mode"))

–举例2:

#return1,唯一部分匹配,返回匹配的元素下标

pmatch("me",   c("mean", "mae","mode"))

–举例3:

#returnNA,部分匹配多个值返回NA

pmatch("m",   c("mean", "median", "mode"))

–举例4:

#returnNA,mn出现在元素的中间不是从元素头开始,因此不予匹配

pmatch("mn",   c("mean", "amnb", "mode"))

–举例5:

#duplicate.ok为FALSE,匹配后剔除,因此第一次完全匹配后table中的第二

#个元素被剔除,第二次只能取部分匹配的值,因此返回NA,2,1

pmatch(c("", "ab", "ab"), c("abc", "ab"), dup = FALSE)

–举例6:

#duplicate.ok为TRUE,table中元素可使用多次,因此第一次完全匹配后#table的第二个元素未被剔除,第二次认可使用,因此返回NA,2,2

pmatch(c("", "ab", "ab"), c("abc", "ab"), dup = FALSE)

3)charmatch函数

基本语法:

charmatch(x,table, nomatch = NA_integer_)

与pmatch功能类似可用于部分匹配,如果同时存在完全匹配和部分匹配则取完全匹配值的下标,对于多个完全配合或者多个部分匹配的情况返回0值,没有匹配的返回nomatch所设置的值。

–举例1:

#return2,完成匹配第二个元素,忽略第一个元素的部分匹配

charmatch("me",   c("mean", "me","mode"))

–举例2:

#return1,唯一部分匹配,返回匹配的元素下标

charmatch("me",   c("mean", "mae","mode"))

–举例3:

#return 0,部分匹配多个值返回0

charmatch("m",   c("mean", "median", "mode"))

–举例4:

#returnNA,mn出现在元素的中间不是从元素头开始,因此不予匹配

charmatch("mn",   c("mean", "amnb", "mode"))

–举例5:

#匹配后元素仍可重复使用,return 0,2,2

charmatch(c("", "ab", "ab"), c("abc", "ab"))

2.    grep函数族

与match函数不同,grep函数族可通过正则表达式在给定的对象中搜索文本。其中,grep输出向量的下标或值,grepl返回匹配与否的逻辑值。regexpr,gregexpr和regexec可以查找到某些字符在字符串中出现的具体位置和字符串长度信息,可以用于字符串的提取操作。

1) grep函数

基本语法:

grep(pattern, x, ignore.case= FALSE, perl = FALSE, value = FALSE,

fixed = FALSE, useBytes = FALSE, invert =FALSE)

grepl(pattern, x,ignore.case = FALSE, perl = FALSE,

fixed = FALSE, useBytes = FALSE)

grepRaw(pattern,x, offset = 1L, ignore.case = FALSE,value = FALSE, fixed = FALSE, all = FALSE,invert = FALSE)

pattern为字符串表示的正则表达式,或者字符串(fixed = TRUE),ignore.case逻辑值,FALSE表示大小写敏感,TRUE不敏感;perl逻辑值,是否使用Perl风格的正则表达式,FALSE表示不使用,TRUE表示使用;value逻辑值,FALSE返回匹配元素的下标,TRUE返回匹配的元素值;fixed逻辑值,FALSE表示正则表达式匹配,TRUE为精确匹配;useBytes逻辑值,FALSE表示按字符匹配,TRUE表示按字节匹配;invert逻辑值,FALSE 查找匹配值,TRUE返回不匹配元素下标或值(根据value值);offset指定匹配开始位置,all逻辑值,TRUE返回所有匹配值,FALSE返回第一个匹配值。

–举例1:

#查找含有字符o或者r的字符串,返回匹配的下标

grep("[or]",c("Tom", "Jerry", "Mickey"))

#查找含有字符o或者r的字符串,返回不匹配的下标

grep("[or]",c("Tom", "Jerry", "Mickey"), invert = TRUE)

#点好(.)匹配任意字符,返回下标

grep("e.r",c("pear", "cherry", "apple"))

#点好(.)匹配任意字符,value设置为TRUE,返回匹配的值

grep("e.r",c("pear", "cherry", "apple"), value = TRUE)

#$匹配一个字符串的结尾,返回以y结尾的字符串

grep("y$",c("year", "Jerry", "Mickey"))

#^匹配一个字符串的开始,返回以y开始的字符串

grep("^y",c("year", "Jerry", "Mickey"))

#匹配以c开头(不一定要求是字符串第一个字符),接着方括号中任意一个字符,最

#后以t结尾

grep("c[aeiou]t",c("cat", "pcut", "apple"))

#[^a]表示匹配任意不是a的元素

grep("c[^a]t",c("cat", "pcut", "apple"))

#匹配a或者u

grep("c(a|u)t",c("cat", "pcut", "apple"))

#匹配字符串pp,{n}表示匹配n个字符

grep("ap{2}",c("cat", "pcut", "apple"))

#匹配字符串anan,{n}表示匹配n个字符

grep("(an){2}",c("cat", "pcut", " banana"))

#?匹配前面的子表达式零次或一次

grep("c(a)?t",c("cat", "pct", "apple"))

#*匹配前面的子表达式任意次,可匹配任意次的c和a

grep("ca*t",c("cat", "pct", "cct", "caaaat"))

#+匹配前面的子表达式一次或多次(大于等于1),只能匹配a

grep("ca+t",c("cat", "pt", "cct", "caaaat"))

–举例2:

#查找含有字符o或者r的字符串,返回与向量长度相同的逻辑向量

grepl("[or]",c("Tom", "Jerry", "Mickey"))

–举例3:

#返回第一次出现o或者r的下标

grepRaw("[or]","Tomorrow")

#设置all = TRUE,返回所有的o和r的位置下标

grepRaw("[or]","Tomorrow", all = TRUE)

#从位置3开始向后搜索匹配

grepRaw("[or]","Tomorrow", all = TRUE, offset = 3)

注意: 若原字符为非字节形式,会强制使用charToRaw先字节化。例如 :

charToRaw("Tomorrow")

2) regexpr、gregexpr和regexec函数

返回匹配结果的具体位置以及字符串长度信息,可以用于字符串的提取操作。

基本语法:

regexpr(pattern,text, ignore.case = FALSE, perl = FALSE,

fixed = FALSE, useBytes = FALSE)

gregexpr(pattern,text, ignore.case = FALSE, perl = FALSE,

fixed = FALSE, useBytes = FALSE)

regexec(pattern,text, ignore.case = FALSE, fixed = FALSE,

useBytes =FALSE)

–举例1:

#返回匹配向量包括字符的位置及匹配长度(只匹配第一次出现的),不匹配返回-1

regexpr("ca*t",c("cat", "pct", "cctdcat", "caaaat","ddd"))

#返回匹配列表包含字符的位置及匹配长度(匹配多次),不匹配字符返回-1

gregexpr("ca*t",c("cat", "pct", "cctdcat", "caaaat","ddd"))

#返回匹配列表包含字符的位置及匹配长度(只匹配第一次出现的),不匹配返回-1

regexec("ca*t",c("cat", "pct", "cctdcat", "caaaat","ddd"))

regmatches函数,可以提取regexpr,gregexprregexec函数中匹配或者不匹配(invert = TRUE)的字符

基本语法:

regmatches(x, m,invert = FALSE)

–举例1:

#提取使用regexpr匹配的实际字符

x <- c("cat","pct", "cctdcat", "caaaat", "ddd")

m <-regexpr("ca*t", x)

regmatches(x, m)

3)agrep函数

根据广义Levenshtein编辑距离进行字符串模糊匹配(adist函数可用于计算Levenshtein编辑距离)。

基本语法 :

agrep(pattern, x,max.distance = 0.1, costs = NULL,

ignore.case = FALSE, value = FALSE, fixed= TRUE,

useBytes = FALSE)

agrepl(pattern,x, max.distance = 0.1, costs = NULL,

ignore.case = FALSE, fixed = TRUE,useBytes = FALSE)

max.distance表示允许的最大Levenshtein编辑距离。

–举例1:

#返回最大编辑距离小于等于3的字符值

#返回1,2

agrep("lasy",c("1 lazy", "lmansky", "1 LAZY"), max = 3)

#返回"1 lazy"

agrep("lasy",c("1 lazy", "lmansky", "1 LAZY"), max = 2, value= T)

–举例2:

#返回匹配的逻辑向量

agrepl("lasy",c("1 lazy", "lmansky", "1 LAZY"), max = 3)

5.4字符串提取/替换/拆分

1.    字符串提取

以下函数可用于字符串提取,同时substr和substring也可用于字符串替换。

1) substr函数

基本语法:

substr(x, start,stop)

对字符串x截取从start到stop的子字符串。

–举例1:

#Return:jing,截取字符串第4位到第7为的字符

substr("Nanjing", 4, 7)

#Return:jing,截取字符串第4位到第10为的字符,stop超出字符长度,

#只取值到字符末尾

substr("Nanjing", 4, 10)

#Return:空字符,start超出字符串长度

substr("Nanjing", 8, 10)

–举例2:

#截取字符向量,对于位置向量长度不足会循环使用

#位置向量为1:4, 2:5, 3:4, 1:5,两个位置向量都循环取值

substr(rep("abcdef", 4), 1:3, 4:5)

–举例3:

#替换原字符串1-3的字符

add <- "Nanjing"

substr(add, 1, 3) <- "Bei"

2) substring函数

基本语法:

substring(text,first, last = 1000000L)

对字符串x截取从first到last的子字符串,last默认值为1000000,可以不传参。

–举例1:

#Return:jing,截取字符串第4位到第7为的字符

substring("Nanjing", 4, 7)

#Return:jing,截取字符串第4位到末尾的子字符串,未设置last取默认值

substring("Nanjing", 4)

–举例2:

#下标向量循环使用截取字符串

substring("Nanjing", 1:2, 1:6)

#未设置last截取字符串

substring("Nanjing", 1:6)

–举例3:

#替换原字符串1-3的字符

add <- "Nanjing"

substring(add, 1, 3) <- "Bei"

3) strtrim函数

基本语法:

strtrim(x,width)

对字符串x从开头截取指定width的子字符串,参数均可循环使用。对于中文字符,一个字符的长度为2,因此width也要设置为2倍宽度。

–举例1:

#Return:Nan,从头开始截取定宽字符

strtrim("Nanjing", 3)

–举例2:

#Return:字符,中文字符宽度需设置为2倍

strtrim("字符操作函数",4)

2.    字符串替换

sub和gsub为字符串替换函数,通过正则表达式设置灵活的匹配规则,返回被替换后的字符串,两者唯一的差别在于前者匹配第一次符合模式的字符串,后者匹配所有符合模式的字符串,也就是说在替换的时候前者只替换第一次符合的,后者可替换所有符合的。

1)    sub和gsub函数

sub和gsub函数用于字符串替换,其中sub只替换第一次匹配的字符,而gsub会替换所有满足条件的匹配。由于R语言操作都是传值不传址,所以替换操作只是替换了原字符向量的copy,如果完全替换还需要再通过赋值操作。

基本语法:

sub(pattern,replacement, x, ignore.case = FALSE, perl = FALSE,

fixed = FALSE, useBytes = FALSE)

gsub(pattern,replacement, x, ignore.case = FALSE, perl = FALSE,

fixed = FALSE, useBytes = FALSE)

replacement参数表示需要替换的内容。

–举例1:

#以字符www替换第一次匹配的字符

sub("ca*t","www", c("cat", "pct", "cctdcat","caaaat", "ddd"))

#以字符www替换所有匹配的字符

gsub("ca*t","www", c("cat", "pct", "cctdcat", "caaaat","ddd"))

2)    chartr函数

基本语法:

chartr(old, new,x)

把字符串x中的字符按照old到new进行替换,字符串old和new要求长度一致,且按顺序匹配替换。

–举例1:

#替换字符一一对应进行映射

chartr("Nan","Bei", "Nanjing")

–举例2:

#替换过程同时生效,由于原字符不存在B,因此不会进行B->F转换

chartr("NB","BF", "Nanjing")

3.    字符串拆分

基本语法:

strsplit(x,split, fixed = FALSE, perl = FALSE, useBytes = FALSE)

strsplit根据split拆分字符串x,并返回子字符串组成的长度与x相同的列表, 分隔符split包括正则表达式,当fixed= TRUE时,需要精确匹配,为FALSE(默认),则使用正则表达式匹配, 除非使用反斜杠(\)转义。perl用于判断是否使用更强大的perl正则表达式,useBytes = TRUE 表示byte-by-byte按字节匹配, FALSE为character-by-character字符匹配(默认)。

–举例1:

#以分隔符-分割字符串

strsplit("JiangSu-Nanjing-Gaoxin","-")

–举例2:

#点好(.)为正则表达式表示任意字符,因此不能正确分割字符串

strsplit("JiangSu.Nanjing.Gaoxin",".")

#设置fixed为TRUE,精确匹配点好

strsplit("JiangSu.Nanjing.Gaoxin",".", fixed = TRUE)

#使用反斜杠(\)转义

strsplit("JiangSu.Nanjing.Gaoxin","\\.")

#使用通配符[],表示含有点号的字符

strsplit("a.b.c","[.]")

–举例3:

#以下三种情况相同,把字符串分解为一个一个单个字符

strsplit("JiangSu-Nanjing-Gaoxin",NULL)

strsplit("JiangSu-Nanjing-Gaoxin","")

strsplit("JiangSu-Nanjing-Gaoxin",character(0))

–举例4:

#\s表示空白字符(包括空格、制表符、换行符等)

strsplit("JiangSuNanjing Gaoxin", "\\s")

strsplit("JiangSu\nNanjing\nGaoxin","\\s")

–举例5:

#使用分隔符”-”,对字符向量分解

person <-c("Tom-30", "Jerry-20", "Bob-18")

strsplit(person,"-")

5.5字符编码转换

字符编码即编码字符集和实际存储数值之间的转换关系。字符集规定了某个文字对应的二进制数字存放方式(编码)和某串二进制数值代表了哪个文字(解码)的转换关系。R语言提供的一些字符编码函数。

1)    Encoding函数

Encoding函数用于读取和设置字符向量的编码。R字符串可以使用包括 "latin1" , "UTF-8" 或 "bytes"的编码格式。由于ASCII 字符串对各种编码表示的形式相同,所以Encoding获取的编码方式为unknown。

–举例1:

x <-"fa\xE7ile"

#字符编码为unknown

Encoding(x)

#设置字符编码为latin1

Encoding(x) <-"latin1"

2)    iconv函数

字符编码转换,转换过程中并不会做太多的校验,因此放源编码不合法时,常常不能正确转换,基本语法:

iconv(x, from ="", to = "", sub = NA, mark = TRUE, toRaw = FALSE)

from为源编码;to为目标编码;sub用于替换不能转换的字节(默认为NA),如果本身为字节类型,则使用16进制字节形式替换。mark逻辑值,指明返回的字符向量是否申明编码类型,默认为TRUE即返回编码类型;toRaw逻辑值,指明是返回字符向量还是字节向量。

–举例1:

x <-"fa\xE7ile"

#设置字符编码为latin1

Encoding(x) <-"latin1"

#转换latin1字符编码为UTF-8

iconv(x, "latin1","UTF-8")

–举例2:

x <-"fa\xE7ile"

Encoding(x) <-"latin1"

#转换为字节型输出

iconv(x, "latin1","UTF-8", toRaw = T)

charToRaw(iconv(x,"latin1", "UTF-8"))

注意:

iconvlist() 可用于输出不同环境支持的编码类型

从当前语言环境选择合适的编码名称。

localeToCharset(locale =Sys.getlocale("LC_CTYPE"))

5.6字符串处理包stringr

相较于R语言基本的字符操作,stringr包提供了更加灵活易用的字符操作方式。

1.    统计匹配的字符数

基本语法:

str_count(string,pattern = "")

–举例1:

x <-c("R", "Rstudio", "Revolution R")

#统计字符向量中每个字符串中字符R的个数

str_count(x,pattern = "R")

–举例2:

#不能正确统计元字符的个数

str_count(c("a.","...", ".a.a"), ".")

#使用fixed函数

str_count(c("a.","...", ".a.a"), fixed("."))

#使用反斜杠转义

str_count(c("a.","...", ".a.a"), "\\.")

#使用[.]同样有效

str_count(c("a.","...", ".a.a"), "[.]")

–举例3:

#使用空字符串返回每个字符串的字符个数,相当于nchar

x <-c("R", "Rstudio", "Revolution R")

str_count(x,pattern = "")

2.    字符长度统计

基本语法:

str_length(string)

–举例1:

x <-c("R", "Rstudio", "Revolution R", NA)

#统计每个字符串的字符个数,相当于nchar,不同的是NA不会计数依然返回NA

str_length(x)

3.    字符串转换

基本语法:

str_to_upper(string,locale = "")

str_to_lower(string,locale = "")

str_to_title(string,locale = "")

–举例1:

x <-c("r", "rstudio", "revolution R", NA)

#转换为全小写,NA依然返回NA

str_to_lower(x)

#转换为全大写,NA依然返回NA

str_to_upper(x)

#转换为首字符大写,NA依然返回NA

str_to_title(x)

4.    字符串连接

基本语法:

str_c(..., sep ="", collapse = NULL)

参数sep表示连接的分隔符,默认为空字符,参数collapse作为合并成一个字符串时的分隔符。

–举例1:

x <-"Hello"; y <- "world"

str_c(x, y)

str_c(x, y, sep= ",")

–举例2:

#以逗号连接为一个字符串

str_c("A",1:4, collapse = ",")

–举例3:

#NA不参与连接,依然输出NA

str_c(c("A","B", NA, "C"), 1:4)

5.    字符串匹配

1)    str_match函数

基本语法:

str_match(string,pattern)

str_match_all(string,pattern)

–举例1:

#返回实际匹配字符组成的字符矩阵,只包含第一个匹配的字符,不匹配值返回NA

str_match(c("pear,ear","cherry", "apple"), "e.r")

–举例2:

#返回字符矩阵组成的list,包含所有匹配的字符,不匹配值返回空字符

str_match_all(c("pear,ear","cherry", "apple"), "e.r")

2)    str_extract函数

基本语法:

str_extract(string,pattern)

str_extract_all(string,pattern, simplify = FALSE)

simplify默认值为FALSE,返回字符向量组成的列表,为TRUE则返回字符矩阵。

–举例1:

#返回实际匹配字符组成的字符向量,只包含第一个匹配的字符,不匹配值返回NA

str_extract(c("pear,ear","cherry", "apple"), "e.r")

–举例2:

#匹配所有满足条件字符,不匹配值返回空字符

#simplify = FALSE(默认),返回字符向量组成的list

str_extract_all(c("pear,ear","cherry", "apple"), "e.r")

#simplify= TRUE,返回字符向量组成的matrix

str_extract_all(c("pear,ear", "cherry","apple"), "e.r", simplify = TRUE)

3)    str_detect函数

基本语法:

str_detect(string,pattern)

返回与string等长的逻辑向量,类似于grepl。

–举例1:

fruit <-c("apple", "banana", "pear","pinapple")

#返回与string向量长度相同的逻辑矩阵,包含所有匹配的元素

str_detect(fruit,"a")

str_detect(fruit,"^a")

str_detect(fruit,"a$")

str_detect(fruit,"b")

str_detect(fruit,"[aeiou]")

1)    str_subset函数

基本语法:

str_subset(string,pattern)

返回匹配的字符串值,类似于grep(pattern, x,value = TRUE)。

–举例1:

fruit <-c("apple", "banana", "pear","pinapple")

#返回匹配的所有字符串值

#相当于fruit[str_detect(fruit,"[lr]")]

str_subset(fruit,"[lr]")

2)    str_locate函数

基本语法:

str_locate(string,pattern

str_locate_all(string,pattern)

查找匹配的字符,返回数值矩阵,第一列为匹配字符的起始位置,第二列为终止位置。str_locate_all返回由数值矩阵组成的列表。

–举例1:

#返回第一个匹配字符的位置矩阵,不匹配值和NA值返回NA

str_locate(c("pear,ear","cherry", "apple", NA), "e.r")

–举例2:

#返回全部匹配字符位置矩阵组成的列表,不匹配值返回空,NA依然返回NA

str_locate_all(c("pear,ear","cherry", "apple", NA), "e.r")

6.    字符串复制

基本语法:

str_dup(string, times)

–举例1:

#按位置复制字符串,NA不会复制

str_dup(c("pear,ear","cherry", "apple", NA), c(1:4))

7.    字符串补充

基本语法:

str_pad(string,width, side = c("left", "right", "both"), pad =" ")

string为字符串或字符串向量;width为字符串填充后的长度;side为填充方向,both两边填充,left左边填充,right右边填充;pad: 用于填充的字符,默认为空格。

–举例1:

#两边填充字符*直到宽度为10

str_pad(c("pear,ear","cherry", "apple", NA), 10, "both", pad ="*")

8.    字符串去空格

基本语法:

str_trim(string, side = c("both","left", "right"))

去除包括空格,\t和\n等字符。

–举例1:

#删除字符串左边的空格

str_trim("   \t\npear \t \n ", "left")

–举例2:

#删除字符串右边的空格

str_trim("   \t\npear \t \n ", "right")

–举例3:

#删除字符串两边的空格,不设置side默认为both

str_trim("   \t\npear \t \n ", "both")

9.    字符串截取/替换/拆分

1)    str_sub函数

基本语法:

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

str_sub(string, start = 1L,end = -1L) <- value

对字符串string截取从start到end的子字符串。

–举例1:

#Return:jing,截取字符串第4位到第7为的字符

str_sub("Nanjing", 4, 7)

#Return:jing,截取字符串第4位到第10为的字符,stop超出字符长度,

#只取值到字符末尾

str_sub("Nanjing", 4, 10)

#Return:空字符,start超出字符串长度

str_sub("Nanjing", 8, 10)

–举例2:

#截取字符向量,对于位置向量长度不足会循环使用

#位置向量为1:4, 2:5, 3:4, 1:5,两个位置向量都循环取值

str_sub(rep("abcdef", 4), 1:3, 4:5)

–举例3:

#end可以设置为负值

str_sub("Nanjing", 3, -2)

–举例4:

#替换原字符串1-3的字符

add <- "Nanjing"

str_sub(add, 1, 3) <- "Bei"

2)    word函数

基本语法:

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

用于从语句中提取单词(字符串)。string为字符串或字符串向量;start为数值向量给出提取的开始位置;end为数值向量给出提取的结束位置;sep为单词间分隔符。

–举例1:

fruit <-c("apple red", "banana yellow", NA)

#默认以空格为分隔符,取第一个位置的字符

word(fruit, 1)

#默认以空格为分隔符,取第二个位置的字符

word(fruit, 2)

word(fruit, -1)

–举例1:

fruit <-c("apple.red", "banana.yellow", NA)

#以点好.为分隔符,取第一个位置的字符

word(fruit, 1,sep = fixed("."))

3)    str_replace函数

基本语法:

str_replace(string, pattern,replacement)

str_replace_all(string,pattern, replacement)

str_replace_na(string,replacement = "NA")

找到匹配的字符,并用给定的字符串进行替换。

–举例1:

fruit <- c("apple", "banana", "pear", "pinapple", NA)

#替换字符串中第一次出现的a或p

str_replace(fruit, "[ap]", "*")

#替换字符串中所有的a或p

str_replace_all(fruit, "[ap]", "*")

–举例2:

#替换NA为NA字符串

str_replace_na(c(NA, "NA", "apple"))

#替换NA为字符*

str_replace_na(c(NA, "NA", "apple"), "*")

4)    str_split函数

基本语法:

str_split(string, pattern, n= Inf)

str_split_fixed(string,pattern, n)

对字符串进行拆分,n为分割的字符串个数。

–举例1:

#使用反斜杠(\)转义

str_split("JiangSu.Nanjing.Gaoxin","\\.")

#分解为两个字符串

str_split("JiangSu.Nanjing.Gaoxin","\\.", 2)

#使用通配符[],表示含有点号的字符

str_split("a.b.c","[.]")

#设置fixed为TRUE,精确匹配点好

str_split_fixed("JiangSu.Nanjing.Gaoxin","\\.", 3)

–举例3:

#把字符串分解为一个一个单个字符,不支持NULL以及character(0)

str_split("JiangSu-Nanjing-Gaoxin","")

–举例4:

#使用分隔符”-”,对字符向量分解

person <-c("Tom-30", "Jerry-20", "Bob-18")

#返回list对象

str_split(person,"-")

10.  字符串编码转换

基本语法:

str_conv(string, encoding)

–举例1:

x <-"fa\xE7ile"

#设置字符编码为latin1

str_conv(x,"latin1")

11.  字符串值排序

基本语法:

str_order(x, decreasing =FALSE, na_last = TRUE, locale = "", ...)

str_sort(x, decreasing =FALSE, na_last = TRUE, locale = "", ...)

decreasing逻辑值,指定排序方向,默认为升序;na_last逻辑值,NA值的存放位置, TRUE放到最后,FALSE放到最前,NA表示过滤NA值排序;locale设置按那种语言习惯排序。

–举例1:

fruit <- c("pear","apple", "pinapple", "banana", NA)

#按英文排序

str_sort(fruit,locale = "en")

#返回排序后的下标

str_order(fruit,locale = "en")

#过滤NA后排序

str_sort(fruit,locale = "en", na_last = NA)

12.  字符串输出

基本语法:

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

string为字符串或字符串向量;width设置行宽;indent设置段落首行的缩进值;exdent设置段落非首行的缩进值。类似于strwrap函数。

–举例1:

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

#设置宽度为40

cat(str_wrap(thanks,width = 40), "\n")

#设置宽度为60,首行缩进2个字符

cat(str_wrap(thanks,width = 60, indent = 2), "\n")

#设置宽度为60,非首行缩进2个字符

cat(str_wrap(thanks,width = 60, exdent = 2), "\n")

#设置宽度为0,每个单词为一行输出

cat(str_wrap(thanks,width = 0, exdent = 2), "\n")

推荐阅读更多精彩内容