Python爬虫—1入门_4_正则表达式

1、python中的正则表达式相关介绍
1.1 转义字符
     注意使用原始字符串，以r开头的字符串，如r"python"；
     当需要匹配 . \ * + 等特殊的字符时，需要在这些字符前加反斜杠\
     例如：r"python\.org"用来匹配"python.org"
1.2数量词的贪婪模式与非贪婪模式
     对于 * + ?这两个数量词，默认情况下是贪婪的（尽可能多的匹配字符）；
     在 * + ? 后加?，就是非贪婪模式（尽可能少的匹配字符）；
     对应的非贪婪模式是：*?     +?     ??

     一般使用非贪婪模式

     例如：
          查找字符串"abbbc"

         
贪婪模式下：r"ab*"      将找到"abbb"
          非贪婪模式：r"ab*?"    将只找到"a"

2、Python re模块
2.1 re模块的内容
     compile(pattern[, flag])                    #根据正则表达式创建匹配对象
     match(pattern, string[, flag])             #在字符串的开始处进行匹配，返回matchObject或者None
     search(pattern, string[, flag])            #在字符串中寻找模式，返回matchObject或者None
     split(pattern, string[, maxsplit])         #根据模式的匹配项来分割字符串
     findall(pattern, string[, flag])             #以列表的形式返回匹配的所有子串
     finditer(pattern, string[,flag])             #返回一个顺序访问每一个匹配结果（matchObject）的迭代器
     sub(pattern, repl, string[, count])
     subn(pattern, repl, string[, count])
2.2 re.compile(pattern[, flag])
     返回一个匹配模式对象，即pattern对象；
     而后可以利用这个pattern对象来对字符串进行进一步的匹配操作；
     flag是匹配模式，取值与解释如下：
          re.I     #忽略大小写
          re.M   #多行模式
          re.S    #点任意匹配模式
          re.L    #使预定义字符类 \w \W \b \B \s \S 取决于当前区域设定
          re.U   #使预定义字符类 \w \W \b \B \s \S 取决于unicode定义的字符属性
          re.X   #详细模式，正则表达式可以是多行的，忽略空白字符，可以加注释
2.3 re.match(pattern[, flag])
     从string的开头开始匹配，如果成功返回一个matchObject，否则返回None
     matchObject提供如下属性和方法，来获取匹配的子串的信息：
     string          匹配时使用的文本
   
 re               匹配时使用的pattern对象
     pos            文本中正则表达式开始搜索的索引
   
 endpos       最后一个被捕获的分组在文本中的索引，默认为None
 
   lastgroup    最后一个被捕获的分组的别名，默认是None
     group([group1, group2, ...])
                       获得一个或者多个分组截获的字符串；指定多个参数时，以元组形式返回；
                       group1可以使用编号也可以使用别名，其中编号0表示整个匹配的子串；
                       默认返回None
     groups( )    以元组的形式返回全部分组截获的字符串
   
 groupdict( )返回以有别名的组的别名为键、以组截获的字符串为值的字典，不包含没有别名的。
     start([group])
                       返回指定的组截获的字串在string中的开始索引，group默认为0
     end([group])
                       返回指定的组截获的字串在string中的结束索引（最后一个字符索引+1），group默认为0
   
 span([group])
                       返回(start([group]), end([group]))
     expand(tmplate)
                       将匹配的分组带入tmplate中返回
     例程：
import re
ptn = re.compile(r"(\w+) (\w+)(?P<sign>.*)")
m = ptn.match("hello world!")
print "m.string:", m.string
print "m.re:", m.re
print "m.pos:", m.pos
print "m.endpos:", m.endpos
print "m.lastindex:", m.lastindex
print "m.lastgroup:", m.lastgroup
print "m.group():", m.group()
print "m.group(1,2):", m.group(1, 2)
print "m.groups():", m.groups()
print "m.groupdict():", m.groupdict()
print "m.start(2):", m.start(2)
print "m.end(2):", m.end(2)
print "m.span(2):", m.span(2)
print r"m.expand(r'\g \g\g'):", m.expand(r'\2 \1\3')
     输出：
m.string: hello world!
m.re: <_sre.SRE_Pattern object at 0x0000000002E96250>
m.pos: 0
m.endpos: 12
m.lastindex: 3
m.lastgroup: sign
m.group(): hello world!
m.group(1,2): ('hello', 'world')
m.groups(): ('hello', 'world', '!')
m.groupdict(): {'sign': '!'}
m.start(2): 6
m.end(2): 11
m.span(2): (6, 11)
m.expand(r'\g \g\g'): world hello!
2.4 re.search(pattern[, flag])
     扫描整个string查找匹配，如果成功返回一个matchObject，否则返回None
2.5 re.split(pattern, string[, maxsplit])
     按照能够匹配的字串将string分割，并返回列表，maxsplit用于指定最大分割次数
     例程：
ptn = re.compile(r"\d+")
print ptn.split("one1two2three34four4")
     输出：
          ['one', 'two', 'three', 'four']
2.6 re.findall(pattern, string[, flag])
     搜索string，以列表形式返回全部能够匹配的子串
     例程：
ptn = re.compile(r"\d+")
print ptn.findall("one1two2three34four4")
     输出：
          ['1', '2', '34', '4']
2.7 re.finditer(pattern, string[, flag])
     搜索string，返回一个顺序访问每一个匹配结果（Match对象）的迭代器
     例程：
pattern = re.compile(r'\d+')
for m in re.finditer(pattern,'one1two2three3four4'):

    print m.group(),
     输出：
          1 2 3 4
2.8 re.sub(pattern, repl, string[, count])
     使用repl替换string中每一个匹配的字串后，返回替换后的字符串
     1）当repl是一个字符串时，可以使用\id或者\g引用分组，但不能使用编号0
     2）当repl是一个方法时，这个方法只接受一个matchObject对象作为参数，并放回一个字符串用于替换
     count用于指定最多替换次数，不指定时全部替换

     例程：
ptn = re.compile(r"(\w+) (\w+)")

s = "i say, hello world!"
print ptn.sub(r"\2 \1", s)

def func(m):

    return m.group(1).title() + " " + m.group(2).title()
print re.sub(ptn, func, s)
     输出：
          say i, world hello!
          I Say, Hello World!
2.9 re.subn(pattern, repl, string[, count])
     返回(sub(pattern, repl, string[, count]), 替换次数)
3、正则表达式的语法规则
     下面是Python中正则表达式的一些匹配规则