R语言中的字符处理

R语言中的字符处理

 (2011-07-10 22:29:48)
转载▼
标签： 

r语言

 

字符处理

 

字符串

 

连接

 

分割

 分类： R
R的字符串处理能力还是很强大的，具体有base包的几个函数和stringr包。

1.计算字符串的字符数
nchar() 

2. 字符串连接
paste(..., sep = " ", collapse = NULL)，其中collpase参数可将多个字符串连接成一个。
=====================================
> paste(letters[1:5], "_1", sep = '')
[1] "a_1" "b_1" "c_1" "d_1" "e_1"
> paste(letters[1:5], collapse='_')
[1] "a_b_c_d_e"
=====================================

3. 字符串分割
3.1 分隔符截取
strsplit(x, split, extended = TRUE, fixed = FALSE, perl = FALSE)
=================================================================================
QWE <- c("QWERTYUIOPASDFGHJKLZXCVBNM")
> unlist(strsplit(QWE, ""))
 [1] "Q" "W" "E" "R" "T" "Y" "U" "I" "O" "P" "A" "S" "D" "F" "G" "H" "J" "K" "L"
[20] "Z" "X" "C" "V" "B" "N" "M"

> xtest  #将xtest表示化成小时为单位的时间表示形式，以便用于坐标轴显示
 [1] "0:00:04"  "0:53:18"  "1:53:18"  "2:53:17"  "3:53:16"  "4:53:16"
 [7] "5:53:16"  "6:53:16"  "7:53:16"  "8:53:16"  "9:53:15"  "10:53:14"
[13] "11:53:13" "12:53:13" "13:53:13" "14:53:13" "15:53:13" "16:53:13"
[19] "17:53:13" "18:53:13" "19:53:13" "20:53:13" "21:53:13" "22:53:13"
[25] "23:53:14"

> xtest <- as.data.frame(strsplit(xtest, split= ":"))
> xtest
  c..0....00....04.. c..0....53....18.. c..1....53....18.. c..2....53....17..
1                  0                  0                  1                  2
2                 00                 53                 53                 53
3                 04                 18                 18                 17
  c..3....53....16.. c..4....53....16.. c..5....53....16.. c..6....53....16..
1                  3                  4                  5                  6
2                 53                 53                 53                 53
3                 16                 16                 16                 16
  c..7....53....16.. c..8....53....16.. c..9....53....15.. c..10....53....14..
1                  7                  8                  9                  10
2                 53                 53                 53                  53
3                 16                 16                 15                  14
  c..11....53....13.. c..12....53....13.. c..13....53....13..
1                  11                  12                  13
2                  53                  53                  53
3                  13                  13                  13
  c..14....53....13.. c..15....53....13.. c..16....53....13..
1                  14                  15                  16
2                  53                  53                  53
3                  13                  13                  13
  c..17....53....13.. c..18....53....13.. c..19....53....13..
1                  17                  18                  19
2                  53                  53                  53
3                  13                  13                  13
  c..20....53....13.. c..21....53....13.. c..22....53....13..
1                  20                  21                  22
2                  53                  53                  53
3                  13                  13                  13
  c..23....53....14..
1                  23
2                  53
3                  14
> mode(xtest)
[1] "list"

> xtest <- apply(xtest, c(1,2), as.numeric)  # list --> numeric
> mode(xtest)
[1] "numeric"

> xtest <- apply(xtest, 2, function(x){x[1]+x[2]/60+x[3]/3600})
> xtest
 c..0....00....04..  c..0....53....18..  c..1....53....18..  c..2....53....17..
         0.01111111          0.93333333          1.93333333          2.93055556
 c..3....53....16..  c..4....53....16..  c..5....53....16..  c..6....53....16..
         3.92777778          4.92777778          5.92777778          6.92777778
 c..7....53....16..  c..8....53....16..  c..9....53....15.. c..10....53....14..
         7.92777778          8.92777778          9.92500000         10.92222222
c..11....53....13.. c..12....53....13.. c..13....53....13.. c..14....53....13..
        11.91944444         12.91944444         13.91944444         14.91944444
c..15....53....13.. c..16....53....13.. c..17....53....13.. c..18....53....13..
        15.91944444         16.91944444         17.91944444         18.91944444
c..19....53....13.. c..20....53....13.. c..21....53....13.. c..22....53....13..
        19.91944444         20.91944444         21.91944444         22.91944444
c..23....53....14..
        23.92222222
==================================================================================

3.2 按照特定长度截取
substr(x, start, stop)
substring(text, first, last = 1000000)
substr(x, start, stop) <- value
substring(text, first, last = 1000000) <- value

===============================================================
> substring("abcdefghij", seq(1, 9, 2), seq(2, 10, 2))  
# 这里用了“向量化”的思想，即substring(first, last)用向量处理。
[1] "ab" "cd" "ef" "gh" "ij"
===============================================================

4. 字符串替换及大小写转换
4.1 普通替换
chartr(old, new, x)

4.2 正则替换
sub(pattern, replacement, x, ignore.case = FALSE, perl = FALSE, fixed = FALSE, useBytes = FALSE)和gsub()可以进行正则替换，x表示字符向量。区别在于，sub()只替换第一个遇到，而gsub()替换其中所有。
=======================================================================
speList <- "Escherichia coli K-12 MG1655, Escherichia coli K-12 W3110"
> sub('Escherichia coli', 'E.coli', speList)
[1] "E.coli K-12 MG1655, Escherichia coli K-12 W3110"
> gsub('Escherichia coli', 'E.coli', speList)
[1] "E.coli K-12 MG1655, E.coli K-12 W3110"
=======================================================================

4.3 大小写转换
tolower(x)
toupper(x)
casefold(x, upper = FALSE)
其中，casefold()是S语言兼容函数，可以忽略。

5. 字符串匹配
grep(pattern, x, ignore.case = FALSE, extended = TRUE, perl = FALSE, value = FALSE, fixed = FALSE, useBytes = FALSE)，grepl()，regexpr()，gregexpr()，regexec()函数是基本的字符匹配函，它们都可以匹配字符向量。

grep()返回匹配元素序号，grepl()返回匹配元素逻辑值。regrexpr()返回第一个匹配序号（整数向量）和长度属性，-1表示无匹配，1表示匹配；gregexpr()返回列表（长度与输入相同），全部匹配序号、长度属性和useBytes属性；regrexec()返回列表（长度与输入相同），第一个匹配序号和长度属性

匹配规则：
.：除换行符之外的其他任意字符。
^：字符串开始，如果放在中括号内部，则表示取非。
$：字符串结束。
*：零个或者多个重复。
+：一个或者多个重复。
?：零个或者一个重复。
.*：任意一个无换行字符串。
^$：空行。
[]：表示其中任意一个；^在[]中表示取“非”；-在[]中表示“从...到...”。
[a-zA-Z]：任意一个英文字母。
[a-z]+：一个或者多个小写英文字母。
[^a-z]：除了26个小写英文字母外的其他任意一个字符（-优先级大于^）。
()：表示作为一个整体。
|：表示“或”。
{n}：表示恰好重复n次。
{n,}：表示重复大于等于n次。
{n,m}：表示重复大于等于次，小于等于m次。
如果需要使用.，^，$，*，+，?，[，]，(，)，{，}，\和/必须使用/作为转义，比如/*，/\。

其他特殊意思匹配：
\n：换行。\n\n在Linux文件中匹配空白行，\r\n\r\n在Windows文件中匹配空白行，也可以使用(\r?\n){2}匹配。
\f：换页。
\r：回车
\t：Tab。
\v：垂直制表符号。
\s：任意一个空白字符，等同于[\n\f\r\t\v]，但不包括一个空格。如果需要匹配一个空格，直接输入“空格”，比如匹配一个或多个空格[ ]{1, }。
\S：以上取反意。
\w：任意字母、数字或者下划线。
\W：以上取反意。
\d：任意一个数字。
\D：以上取反意。
\b：表示一个“单词”的开始或者结束，“单词”的意思是指不少一个的连续\w，即\w{1, }。
\B：以上取反意。

因为R将\也视为转义，所以类似\*都需要写成\\*，比如
========================================================
> gregexpr("\\(human\\)", "Homo sapiens (human)")
[[1]]
[1] 14
attr(,"match.length")
[1] 7
attr(,"useBytes")
[1] TRUE
=======================================================

特殊规则：
1. 贪婪和惰性
举例：普通的*是“贪婪”的，默认能匹配多少就匹配多少，比如：

======================================
> regexpr("a.*b", 'aababababab')
[1] 1
attr(,"match.length")
[1] 11
attr(,"useBytes")
[1] TRUE

> regexpr("a.*?b", 'aababababab')
[1] 1
attr(,"match.length")
[1] 3
attr(,"useBytes")
[1] TRUE
========================================
第一个例子中，一直贪婪地匹配到了最后；第二个例子则懒惰地匹配到第一个就停止了。常用的惰性匹配有：*?，+?，??，{n, m}?，{n, }?。

     'agrep' for approximate matching.

     'tolower', 'toupper' and 'chartr' for character translations.
     'charmatch', 'pmatch', 'match'. 'apropos' uses regexps and has
     nice examples.


stringr包
str_trim()：去除多余空格。


字符不完全匹配
agrep()
参考：
1. http://cos.name/cn/topic/12987#post-12987
2. http://cos.name/cn/topic/104746
4. 字符匹配详细介绍：http://pgfe.umassmed.edu/ou/archives/2876
6. 书籍推荐：正则表达式必知必会
posted @ 2014-05-20 10:31  JamesFan  阅读(1315)  评论(0)  编辑  收藏  举报