在本文中，我们将带你了解Python模块re在这篇文章中，我们将为您详细介绍Python模块re的方方面面，并解答RegularExpression常见的疑惑，同时我们还将给您一些技巧，以帮助您实现更
在本文中，我们将带你了解Python 模块 re 在这篇文章中，我们将为您详细介绍Python 模块 re 的方方面面，并解答Regular Expression常见的疑惑，同时我们还将给您一些技巧，以帮助您实现更有效的3.2 re--正则表达式操作（Regular expression operations）、ABAP 正则表达式（Regular Expressions）、Grep命令中正则表达式（regular Expressions,RE)的用法、iphone – NSPredicate和NSRegularExpression。
本文目录一览：- Python 模块 re （Regular Expression）（python 模块化设计）
- 3.2 re--正则表达式操作（Regular expression operations）
- ABAP 正则表达式（Regular Expressions）
- Grep命令中正则表达式（regular Expressions,RE)的用法
- iphone – NSPredicate和NSRegularExpression
Python 模块 re （Regular Expression）（python 模块化设计）
使用 Python 模块 re 实现解析小工具
概要
在开发过程中发现，Python 模块 re（Regular Expression）是一个很有价值并且非常强大的文本解析工具，因而想要分享一下此模块的使用方法。
有这样一个简单而有趣的实践范例：对于喜欢追看美剧的年轻人，最新一集美剧的播出时间常常是一个让人头疼的问题，一个实时更新美剧播出时间表的小工具会很受欢迎。
本文通过以上这个实例，描述如何抓获 TV.com 网站上的文本信息，利用 Python 的 re 模块进行解析，并将热门美剧播出时间显示在自己的网页上，希望能够以娱乐的方式很好的解释 re 模块的用法。
Python 正则表达式模块 (re) 简介
Python 的 re 模块（Regular Expression 正则表达式）提供各种正则表达式的匹配操作，和 Perl 脚本的正则表达式功能类似，使用这一内嵌于 Python 的语言工具，尽管不能满足所有复杂的匹配情况，但足够在绝大多数情况下能够有效地实现对复杂字符串的分析并提取出相关信息。Python 会将正则表达式转化为字节码，利用 C 语言的匹配引擎进行深度优先的匹配。
Python 正则表达式语法
正则表达式可以包含普通字符和特殊字符，普通字符（比如数字或者字母）可以直接对目标字符串进行匹配，在本文中我们主要讨论利用特殊字符来模糊匹配某一些字符串的方法，比如 ''|'' 或者 ''(''，使用这些特殊字符，正则表达式可以表示某一类的普通字符，或者是改变其周围的正则表达式的含义。具体如表 2-1 所示：
表 1. 正则表达式语法
| 符号 | 意义 | 例子 |
|---|---|---|
| . | 表示任意字符，如果说指定了 DOTALL 的标识，就表示包括新行在内的所有字符。 | |
| ^ | 表示字符串开头。 | |
| $ | 表示字符串结尾。 | ‘ test ’ 可以匹配‘ test ’和‘ testtool ’，但‘ test$ ’只能匹配‘ test ’。 |
| *, +, ? | ''*'' 表示后面可跟 0 个或多个字符，''+'' 表示后面可跟 1 个或多个字符，''?'' 表示后面可跟 0 个或多个字符 | ‘ abc* ’可以匹配‘ abc ’ 或者‘ abcd ’或者‘ abcdefg ’等等。 |
| *?, +?, ?? | 在上面的结果中只去第一个 | <*> 会匹配 ''<H1>title</H1>'' 整个字符串（贪婪匹配），使用 *? 可以只找出 <H1>（非贪婪匹配） |
| {m} | 对于前一个字符重复 m 次 | a {6} 匹配 6 个 ''a'' |
| {m,n} | 对于前一个字符重复 m 到 n 次 | a {2,4} 匹配 2-4 个 a，a {2,} 匹配 2 个以上 a，a {,4} 匹配 4 个以下 a |
| {m,n}? | 对于前一个字符重复 m 到 n 次，并且取尽可能少的情况 | 在字符串 ''aaaaaa'' 中，a {2,4} 会匹配 4 个 a，但 a {2,4}? 只匹配 2 个 a |
| \ | 对特殊字符进行转义，或者是指定特殊序列 | |
| [] | 表示一个字符集 | [abc] 会匹配字符 a，b 或者 c，[a-z] 匹配所有小写字母，[a-zA-Z0-9] 匹配所有字母和数字，[^6] 表示除了 6 以外的任意字符 |
| | | 或者，只匹配其中一个表达式 | A|B，如果 A 匹配了，则不再查找 B，反之亦然 |
| ( … ) | 匹配括号中的任意正则表达式 | |
| (?#...) | 注释，忽略括号内的内容 | |
| (?= … ) | 表达式’…’之前的字符串 | 在字符串’ pythonretest ’中 (?=test) 会匹配’ pythonre ’ |
| (?!...) | 后面不跟表达式’…’的字符串 | 如果’ pythonre ’后面不是字符串’ test ’，那么 (?!test) 会匹配’ pythonre ’ |
| (?<= … ) | 跟在表达式’…’后面的字符串符合括号之后的正则表达式 | 正则表达式’ (?<=abc) def ’会在’ abcdef ’中匹配’ def ’ |
| (?<!...) | 括号之后的正则表达式不跟在’…’的后面 |
包含’ \ ’的特殊序列的意义如表 2-2：
表 2. 正则表达式特殊序列
| 特殊表达式序列 | 意义 |
|---|---|
| \A | 只在字符串开头进行匹配。 |
| \b | 匹配位于开头或者结尾的空字符串 |
| \B | 匹配不位于开头或者结尾的空字符串 |
| \d | 匹配任意十进制数，相当于 [0-9] |
| \D | 匹配任意非数字字符，相当于 [^0-9] |
| \s | 匹配任意空白字符，相当于 [\t\n\r\f\v] |
| \S | 匹配任意非空白字符，相当于 [^ \t\n\r\f\v] |
| \w | 匹配任意数字和字母，相当于 [a-zA-Z0-9_] |
| \W | 匹配任意非数字和字母的字符，相当于 [^a-zA-Z0-9_] |
| \Z | 只在字符串结尾进行匹配 |
Python re 的主要功能
Python 的 re 正则表达式模块定义了一系列函数，常量以及异常；同时，正则表达式被编译成‘ RegexObject ’实例，本身可以为不同的操作提供方法。接下来简要介绍一下这些函数的功能和用法。
compile
re.compile(pattern[, flags])
把正则表达式的模式和标识转化成正则表达式对象，供 match () 和 search () 这两个函数使用。
re 所定义的 flag 包括：
re.I 忽略大小写
re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
re.M 多行模式
re.S 即为’ . ’并且包括换行符在内的任意字符（’ . ’不包括换行符）
re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
re.X 为了增加可读性，忽略空格和’ # ’后面的注释
例：以下两种用法结果相同：
A)
|
1
2
|
compiled_pattern = re.compile(pattern)
result = compiled_pattern.match(string)
|
B)
|
1
|
result = re.match(pattern, string)
|
search
re.search(pattern, string[, flags])
在字符串中查找匹配正则表达式模式的位置，返回 MatchObject 的实例，如果没有找到匹配的位置，则返回 None。
对于已编译的正则表达式对象来说（re.RegexObject），有以下 search 的方法：
search (string[, pos[, endpos]])
若 regex 是已编译好的正则表达式对象，regex.search (string, 0, 50) 等同于 regex.search (string [:50], 0)。
具体示例如下。
|
1
2
3
|
>>> pattern = re.compile("a")
>>> pattern.search("abcde") # Match at index 0
>>> pattern.search("abcde", 1) # No match;
|
match
re.match(pattern, string[, flags])
判断 pattern 是否在字符串开头位置匹配。对于 RegexObject，有：
match(string[, pos[, endpos]])
match () 函数只在字符串的开始位置尝试匹配正则表达式，也就是只报告从位置 0 开始的匹配情况，而 search () 函数是扫描整个字符串来查找匹配。如果想要搜索整个字符串来寻找匹配，应当用 search ()。
split
re.split(pattern, string[, maxsplit=0, flags=0])
此功能很常用，可以将将字符串匹配正则表达式的部分割开并返回一个列表。对 RegexObject，有函数：
split(string[, maxsplit=0])
例如，利用上面章节中介绍的语法：
|
1
2
3
4
5
6
|
>>> re.split(''\W+'', ''test, test, test.'')
[''test'', ''test'', ''test'', '''']
>>> re.split(''(\W+)'', '' test, test, test.'')
['' test '', '', '', '' test '', '', '', '' test '', ''.'', '''']
>>> re.split(''\W+'', '' test, test, test.'', 1)
['' test '', '' test, test.'']
|
对于一个找不到匹配的字符串而言，split 不会对其作出分割，如：
|
1
2
|
>>> re.split(''a*'', ''hello world'')
[''hello world'']
|
findall
re.findall(pattern, string[, flags])
在字符串中找到正则表达式所匹配的所有子串，并组成一个列表返回。同样 RegexObject 有：
findall(string[, pos[, endpos]])
示例如下：
|
1
2
|
#get all content enclosed with [], and return a list
>>> return_list = re.findall("(\[.*?\])",string)
|
finditer
re.finditer(pattern, string[, flags])
和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并组成一个迭代器返回。同样 RegexObject 有：
finditer(string[, pos[, endpos]])
sub
re.sub(pattern, repl, string[, count, flags])
在字符串 string 中找到匹配正则表达式 pattern 的所有子串，用另一个字符串 repl 进行替换。如果没有找到匹配 pattern 的串，则返回未被修改的 string。Repl 既可以是字符串也可以是一个函数。对于 RegexObject 有：
sub(repl, string[, count=0])
此语法的示例有：
|
1
2
3
|
>>> p = re.compile( ''(one|two|three)'')
>>> p.sub( ''num'', ''one word two words three words'')
''num word num words num words''
|
同样可以用以下方法，并指定 count 为 1（只替换第一个）：
>>> p.sub( ''num'', '' one word two words three words'', count=1)
'' num word two words three words''
subn
re.subn(pattern, repl, string[, count, flags])
该函数的功能和 sub () 相同，但它还返回新的字符串以及替换的次数。同样 RegexObject 有：
subn(repl, string[, count=0])
实例分析 - 使用 re 模块实现美剧时间表
这一章节将描述使用 re 模块进行文本解析并实现美剧播出时间表小工具的细节。我们会引用实际的代码片段，解释在实际程序中，应当如何使用 re 模块实现文本解析的功能。
需求分析
为了将我们感兴趣的信息全部提取出来渲染到一个单独的页面上，我们选取 www.tv.com 的 html 作为数据源，获取到其 HTML 文本之后用正则表达式解析并获得相关内容。
请注意用正则表达式分析 HTML 或 XML 是痛苦的。随处可见的变化使得写出一个通用的正则表达式变得极为困难，象这样的任务使用专用的 HTML 或 XML 解析器更为适宜 (如 http://www.crummy.com/software/BeautifulSoup/， 值得一提的是，这个解析器也是用 Python RE 实现的)，为了演示 Python RE 的使用，本文全部使用正则表达式处理文本。
实现步骤
因为此工具的最后结果会被呈现在一个网页上，它的主要功能就是从上述的 html code 中提取出我们感兴趣的 element, 并按照我们自己的对内容的选择重新生成一个个性化过的页面，请参见附件查看我们将要解析的 html 文本。
通过检视此 html 文件，我们需要提取的 html element 只有被 head 标签修饰的文档信息元素，和被 div 标签修饰，id 值为 episode_listing 的块级区域。
下面对实现这部分功能的主要代码进行一些分析。
以只读方式打开所需处理文本并读入其内容：
|
1
2
|
fh = open("~/vampire_episode.html", "r")
fh_str = fd.read()
|
读取剧集标题，使用正则表达式匹配以 “<title” 起始，“/title>” 结束的元素，注意此处使用非贪婪匹配以获取首次匹配的内容：
|
1
|
title = re.findall("<
title.
*?\/title>", fds)
|
查看一下变量类型和内容：
|
1
2
3
4
5
6
7
|
In [74]: type(title)
Out[74]: <
type
''list''>
In [75]: print title
-------> print(title)
[''<
title
>The Vampire Diaries Season 2 Episode Guide on TV.com</
title
>'']
|
读取 html 文本中 id 值为 episode_listing 的 div 元素，注意由于此元素会跨越多行，我们在调用 findall 函数时需要指定 re.S 标志，同样使用非贪婪匹配：
fd_result = re.findall("<div id=\"episode_listing\".*?\/div>", fh_str, re.S)
此时我们已经获取到全部所需内容，将他们写入另一个 html 文件：
|
1
2
3
4
5
6
7
|
output = open("parse_result.html", "w")
output.write(''<
html
><
body
><
h1
>The Air Date List you want to see:</
h1
>'')
output.write(''<
br
/>'')
output.write(title[0])
output.write(fd_result[0])
output.write("</
body
></
html
>")
output.close()
|
结果演示
本章节将演示实例效果，展示最终可以显示在网页上的运行结果，我们将看到解析获得的美剧时间表，剧集标题等。为此我们在 Google App Engine 上创建了一个 Demo 示例以更好的对此本文所介绍的内容进行演示，读者可以直接访问使用。示例的网址如下：
http://omtvdw.appspot.com/
下面我们用截图来说明该示例的内容。该示例主要展示了对给定的包含美剧信息的 URL 所截取出来的剧集播放信息，如下图所示本示例展示如下三部美剧的信息：
图 1. 美剧信息 URL
其输出结果如下：
图 2-1. URL 所对应剧集播出时间表
图 2-2. URL 所对应剧集播出时间表
图 2-3. URL 所对应剧集播出时间表
另外，我们还为读者提供了亲自体验的 Play Ground，读者可以通过点击主页面最下方的相关链接（http://omtvdw.appspot.com/pg）来到如下界面：
图 3. 自行获取指定美剧播出时间界面
在此界面里，读者可以自行输入含有美剧播出信息的相关页面的链接，然后查看输出结果。例如我们输入 http://www.tv.com/24/show/3866/episode.html?shv=list&season=5，然后点击 “Get Air Date List” 就会看到关于 24 小时第五季的播出信息：
图 4. 运行结果
读者可以自行试验获取其他美剧的信息，但是需要自己从 www.tv.com 上找到类似的 URL。
小结
尽管对于 Python 正则表达式模块（re）的语法和相关函数的描述并不全面，但文章以简洁的方式介绍了最常用的正则表达式语法和函数调用方法，关于更为复杂和深入的用法讨论，读者可以参考官方文档。在之后的章节中，本文直观地通过网页文本解析的实例，讲解了美剧播出时间解析小工具的实现方法和步骤，希望最后的网站示例和演示结果能够提供给这一模块的功能学习提供一些有趣并有用的帮助。
正则表达式 (regular expression) 描述了一种字符串匹配的模式（pattern），可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。
例如：
-
runoo+b，可以匹配 runoob、runooob、runoooooob 等，+ 号代表前面的字符必须至少出现一次（1 次或多次）。
-
runoo*b，可以匹配 runob、runoob、runoooooob 等，* 号代表字符可以不出现，也可以出现一次或者多次（0 次、或 1 次、或多次）。
-
colou?r 可以匹配 color 或者 colour，? 问号代表前面的字符最多只可以出现一次（0 次、或 1 次）。
构造正则表达式的方法和创建数学表达式的方法一样。也就是用多种元字符与运算符可以将小的表达式结合在一起来创建更大的表达式。正则表达式的组件可以是单个的字符、字符集合、字符范围、字符间的选择或者所有这些组件的任意组合。
正则表达式是由普通字符（例如字符 a 到 z）以及特殊字符（称为 "元字符"）组成的文字模式。模式描述在搜索文本时要匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。
普通字符
普通字符包括没有显式指定为元字符的所有可打印和不可打印字符。这包括所有大写和小写字母、所有数字、所有标点符号和一些其他符号。
非打印字符
非打印字符也可以是正则表达式的组成部分。下表列出了表示非打印字符的转义序列：
| 字符 | 描述 |
|---|---|
| \cx | 匹配由 x 指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 ''c'' 字符。 |
| \f | 匹配一个换页符。等价于 \x0c 和 \cL。 |
| \n | 匹配一个换行符。等价于 \x0a 和 \cJ。 |
| \r | 匹配一个回车符。等价于 \x0d 和 \cM。 |
| \s | 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [\f\n\r\t\v]。注意 Unicode 正则表达式会匹配全角空格符。 |
| \S | 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。 |
| \t | 匹配一个制表符。等价于 \x09 和 \cI。 |
| \v | 匹配一个垂直制表符。等价于 \x0b 和 \cK。 |
特殊字符
所谓特殊字符，就是一些有特殊含义的字符，如上面说的 runoo*b 中的 *，简单的说就是表示任何字符串的意思。如果要查找字符串中的 * 符号，则需要对 * 进行转义，即在其前加一个 \: runo\*ob 匹配 runo*ob。
许多元字符要求在试图匹配它们时特别对待。若要匹配这些特殊字符，必须首先使字符 "转义"，即，将反斜杠字符 \ 放在它们前面。下表列出了正则表达式中的特殊字符：
| 特别字符 | 描述 |
|---|---|
| $ | 匹配输入字符串的结尾位置。如果设置了 RegExp 对象的 Multiline 属性，则 $ 也匹配 ''\n'' 或 ''\r''。要匹配 $ 字符本身，请使用 \$。 |
| ( ) | 标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 。 |
| * | 匹配前面的子表达式零次或多次。要匹配 * 字符，请使用 \*。 |
| + | 匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 \+。 |
| . | 匹配除换行符 \n 之外的任何单字符。要匹配 . ，请使用 \. 。 |
| [ | 标记一个中括号表达式的开始。要匹配 [，请使用 \[。 |
| ? | 匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配？字符，请使用 \?。 |
| \ | 将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。例如， ''n'' 匹配字符 ''n''。''\n'' 匹配换行符。序列 ''\\'' 匹配 "\"，而 ''\('' 则匹配 "("。 |
| ^ | 匹配输入字符串的开始位置，除非在方括号表达式中使用，此时它表示不接受该字符集合。要匹配 ^ 字符本身，请使用 \^。 |
| { | 标记限定符表达式的开始。要匹配 {，请使用 \{。 |
| | | 指明两项之间的一个选择。要匹配 |，请使用 \|。 |
限定符
限定符用来指定正则表达式的一个给定组件必须要出现多少次才能满足匹配。有 * 或 + 或 ? 或 {n} 或 {n,} 或 {n,m} 共 6 种。
正则表达式的限定符有：
| 字符 | 描述 |
|---|---|
| * | 匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于 {0,}。 |
| + | 匹配前面的子表达式一次或多次。例如，''zo+'' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。 |
| ? | 匹配前面的子表达式零次或一次。例如，"do (es)?" 可以匹配 "do" 、 "does" 中的 "does" 、 "doxy" 中的 "do" 。? 等价于 {0,1}。 |
| {n} | n 是一个非负整数。匹配确定的 n 次。例如，''o {2}'' 不能匹配 "Bob" 中的 ''o''，但是能匹配 "food" 中的两个 o。 |
| {n,} | n 是一个非负整数。至少匹配 n 次。例如，''o {2,}'' 不能匹配 "Bob" 中的 ''o''，但能匹配 "foooood" 中的所有 o。''o {1,}'' 等价于 ''o+''。''o {0,}'' 则等价于 ''o*''。 |
| {n,m} | m 和 n 均为非负整数，其中 n <= m。最少匹配 n 次且最多匹配 m 次。例如，"o {1,3}" 将匹配 "fooooood" 中的前三个 o。''o {0,1}'' 等价于 ''o?''。请注意在逗号和两个数之间不能有空格。 |
由于章节编号在大的输入文档中会很可能超过九，所以您需要一种方式来处理两位或三位章节编号。限定符给您这种能力。下面的正则表达式匹配编号为任何位数的章节标题：
/Chapter [1-9][0-9]*/请注意，限定符出现在范围表达式之后。因此，它应用于整个范围表达式，在本例中，只指定从 0 到 9 的数字（包括 0 和 9）。
这里不使用 + 限定符，因为在第二个位置或后面的位置不一定需要有一个数字。也不使用？字符，因为使用？会将章节编号限制到只有两位数。您需要至少匹配 Chapter 和空格字符后面的一个数字。
如果您知道章节编号被限制为只有 99 章，可以使用下面的表达式来至少指定一位但至多两位数字。
/Chapter [0-9]{1,2}/上面的表达式的缺点是，大于 99 的章节编号仍只匹配开头两位数字。另一个缺点是 Chapter 0 也将匹配。只匹配两位数字的更好的表达式如下：
/Chapter [1-9][0-9]?/或
/Chapter [1-9][0-9]{0,1}/*、+ 限定符都是贪婪的，因为它们会尽可能多的匹配文字，只有在它们的后面加上一个？就可以实现非贪婪或最小匹配。
例如，您可能搜索 HTML 文档，以查找括在 H1 标记内的章节标题。该文本在您的文档中如下：
<H1>Chapter 1 - 介绍正则表达式</H1>贪婪：下面的表达式匹配从开始小于符号 (<) 到关闭 H1 标记的大于符号 (>) 之间的所有内容。
/<.*>/非贪婪：如果您只需要匹配开始和结束 H1 标签，下面的非贪婪表达式只匹配 <H1>。
/<.*?>/如果只想匹配开始的 H1 标签，表达式则是：
/<\w+?>/通过在 *、+ 或 ? 限定符之后放置 ?，该表达式从 "贪心" 表达式转换为 "非贪心" 表达式或者最小匹配。
定位符
定位符使您能够将正则表达式固定到行首或行尾。它们还使您能够创建这样的正则表达式，这些正则表达式出现在一个单词内、在一个单词的开头或者一个单词的结尾。
定位符用来描述字符串或单词的边界，^ 和 $ 分别指字符串的开始与结束，\b 描述单词的前或后边界，\B 表示非单词边界。
正则表达式的定位符有：
| 字符 | 描述 |
|---|---|
| ^ | 匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性，^ 还会与 \n 或 \r 之后的位置匹配。 |
| $ | 匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性，$ 还会与 \n 或 \r 之前的位置匹配。 |
| \b | 匹配一个单词边界，即字与空格间的位置。 |
| \B | 非单词边界匹配。 |
注意：不能将限定符与定位符一起使用。由于在紧靠换行或者单词边界的前面或后面不能有一个以上位置，因此不允许诸如 ^* 之类的表达式。
若要匹配一行文本开始处的文本，请在正则表达式的开始使用 ^ 字符。不要将 ^ 的这种用法与中括号表达式内的用法混淆。
若要匹配一行文本的结束处的文本，请在正则表达式的结束处使用 $ 字符。
若要在搜索章节标题时使用定位点，下面的正则表达式匹配一个章节标题，该标题只包含两个尾随数字，并且出现在行首：
/^Chapter [1-9][0-9]{0,1}/真正的章节标题不仅出现行的开始处，而且它还是该行中仅有的文本。它即出现在行首又出现在同一行的结尾。下面的表达式能确保指定的匹配只匹配章节而不匹配交叉引用。通过创建只匹配一行文本的开始和结尾的正则表达式，就可做到这一点。
/^Chapter [1-9][0-9]{0,1}$/匹配单词边界稍有不同，但向正则表达式添加了很重要的能力。单词边界是单词和空格之间的位置。非单词边界是任何其他位置。下面的表达式匹配单词 Chapter 的开头三个字符，因为这三个字符出现在单词边界后面：
/\bCha/\b 字符的位置是非常重要的。如果它位于要匹配的字符串的开始，它在单词的开始处查找匹配项。如果它位于字符串的结尾，它在单词的结尾处查找匹配项。例如，下面的表达式匹配单词 Chapter 中的字符串 ter，因为它出现在单词边界的前面：
/ter\b/下面的表达式匹配 Chapter 中的字符串 apt，但不匹配 aptitude 中的字符串 apt：
/\Bapt/字符串 apt 出现在单词 Chapter 中的非单词边界处，但出现在单词 aptitude 中的单词边界处。对于 \B 非单词边界运算符，位置并不重要，因为匹配不关心究竟是单词的开头还是结尾。
选择
用圆括号将所有选择项括起来，相邻的选择项之间用 | 分隔。但用圆括号会有一个副作用，使相关的匹配会被缓存，此时可用？: 放在第一个选项前来消除这种副作用。
其中 ?: 是非捕获元之一，还有两个非捕获元是 ?= 和 ?!，这两个还有更多的含义，前者为正向预查，在任何开始匹配圆括号内的正则表达式模式的位置来匹配搜索字符串，后者为负向预查，在任何开始不匹配该正则表达式模式的位置来匹配搜索字符串。
反向引用
对一个正则表达式模式或部分模式两边添加圆括号将导致相关匹配存储到一个临时缓冲区中，所捕获的每个子匹配都按照在正则表达式模式中从左到右出现的顺序存储。缓冲区编号从 1 开始，最多可存储 99 个捕获的子表达式。每个缓冲区都可以使用 \n 访问，其中 n 为一个标识特定缓冲区的一位或两位十进制数。
可以使用非捕获元字符 ?:、?= 或 ?! 来重写捕获，忽略对相关匹配的保存。
反向引用的最简单的、最有用的应用之一，是提供查找文本中两个相同的相邻单词的匹配项的能力。以下面的句子为例：
Is is the cost of of gasoline going up up?上面的句子很显然有多个重复的单词。如果能设计一种方法定位该句子，而不必查找每个单词的重复出现，那该有多好。下面的正则表达式使用单个子表达式来实现这一点：
实例
查找重复的单词：
尝试一下 »
捕获的表达式，正如 [a-z]+ 指定的，包括一个或多个字母。正则表达式的第二部分是对以前捕获的子匹配项的引用，即，单词的第二个匹配项正好由括号表达式匹配。\1 指定第一个子匹配项。
单词边界元字符确保只检测整个单词。否则，诸如 "is issued" 或 "this is" 之类的词组将不能正确地被此表达式识别。
正则表达式后面的全局标记 g 指定将该表达式应用到输入字符串中能够查找到的尽可能多的匹配。
表达式的结尾处的不区分大小写 i 标记指定不区分大小写。
多行标记指定换行符的两边可能出现潜在的匹配。
反向引用还可以将通用资源指示符 (URI) 分解为其组件。假定您想将下面的 URI 分解为协议（ftp、http 等等）、域地址和页 / 路径：
http://www.runoob.com:80/html/html-tutorial.html下面的正则表达式提供该功能：
实例
输出所有匹配的数据：
尝试一下 »
第三行代码 str.match (patt1) 返回一个数组，实例中的数组包含 5 个元素，索引 0 对应的是整个字符串，索引 1 对应第一个匹配符（括号内），以此类推。
第一个括号子表达式捕获 Web 地址的协议部分。该子表达式匹配在冒号和两个正斜杠前面的任何单词。
第二个括号子表达式捕获地址的域地址部分。子表达式匹配 : 和 / 之后的一个或多个字符。
第三个括号子表达式捕获端口号（如果指定了的话）。该子表达式匹配冒号后面的零个或多个数字。只能重复一次该子表达式。
最后，第四个括号子表达式捕获 Web 地址指定的路径和 / 或页信息。该子表达式能匹配不包括 # 或空格字符的任何字符序列。
将正则表达式应用到上面的 URI，各子匹配项包含下面的内容：
- 第一个括号子表达式包含 http
- 第二个括号子表达式包含 www.runoob.com
- 第三个括号子表达式包含 :80
- 第四个括号子表达式包含 /html/html-tutorial.html
3.2 re--正则表达式操作（Regular expression operations）
本模块提供了正则表达式的匹配操作，它的功能跟Perl语言里的功能一样。
无论是Unicode字符串还是单字节8位组成的字符串，都可以使用模式匹配和字符串查找的功能。不过要注意的是Unicode字符串与8位的字符串不能混合使用，也就是说你不能在Unicode里去匹配单字节的模式，或者其它查找的功能。同样也不能在不同类型的字符串里相互替换字符串。
正则表达式使用反斜线（‘\’）来指定特定的格式的意义，或者是允许使用特定的字符。为了解决使用反斜线（‘\’），它的解决方法跟在字符串格式化里使用一样的方案。比如想匹配双反斜线（‘\\’），就需要使用’\\\\’的格式，因为每两个双反斜线（‘\\’）表示一个斜线。
不过，也可以使用另外一种方法来表示正则表达式的字符串，不用这么麻烦的方法，那就是使用‘r’字符开头来表示原始字符串处理。比如写成r’\n’就是表示两个字符：\和n的字符串，如果没有r开头的字符串’\n’则是表示一个字符的字符串，它表示换行字符。
有一点是要注意的，所有正则表达式的相关函数和方法都在编译正则表达式的对象那节里，但并不是说这些函数和方法需要编译正则表达式才可以使用，而是直接可以使用，不过会有一些性能上损失，或者要多输入一些参数。
蔡军生 QQ:9073204 深圳
ABAP 正则表达式（Regular Expressions）
正则表达式（Regular Expressions）
正则表达式在其他编程语言中的应用非常广泛，网上资料也非常多，而网上在ABAP语言中应用的资料却很少，尽管各语言中正则表达式语法知识都很类似，但仍然有一些区别，本文主要是简单介绍一下其基本语法。总结一下，方便大家查阅。
欢迎转载，请注明出处，文中不足之处还望指正。（Email：hubin0809@126.com）
一、简要认识
正则表达式就是用一个“字符串”来描述一个特征，然后去验证另一个“字符串”是否符合这个特征。比如表达式“ab+” 描述的特征是“一个 'a' 和任意个 'b' ”，那么 'ab','abb','abbbbbbbbbb' 都符合这个特征。
正则表达式可以用来：（1）验证字符串是否符合指定特征，比如验证是否是合法的邮件地址。（2）用来查找字符串，从一个长的文本中查找符合指定特征的字符串，比查找固定字符串更加灵活方便。（3）用来替换，比普通的替换更强大。
举例
| DATA:matcherTYPEREFTOcl_abap_matcher, |
| 输出结果：X |
解释：
1> '\w+@\w+(\.\w+)+'中 \w 是表示任意一个字母或数字或下划线，+ 表示前面字符个数为一个或多个，@即为’@’字符
2> matcher参照类cl_abap_matcher，match有匹配的意思，调用静态方法create创建了匹配的对（暂时这么理解，好吧，我承认我不知道怎么形容），然后调用match方法，返回值中’X’表示匹配，SPACE表示不匹配。
具体含义后面会讲到，本程序主要是验证邮件地址是否合法。
二、语法规则
pattern模板，text要匹配的字符，match匹配结果，’X’表示匹配，SPACE表示不匹配。
1、普通字符
字母、数字、汉字、下划线、以及后面没有特殊定义的标点符号，都是"普通字符"。表达式中的普通字符，在匹配一个字符串的时候，匹配与之相同的一个字符。
| Pattern |
Text |
Match |
| A |
X |
|
| a |
- |
|
| AB |
X |
2、转义字符
一些不便书写的字符，采用在前面加 "\" 的方法。例如’.’
| 表达式 |
可匹配 |
| \\ |
代表 "\" 本身 |
| \. |
匹配小数点（.）本身 |
| \Q...\E |
中间的字符作为普通字符 |
| Pattern |
Match |
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| .\. |
f. |
X |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| f\f |
- |
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| \w\d |
\w\d |
\\w\\d |
\Q\w\d\E |
3、能够与 '多种字符'匹配的表达式
正则表达式中的一些表示方法，可以匹配 '多种字符' 其中的任意一个字符。比如，表达式 "\d" 可以匹配任意一个数字。虽然可以匹配其中任意字符，但是只能是一个，不是多个。这就好比玩扑克牌时候，大小王可以代替任意一张牌，但是只能代替一张牌。（没玩过？好吧，去玩qq够级吧，ok，信息泄露了，承认我是山东人）
\d |
9 |
25 |
- |
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| \d\d |
\w |
\s |
\n |
... |
4zF |
4、自定义能够与 '多种字符'匹配的表达式
使用方括号 [ ] 包含一系列字符，能够匹配其中任意一个字符。用 [^ ] 包含一系列字符，则能够匹配其中字符之外的任意一个字符。同样的道理，虽然可以匹配其中任意一个，但是只能是一个，不是多个。
[abc] |
abc |
[^abc]b |
cb |
[a-g]b |
5、支持的 POSIX字符集合
个人感觉意义不大，可能对一些控制字符有用吧，了解。
[[:alnum:]] |
[:lower:][:digit:] |
a9 |
[[:lower:][:digit:]] |
b |
6、修饰匹配次数的特殊符号
前面讲到的表达式，无论是只能匹配一种字符的表达式，还是可以匹配多种字符其中任意一个的表达式，都只能匹配一次。如果使用表达式再加上修饰匹配次数的特殊符号，那么不用重复书写表达式就可以重复匹配，否则会累死的。
[abc]{3} |
bca |
.{3,5} |
abcd |
\d{5,} |
12345 |
a*b |
a+b |
- |
7、其他一些代表抽象意义的特殊符号
^
与字符串开始的地方匹配，不匹配任何字符
$
与字符串结束的地方匹配，不匹配任何字符
\b
匹配一个单词边界，也就是单词和空格之间的位置，不匹配任何字符
|
左右两边表达式之间 "或" 关系，匹配左边或者右边
( )
(1). 在被修饰匹配次数的时候，括号中的表达式可以作为整体被修饰
(2). 取匹配结果的时候，括号中的表达式匹配到的内容可以被单独得到
(?: )
匹配pattern但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。
进一步的文字说明仍然比较抽象，因此，举例帮助大家理解。
举例1：表达式 "^aaa" 在匹配 "xxx aaa xxx" 时，匹配结果是：失败。因为 "^" 要求与字符串开始的地方匹配，因此，只有当 "aaa" 位于字符串的开头的时候，"^aaa" 才能匹配，比如："aaa xxx xxx"。
举例2：表达式 "aaa$" 在匹配 "xxx aaa xxx" 时，匹配结果是：失败。因为 "$" 要求与字符串结束的地方匹配，因此，只有当 "aaa" 位于字符串的结尾的时候，"aaa$" 才能匹配，比如："xxx xxx aaa"。
举例3：表达式 ".\b." 在匹配 "@@@abc" 时，能够找到匹配的内容；匹配到的内容是："@a"；匹配到的位置是：开始于2，结束于4。
进一步说明："\b" 与 "^" 和 "$" 类似，本身不匹配任何字符，但是它要求它在匹配结果中所处位置的左右两边，其中一边是 "\w" 范围，另一边是 非"\w" 的范围。
举例4：表达式 "\bend\b" 在匹配 "weekend,endfor,end" 时，能够找到匹配的内容；匹配到的内容是："end"；匹配到的位置是：开始于15，结束于18。
| Pattern |
Match |
||||||||
| (.{1,3})|(.{5,}) |
bcade |
三、正则表达式中的一些高级规则(ABAP部分支持)
1、 匹配次数中的贪婪与非贪婪贪婪模式： 在使用修饰匹配次数的特殊符号时，有几种表示方法可以使同一个表达式能够匹配不同的次数，比如："{m,n}","{m,}","?","*","+"，具体匹配的次数随被匹配的字符串而定。这种重复匹配不定次数的表达式在匹配过程中，总是尽可能多的匹配。比如，针对文本 "dxxxdxxxd"，举例如下：
由此可见，"\w+" 在匹配的时候，总是尽可能多的匹配符合它规则的字符。虽然第二个举例中，它没有匹配最后一个 "d"，但那也是为了让整个表达式能够匹配成功。同理，带 "*" 和 "{m,n}" 的表达式都是尽可能地多匹配，带 "?" 的表达式在可匹配可不匹配的时候，也是尽可能的 "要匹配"。这种匹配原则就叫作 "贪婪" 模式 。 非贪婪模式：（ABAP暂时不支持，但是最好理解吧） (d)(\w+?) |
"\w+?" 将尽可能少的匹配第一个 "d" 之后的字符，结果是："\w+?" 只匹配了一个 "x" |
||||||
| (d)(\w+?)(d) |
为了让整个表达式匹配成功，"\w+?" 不得不匹配 "xxx" 才可以让后边的 "d" 匹配，从而使整个表达式匹配成功。因此，结果是："\w+?" 匹配 "xxx" |
Grep命令中正则表达式（regular Expressions,RE)的用法
当你在使用grep命令的时候肯定会用到正则表达式，那么怎么在grep命令中使用正则表达式呢？
正则表达式元字符
grep命令支持很多正则表达式的元字符，以使用户能够更精准的定义要查找的模式。例如，可以通过制定的选项来关闭大小写敏感，要求显示行号等。
| 元字符 | 功能 | 示例 | 匹配对象 |
| ^ | 行首定位符 | ‘^user' | 匹配所有以user开头的行 |
| $ | 行尾定位符 | ’user$' | 匹配所以以user结尾的行 |
| 。 | 匹配一个字符 | ‘u.r' | 匹配包含一个u,后跟一个字符，再跟一个r的行 |
| * | 匹配两个或多个前导字符 | ’u*ser' | 匹配包含零个或多个u后，跟ser模式的行 |
| [] | 匹配一组字符中的人一个 | ‘[uU]ser' | 匹配包含user或者User的行 |
| [^] | 匹配不在指定字符组里的字符 | ’[^A-S]ser‘ | 匹配一个不在A到S之间的字符，并且该字符后紧跟着ser的行 |
| \< | 词首定位符 | ’\<user‘ | 匹配包含以user开头的词的行 |
| \> | 词尾定位符 | ’user\>‘ | 匹配包含以user结尾的词的行 |
| \<..\> | 标记匹配到的字符 | ’\<user\>' | 匹配包含<user>的行 |
| {M}{M,}{M,N} | 匹配重复出现的次数M次匹配出现的次数至少M次 匹配出现的次数至少M次，但不超过N次 |
'u\{4\}u\{5\} u\{5,8\}' |
匹配连续出现4个u的行匹配连续出现最少5个u的行 匹配连续出现最少5个，最多8个u的行 |
grep 正则表达式示例：
在/etc/passwd 里查找包含“user1“字符串的行
[root@devops~]#grepuser1/etc/passwd user1:x:502:503::/home/user1:/bin/bash
如果想忽略大小写的区做搜索可以使用-i选项
#grepuser1/etc/passwd
你可以使用"."元字符为一个单个的字符做匹配，例如我们可以使用下面的命令去匹配一个以”u"开头，以“r”结尾，中间是任意一个字符的行
[root@devops~]#grep'\<u.r\>'/etc/passwd game:x:12:100:games:/usr/games:/sbin/nologin
如何在grep正则表达式中准确的匹配所有包含两个字符的行？
[root@devops~]#grep'^..$'/
iphone – NSPredicate和NSRegularExpression
这是我的代码：
Nsstring *regexString = [Nsstring stringWithFormat:@"%@_[0-9]+",value];
NSRegularExpression *regex = [NSRegularExpression regularExpressionWithPattern:regexString
options:NSRegularExpressionSearch
error:&error];
nspredicate *predicate = [nspredicate predicateWithFormat:@"(label = %@) OR (label = %@)",value,regex];
value是一个字符串,label是实体的键.
如果value是“New Project”,则NSFetchRequest返回一个包含一个对象的数组,但是,我的模型中有两个标签(“New Project”和“New Project_1”)应该被提取.
我究竟做错了什么？
解决方法
今天关于Python 模块 re 和Regular Expression的介绍到此结束，谢谢您的阅读，有关3.2 re--正则表达式操作（Regular expression operations）、ABAP 正则表达式（Regular Expressions）、Grep命令中正则表达式（regular Expressions,RE)的用法、iphone – NSPredicate和NSRegularExpression等更多相关知识的信息可以在本站进行查询。
本文标签：
