Chinaunix首页 | 论坛 | 博客
  • 博客访问: 291910
  • 博文数量: 46
  • 博客积分: 528
  • 博客等级: 中士
  • 技术积分: 486
  • 用 户 组: 普通用户
  • 注册时间: 2012-05-20 15:36
文章分类

全部博文(46)

文章存档

2017年(1)

2015年(8)

2014年(2)

2013年(19)

2012年(16)

分类: Python/Ruby

2013-06-04 12:13:01

原文地址:Python 正则表达式 作者:huaius

元字符

首先来看一下正则表达式的一些基本的用法,元字符。这些规则在很多环境下都是通用的,比如在Perl中的正则表达式。
. ^ $ * + ? { [ ] \ | ( )
这里需要着重的给出"[]"的使用方法,因为有些细节相信很多人不是很清楚:
  1. [abc] 将匹配"a", "b","c"中的任意一个字符;
  2. 也可以用区间[a-c]来表示同一字符集.

  3. 元字符在类别里并不起作用。例如,[akm$]将匹配字符"a", "k", "m","$" 中的任意一个;"$"通常用作元字符,但在字符类别里,其特性被除去,恢复成普通字符。

  4. 你可以用补集来匹配不在区间范围内的字符。其做法是把"^"作为类别的首个字符;其它地方的"^"只会简单匹配 "^"字符本身。例如,[^5] 将匹配除 "5" 之外的任意字符。

  5. \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_]。

    这样特殊字符都可以包含在一个字符类中。如,[\s,.]字符类将匹配任何空白字符或","或"."。

开始使用re

Python通过re模块提供对正则表达式的支持。使用re的一般步骤是先将正则表达式的字符串形式编译为Pattern实例,然后使用Pattern实例处理文本并获得匹配结果(一个Match实例),最后使用Match实例获得信息,进行其他的操作。

  1. import re
  2.  
  3. # 将正则表达式编译成Pattern对象
  4. pattern = re.compile(r'hello')
  5.  
  6. # 使用Pattern匹配文本,获得匹配结果,无法匹配时将返回None
  7. match = pattern.match('hello world!')
  8.  
  9. if match:
  10.     # 使用Match获得分组信息
  11.     print match.group()
  12.  
  13. ### 输出 ###
  14. # hello

反斜杠的困扰 -- 为什么要用r''

RE 被做为一个字符串发送给 re.compile()。REs 被处理成字符串是因为正则表达式不是 Python 语言的核心部分,也没有为它创建特定的语法。(应用程序根本就不需要 REs,因此没必要包含它们去使语言说明变得臃肿不堪。)而 re 模块则只是以一个 C 扩展模块的形式来被 Python 包含,就象 socket 或 zlib 模块一样. 将 REs 作为字符串以保证 Python 语言的简洁,但这样带来的一个麻烦就是象标题所讲的。
在早期规定中,正则表达式用反斜杠字符 ("\") 来表示特殊格式或允许使用特殊字符而不调用它的特殊用法。这就与 Python 在字符串中的那些起相同作用的相同字符产生了冲突。

让我们举例说明,你想写一个 RE 以匹配字符串 "\section",可能是在一个 LATEX 文件查找。为了要在程序代码中判断,首先要写出想要匹配的字符串。接下来你需要在所有反斜杠和其它元字符前加反斜杠来取消其特殊意义,结果要匹配的字符串就成了"\\section"。 当把这个字符串传递给re.compile()时必须还是"\\section"。然而,作为Python的字符串实值(string literals)来表示的话,"\\section"中两个反斜杠还要再次取消特殊意义,最后结果就变成了"\\\\section"。

\section 要匹配的字符串
\\section 为 re.compile 取消反斜杠的特殊意义
"\\\\section" 为"\\section"的字符串实值(string literals)取消反斜杠的特殊意义

简单地说,为了匹配一个反斜杠,不得不在 RE 字符串中写 '\\\\',因为正则表达式中必须是 "\\",而每个反斜杠在常规的 Python 字符串实值中必须表示成 "\\"。在 REs 中反斜杠的这个重复特性会导致大量重复的反斜杠,而且所生成的字符串也很难懂。
解决的办法就是为正则表达式使用 Python 的 raw 字符串表示;在字符串前加个 "r" 反斜杠就不会被任何特殊方式处理,所以 r"\n" 就是包含"\" 和 "n" 的两个字符,而 "\n" 则是一个字符,表示一个换行。正则表达式通常在 Python 代码中都是用这种 raw 字符串表示。

re.compile(strPattern[, flag]):

这个方法是Pattern类的工厂方法,用于将字符串形式的正则表达式编译为Pattern对象。 第二个参数flag是匹配模式,取值可以使用按位或运算符'|'表示同时生效,比如re.I | re.M。另外,你也可以在regex字符串中指定模式,比如re.compile('pattern', re.I | re.M)与re.compile('(?im)pattern')是等价的。 
可选值有:
    • re.I(re.IGNORECASE): 忽略大小写(括号内是完整写法,下同)
    • M(MULTILINE): 多行模式,改变'^'和'$'的行为(参见上图)
    • S(DOTALL): 点任意匹配模式,改变'.'的行为
    • L(LOCALE): 使预定字符类 \w \W \b \B \s \S 取决于当前区域设定
    • U(UNICODE): 使预定字符类 \w \W \b \B \s \S \d \D 取决于unicode定义的字符属性
    • X(VERBOSE): 详细模式。这个模式下正则表达式可以是多行,忽略空白字符,并可以加入注释。以下两个正则表达式是等价的:
  1. a = re.compile(r"""d + # the integral part
  2.                    . # the decimal point
  3.                    d * # some fractional digits""", re.X)
  4. b = re.compile(r"d+.d*")
re模块还提供了一个方法escape(string),用于将string中的正则表达式元字符如*/+/?等之前加上转义符再返回,在需要大量匹配元字符时有那么一点用。

Match

Match对象是一次匹配的结果,包含了很多关于此次匹配的信息,可以使用Match提供的可读属性或方法来获取这些信息。

属性:

  • string: 匹配时使用的文本。
  • re: 匹配时使用的Pattern对象。
  • pos: 文本中正则表达式开始搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。
  • endpos: 文本中正则表达式结束搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。
  • lastindex: 最后一个被捕获的分组在文本中的索引。如果没有被捕获的分组,将为None。
  • lastgroup: 最后一个被捕获的分组的别名。如果这个分组没有别名或者没有被捕获的分组,将为None。

方法:

  • group([group1, …]): 获得一个或多个分组截获的字符串;指定多个参数时将以元组形式返回。group1可以使用编号也可以使用别名;编号0代表整个匹配的子串;不填写参数时,返回group(0);没有截获字符串的组返回None;截获了多次的组返回最后一次截获的子串。
  • groups([default]): 以元组形式返回全部分组截获的字符串。相当于调用group(1,2,…last)。default表示没有截获字符串的组以这个值替代,默认为None。
  • groupdict([default]): 返回以有别名的组的别名为键、以该组截获的子串为值的字典,没有别名的组不包含在内。default含义同上。
  • start([group]): 返回指定的组截获的子串在string中的起始索引(子串第一个字符的索引)。group默认值为0。
  • end([group]): 返回指定的组截获的子串在string中的结束索引(子串最后一个字符的索引+1)。group默认值为0。
  • span([group]): 返回(start(group), end(group))。
  • expand(template): 将匹配到的分组代入template中然后返回。template中可以使用\id或\g、\g引用分组,但不能使用编号0。\id与\g是等价的;但\10将被认为是第10个分组,如果你想表达\1之后是字符'0',只能使用\g0。

Pattern

Pattern对象是一个编译好的正则表达式,通过Pattern提供的一系列方法可以对文本进行匹配查找。
Pattern不能直接实例化,必须使用re.compile()进行构造。
Pattern提供了几个可读属性用于获取表达式的相关信息:
  • pattern: 编译时用的表达式字符串。
  • flags: 编译时用的匹配模式。数字形式。
  • groups: 表达式中分组的数量。
  • groupindex: 以表达式中有别名的组的别名为键、以该组对应的编号为值的字典,没有别名的组不包含在内。

实例方法[ | re模块方法]:

match(string[, pos[, endpos]]) | re.match(pattern, string[, flags]): 
这个方法将从string的pos下标处起尝试匹配pattern;如果pattern结束时仍可匹配,则返回一个Match对象;如果匹配过程中pattern无法匹配,或者匹配未结束就已到达endpos,则返回None。 需要注意的是,这个方法是决定 RE 是否在字符串刚开始的位置匹配
pos和endpos的默认值分别为0和len(string);re.match()无法指定这两个参数,参数flags用于编译pattern时指定匹配模式。 
注意:这个方法并不是完全匹配。当pattern结束时若string还有剩余字符,仍然视为成功。想要完全匹配,可以在表达式末尾加上边界匹配符'$'。 

search(string[, pos[, endpos]]) | re.search(pattern, string[, flags]): 
这个方法用于查找字符串中可以匹配成功的子串。从string的pos下标处起尝试匹配pattern,如果pattern结束时仍可匹配,则返回一个Match对象;若无法匹配,则将pos加1后重新尝试匹配;直到pos=endpos时仍无法匹配则返回None。 
pos和endpos的默认值分别为0和len(string));re.search()无法指定这两个参数,参数flags用于编译pattern时指定匹配模式。 

split(string[, maxsplit]) | re.split(pattern, string[, maxsplit]): 
按照能够匹配的子串将string分割后返回列表。maxsplit用于指定最大分割次数,不指定将全部分割。 

findall(string[, pos[, endpos]]) | re.findall(pattern, string[, flags]): 
搜索string,以列表形式返回全部能匹配的子串。 

finditer(string[, pos[, endpos]]) | re.finditer(pattern, string[, flags]): 
搜索string,返回一个顺序访问每一个匹配结果(Match对象)的迭代器。 

sub(repl, string[, count]) | re.sub(pattern, repl, string[, count]): 
使用repl替换string中每一个匹配的子串后返回替换后的字符串。 
当repl是一个字符串时,可以使用\id或\g、\g引用分组,但不能使用编号0。 
当repl是一个方法时,这个方法应当只接受一个参数(Match对象),并返回一个字符串用于替换(返回的字符串中不能再引用分组)。 
count用于指定最多替换次数,不指定时全部替换。 

subn(repl, string[, count]) |re.sub(pattern, repl, string[, count]): 
返回 (sub(repl, string[, count]), 替换次数)。 

更多模式功能

| 可选项,或者 "or" 操作符。如果 A 和 B 是正则表达式,A|B 将匹配任何匹配了 "A" 或 "B" 的字符串。| 的优先级非常低,是为了当你有多字符串要选择时能适当地运行。Crow|Servo 将匹配"Crow" 或 "Servo", 而不是 "Cro", 一个 "w" 或 一个 "S", 和 "ervo"。为了匹配字母 "|",可以用 \|,或将其包含在字符类中,如[|]。
^ 匹配行首。除非设置 MULTILINE 标志,它只是匹配字符串的开始。在 MULTILINE 模式里,它也可以直接匹配字符串中的每个换行。
$ 匹配行尾,行尾被定义为要么是字符串尾,要么是一个换行字符后面的任何位置。
\A 只匹配字符串首。当不在 MULTILINE 模式,\A 和 ^ 实际上是一样的。然而,在 MULTILINE 模式里它们是不同的;\A 只是匹配字符串首,而 ^ 还可以匹配在换行符之后字符串的任何位置。
\Z 只匹配字符串尾。
\b 单词边界。这是个零宽界定符(zero-width assertions)只用以匹配单词的词首和词尾。单词被定义为一个字母数字序列,因此词尾就是用空白符或非字母数字符来标示的。
\B 另一个零宽界定符(zero-width assertions),它正好同 \b 相反,只在当前位置不在单词边界时匹配。

通过下面的一个例子可以看出raw字符串显示模式的重要性:

点击(此处)折叠或打开

  1. 下面的例子只匹配 "class" 整个单词;而当它被包含在其他单词中时不匹配。

  2. #!python
  3. >>> p = re.compile(r'bclassb')
  4. >>> print p.search('no class at all')
  5. <re.MatchObject instance at 80c8f28>
  6. >>> print p.search('the declassified algorithm')
  7. None
  8. >>> print p.search('one subclass is')
  9. None

  10. 当用这个特殊序列时你应该记住这里有两个微妙之处。第一个是 Python 字符串和正则表达式之间最糟的冲突。在 Python 字符串里,"b" 是反斜杠字符,ASCII值是8。如果你没有使用 raw 字符串时,那么 Python 将会把 "b" 转换成一个回退符,你的 RE 将无法象你希望的那样匹配它了。下面的例子看起来和我们前面的 RE 一样,但在 RE 字符串前少了一个 "r"

  11. #!python
  12. >>> p = re.compile('bclassb')
  13. >>> print p.search('no class at all')
  14. None
  15. >>> print p.search('b' + 'class' + 'b')
  16. <re.MatchObject instance at 80c3ee0>

  17. 第二个在字符类中,这个限定符(assertion)不起作用,b 表示回退符,以便与 Python 字符串兼容。

分组

组是通过 "(" 和 ")" 元字符来标识的。 "(" 和 ")" 有很多在数学表达式中相同的意思;它们一起把在它们里面的表达式组成一组。举个例子,你可以用重复限制符,象 *, +, ?, 和 {m,n},来重复组里的内容,比如说(ab)* 将匹配零或更多个重复的 "ab"。
  1. #!python
  2. >>> p = re.compile('(ab)*')
  3. >>> print p.match('ababababab').span()
  4. (0, 10)
组用 "(" 和 ")" 来指定,并且得到它们匹配文本的开始和结尾索引;这就可以通过一个参数用 group()、start()、end() 和 span() 来进行检索。组是从 0 开始计数的。组 0 总是存在;它就是整个 RE,所以 `MatchObject` 的方法都把组 0 作为它们缺省的参数。

  1. #!python
  2. >>> p = re.compile('(a)b')
  3. >>> m = p.match('ab')
  4. >>> m.group()
  5. 'ab'
  6. >>> m.group(0)
  7. 'ab'
小组是从左向右计数的,从1开始。组可以被嵌套。计数的数值可以通过从左到右计算打开的括号数来确定。

  1. #!python
  2. >>> p = re.compile('(a(b)c)d')
  3. >>> m = p.match('abcd')
  4. >>> m.group(0)
  5. 'abcd'
  6. >>> m.group(1)
  7. 'abc'
  8. >>> m.group(2)
  9. 'b'
group() 可以一次输入多个组号,在这种情况下它将返回一个包含那些组所对应值的元组。

  1. #!python
  2. >>> m.group(2,1,2)
  3. ('b', 'abc', 'b')

  4. #The groups() 方法返回一个包含所有小组字符串的元组,从 1 到 所含的小组号。
  5. #!python
  6. >>> m.groups()
  7. ('abc', 'b')
模式中的逆向引用允许你指定先前捕获组的内容,该组也必须在字符串当前位置被找到。举个例子,如果组 1 的内容能够在当前位置找到的话,\1 就成功否则失败。记住 Python 字符串也是用反斜杠加数据来允许字符串中包含任意字符的,所以当在 RE 中使用逆向引用时确保使用 raw 字符串。

  1. #!python
  2. >>> p = re.compile(r'(bw+)s+1')
  3. >>> p.search('Paris in the the spring').group()
  4. 'the the'

贪婪与非贪婪

当重复一个正则表达式时,如用 a*,操作结果是尽可能多地匹配模式。当你试着匹配一对对称的定界符,如 HTML 标志中的尖括号时这个事实经常困扰你。匹配单个 HTML 标志的模式不能正常工作,因为 .* 的本质是“贪婪”的
在这种情况下,解决方案是使用不贪婪的限定符 *?、+?、?? 或 {m,n}?,尽可能匹配小的文本。在上面的例子里, ">" 在第一个 ""。这个处理将得到正确的结果:
  1. #!python
  2. #贪婪
  3. >>> s = 'Title'
  4. >>> len(s)
  5. 32
  6. >>> print re.match('', s).span()
  7. (0, 32)
  8. >>> print re.match('', s).group()
  9. <html><head><title>Title</title>

  10. #非贪婪
  11. #!python
  12. >>> print re.match('', s).group()
  13. <html>

阅读(1492) | 评论(0) | 转发(0) |
0

上一篇:Python 字符串处理

下一篇:Python os.stat 模块

给主人留下些什么吧!~~