python正则表达式

rger

    python正则表达式表


一、re模块
   python中处理正则表达式的一个模块，通过re模块的方法，把正则表达式pattern编译成正则
对象，以便使用正则对象的方法


1.格式参数
re.compile(pattern[, flags])


1）参数flag是匹配模式，取值可以使用按位或运算符“|”表示同时生效，比如：re.I | re.M
2）flag的可选值：
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)：        详细模式，正则表达式可以多行，忽略空白字符，可以加入注释

例子：
a和b等价
a = re.compile(r"""\d +  # the integral part
         \.    # the decimal point
         \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")


2.正则原生符r
   表示这个字符串中间的特殊字符不用转义，比如要表示‘\n’,可以这样：r'\n'，或者不用原生字符，而是用字符串：‘\\n
例子：
a = r"\n"
b =  "\n"
c = "\\n"
print a
print b
print c
结果：
\n
\n


3.re模块常用方法
3.1.match()方法
格式：match(string[, pos[, endpos]])
参数：
1）string：    匹配使用的文本
2）pos：       开始搜索的索引（即开始搜索string的下标）默认从开头匹配，如没有返回None
3）endpos： 结束搜索的索引


例子
import re
pattern = re.compile(r"\w*(hello.*)(world.*)")
result = pattern.match("aahello world huang")
print(result.groups())
结果：
('hello ', 'world huang')


3.2.search()方法
   该方法用于查找字符串中可以匹配成功的子字符串；从string的pos下标处起尝试匹配pattern，如果pattern结束时仍可匹配，则返回一个Match对象；若无法匹配，则将pos加1后重新尝试匹配；直到pos=endpos时仍无法匹配则返回None
格式： search(string[, pos[, endpos]])

例子：
import re
pattern = re.compile(r"\w*(hello.*)(world.*)")
result = pattern.search("aahello world huang")
print(result.groups())
结果：
('hello ', 'world huang')


3.3.split()方法
按照能够匹配的子串将string分割后返回列表
格式：split(string[, maxsplit])
参数：
maxsplit：用于指定最大分割次数，不指定将全部分割

例子：
import re
pattern = re.compile(r"\d+")
result = pattern.split("one1two2three3four")
print result
结果：
['one', 'two', 'three', 'four']


3.4.findall()方法
搜索string，以列表形式返回全部能匹配的子串.
格式：
findall(string[, pos[, endpos]])


例子：
import re
pattern = re.compile(r"\d+")
result = pattern.findall("one1two2three3four")
print result
结果：
['1', '2', '3']


3.5.finditer()方法
搜索string，返回一个顺序访问每一个匹配结果（Match对象）的迭代器
格式：finditer(string[, pos[, endpos]])


例子：
import re
pattern = re.compile(r"\d+")
result = pattern.finditer("one1two2three3four")
print type(result)
for m in result:
    print type(m)
    print (m.group())


结果：
<type 'callable-iterator'>
<type '_sre.SRE_Match'>
1
<type '_sre.SRE_Match'>
2
<type '_sre.SRE_Match'>
3


说明：result是一个迭代器，而返回的每个m都是match对象


3.6.sub()方法
格式：sub(repl, string[, count])
参数：
1）使用repl替换string中每一个匹配的子串后返回替换后的字符串：
当repl是一个字符串时，可以使用\id或\g<id>、\g<name>引用分组，但不能使用编号0；
当repl是一个方法时，这个方法应当只接受一个参数（Match对象），并返回一个字符串用于替换   （返回的字符串中不能再引用分组）
2）count用于指定最多替换次数，不指定时全部替换


例子：
import re
p = re.compile(r'(\w+) (\w+)')
s = 'i say, hello world!'
print(p.sub(r'\2 \1', s))
def func(m):
    return m.group(1).title() + ' ' + m.group(2).title()
print(p.sub(func, s))


结果：
say i, world hello!
I Say, Hello World!


解释：
\(id)就是匹配的括号的内容，id从默认从1开始计数
m.group(1)是一个字符串，调用字符串的title()方法，所有单词的首字母大写




二、match匹配对象
   Match对象是一次匹配的结果，包含了很多关于此次匹配的信息，可以使用Match提供的可读属性或方法来获取这些信息。上面的过程中多次使用了match对象，调用了他的group()和groups()等方法。


例子：
import re
prog = re.compile(r'(?P<tagname>abc)(.*)(?P=tagname)')
result = prog.match('abc1234567890abc')
print(result)
print "## groups() ##"
print(result.groups())
print ""
print "## group('tagname') ##"
print result.group('tagname')
print ""
print "## group(1) ##"
print(result.group(1))
print ""
print "## group(2) ##"
print(result.group(2))
print ""
print "## groupdict() ##"
print(result.groupdict())


结果：
<_sre.SRE_Match object at 0x02525890>
## groups() ##
('abc', '1234567890')


## group('tagname') ##
abc


## group(1) ##
abc


## group(2) ##
1234567890


## groupdict() ##
{'tagname': 'abc'}


解释：
1）result已经由字符串转换成了一个正则对象
2）resule.groups()可以查看出来所有匹配到的数据，每个()是一个元素，最终返回一个tuple
3）group()既可以通过下标（从1开始）的方式访问，也可以通过分组名进行访问
4）groupdict只能显示有分组名的数据

group([group1, …]):
获得一个或多个分组截获的字符串；指定多个参数时将以元组形式返回。group1可以使用编号也可以使用别名；编号0代表整个匹配的子串；不填写参数时，返回group(0)；没有截获字符串的组返回None；截获了多次的组返回最后一次截获的子串


groups([default]):
以元组形式返回全部分组截获的字符串。相当于调用group(1,2,…last)。default表示没有截获字符串的组以这个值替代，默认为None


groupdict([default]):
返回以有别名的组的别名为键、以该组截获的子串为值的字典，没有别名的组不包含在内。default含义同上




三、正则表达式分组
  分组就是用一对圆括号“()”括起来的正则表达式，匹配出的内容就表示一个分组。从正则表达式的左边开始看，看到的第一个左括号“(”表示第一个分组，第二个表示第二个分组，依次类推，需要注意的是，有一个隐含的全局分组（就是0），就是整个正则表达式。
分完组以后，要想获得某个分组的内容，直接使用group(num)和groups()函数去直接提取就行


1.命名分组
  命名分组就是给具有默认分组编号的组另外再给一个别名。命名分组的语法格式如下：
  (?P<name>正则表达式)   #name是一个合法的标识符


2.后向引用
   当用”()”定义了一个正则表达式组后，正则引擎则会把被匹配的组按照顺序编号，存入缓存。这样我们想在后面对已经匹配过的内容进行引用时，就可以用”\数字”的方式或者是通过命名分组进行”(?P=name)“进行引用。\1表示引用第一个分组，\2引用第二个分组，以此类推，\n引用第n个组。而\0则引用整个被匹配的正则表达式本身
  

阿森纳

啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊

zhangxiajun

不错，好东西啊

nhj074

好东西啊好东西啊好东西啊