正则表达式模块 re
参考：http://www.cnblogs.com/huxi/archive/2010/07/04/1771073.html
1、两种模式
python中有两种正则表达式，上面一种是未编译模式，直接使用re模块中的函数。编译使用方法
未编译模式
>>> import re
>>> re_string="{{(.*?)}}"
>>> some_string="this is a string with {{word}} embedded in {{curly brackets}} to show an {{example}} of {{regular expression}}“
>>> for match in re.findall(re_string,some_string):#findall找出所有匹配的数据放到一个列表里
... print "MATCH->",match
...
MATCH-> word
MATCH-> curly brackets
MATCH-> example
MATCH-> regular expression
已编译模式
>>> import re
>>>obj=re.compile("{{(.*?)}}")
>>> some_string="this is a string with {{word}} embedded in {{curly brackets}} to show an {{example}} of {{regular expression}}"
>>> for match in obj.findall(some_string):
... print "MATCH->",match
...
MATCH-> word
MATCH-> curly brackets
MATCH-> example
MATCH-> regular expression
2、re.compile创建一个模式的对象
re.compile创建一个模式的对象,最常使用的正则表达式方法,里面建立多个匹配模式
3、re.findall() 全文搜索匹配
搜索字符串中指定模式的所有匹配。其匹配模式返回的数据结构类型将取决于模式是否定义了一个组，如果没
有在正则表达式模式中定义组，但却找到匹配。将返回一个字符串列表。如果定义了组（也就是定义了多个模
式），并且其中有匹配，那么re.findall()返回一个多元列表（列表中的数据是多个元组）
re.finditer() re.finditer()对re.findall()稍微修改，不同之处是返回一个迭代。每一次迭代的元素都是一个正则表达式匹配的对象
m=re.compile(r".")
>> m_match=m.findall(text) #findall找出所有匹配的数据放到一个列表里
>>> print m_match
['T', 'h', 'e', ' ', 'A', 't', 't', 'i', 'l', 'a', ' ', 't', 'h', 'e', ' ', 'H', 'u', 'n', ' ', 'S', 'h', 'o', 'w']
多模式
>>> m=re.compile(r'(.)(\w+)(\s+)')
>>> m_match=m.findall(text)
>>> print m_match
[('T', 'he', ' '), ('A', 'ttila', ' '), ('t', 'he', ' '), ('H', 'un', ' ')]
4、找到首次匹配re.match()re.search()
re.match()和re.search()
这两个方法提供相似的功能，他们对字符串应用一个正则表达式，定义开始搜索（pos)和结束搜索的位置（endpos），并且都返回一个【首次匹配】指定模式的匹配对象。参数pos是一个索引.
re.search(re_string,pos=1,endpos=3)
这两个工具不仅可以显示一个模式是否匹配一段文本，而且可以返回一个match()对象.match()对象包含当你搜索文本时
各种各样的数据片段，start(),end(),span(),group(),groups()和groupdict()都是match()方法。
match()方法介绍
start()：匹配行开始位置 end():配行结束位置 span():配置行的长度(包含空格），
group(): 匹配的内容 group()和group(0)一样。group(1)可能是匹配的多个模式中第一个，group(2)第2个
groups(): 将多个模式匹配中匹配出来的元素构成元组('local2:80',)，
groupdict(): 返回一个命名组字典。匹配的别名作为key,匹配的数据作为value
vhost_start=re.compile(r'<VirtualHost\s+(.*?)>')
vhost_end=re.compile(r'</VirtualHost')
docroot_re=re.compile(r'( DocumentRoot\s+)(\S+)')
print "vhost_start_match.span is:",vhost_start_match.span()
print "vhost_start_match.start is:",vhost_start_match.start()
print "vhost_start_match.end is:",vhost_start_match.end()
print "vhost_start_match.group is:",vhost_start_match.group()
print "vhost_start_match.groups is:",vhost_start_match.groups()
print "vhost_start_match.groupdict is:",vhost_start_match.groupdict()
print "vhost_start_match.groups 0 is :",vhost_start_match.groups()[0]
#print "vhost_start_match.groups 1 is :",vhost_start_match.groups()[1]
print "vhost_start_match.group 0 is :",vhost_start_match.group()[0]
print "vhost_start_match.group 1 is :",vhost_start_match.group()[1]
对应结果
vhost_start_match.span is: (0, 23)
vhost_start_match.start is: 0
vhost_start_match.end is: 23
vhost_start_match.group is: <VirtualHost local2:80>
vhost_start_match.groups is: ('local2:80',)
vhost_start_match.groupdict is: {}
vhost_start_match.groups 0 is : local2:80
vhost_start_match.group 0 is : <
vhost_start_match.group 1 is : V
5、正则模块的拆分和替换re.split() re.sub()
re.split() : 正则模块中的拆分
re.sub() : 正则模块中的替换
1)拆分
split(string[, maxsplit]) | re.split(pattern, string[, maxsplit]):
split(pattern, string, maxsplit=0, flags=0)
#按照能够匹配的子串将string分割后返回列表。maxsplit用于指定最大分割次数，（1是两个）不指定将全部分割。
>>> import re
>>> p=re.compile(r'\d+')
>>> print p.split('one1two2three3four4')
['one', 'two', 'three', 'four', '']
上面是编译模式，下面是非编译模式
>>> lines='one1two2three3four4'
>>> re.split(r'\d+',lines)
['one', 'two', 'three', 'four', '']
>>> re.split(r'\d+',lines)[0]
'one'
>>> re.split(r'\d+',lines,2)
['one', 'two', 'three3four4']
#（模式 字符串)最大拆分个数默认为0为最大 \s+一个或多个空白,\d+一个或多个数字
>>> re.split(r'\s+',lines[0])
['HTTP/1.1', '301', 'Moved', 'Permanently']
>>> re.split(r'\s+',lines[0],1)
['HTTP/1.1', '301 Moved Permanently']
>>> re.split(r'\s+',lines[0],4)
['HTTP/1.1', '301', 'Moved', 'Permanently'] #超过最大也显示最大
2）替换
sub(repl, string[, count]) | re.sub(pattern, repl, string[, count]):
使用repl替换string中每一个匹配的子串后返回替换后的字符串。
当repl是一个字符串时，可以使用\id或\g<id>、\g<name>引用分组，但不能使用编号0。
当repl是一个方法时，这个方法应当只接受一个参数（Match对象），并返回一个字符串用于替换（返回的字符串中不能再引用分组）。
count用于指定最多替换次数，不指定时全部替换
>>> p = re.compile(r'(\w+) (\w+)')
>>> s = 'i say, hello world!'
>>> print p.sub(r'\2 \1', s)
say i, world hello!
docroot_re=re.compile(r'(DocumentRoot\s+)(\S+)')
sub_line=docroot_re.sub(r'\1%s' % newdocroot,line)
编译性用r'\1%s' % newdocroot替换line匹配的字符串\1%s 替换第2个分组,正则分组2个，1为第二个，也就是DocumentRoot空白后面的非空白字符串
<1>.替换所有匹配的子串
#用newstring替换subject中所有与正则表达式regex匹配的子串
result = re.sub(regex, newstring, subject)
<2>.替换所有匹配的子串（使用正则表达式对象）
reobj = re.compile(regex)
result = reobj.sub(newstring, subject)
6、正则编译的研究
>>> m=re.compile(r".")
>>> m_match=m.search(text) #对的首次匹配指定模式的匹配对象
>>> print m_match
<_sre.SRE_Match object at 0x28495b80>
['__class__', '__copy__', '__deepcopy__', '__delattr__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'end', 'endpos', 'expand', 'group', 'groupdict', 'groups', 'lastgroup', 'lastindex', 'pos', 're', 'regs', 'span', 'start', 'string']
>>> m_match.group()
'T'
>>> m_match.groups()
()
>>> m_match=m.findall(text) #findall找出所有匹配的数据放到一个列表里
>>> print m_match
['T', 'h', 'e', ' ', 'A', 't', 't', 'i', 'l', 'a', ' ', 't', 'h', 'e', ' ', 'H', 'u', 'n', ' ', 'S', 'h', 'o', 'w']
7、模式分组
log_line_re=re.compile(r'(?P<remote_host>\S+)\s+\S+\s+\S+\s+\[[^\[\]]+\]\s+"[^"]+"\s+(?P<status>\d+)\s+(?P<bytes_sent>-|\d+)\s*')
\s+空白 \S+字符串
>>> m=re.compile(r'(.)(\w+)')
>>> m_match=m.search(text)
>>> m_match.group() #匹配的内容
'The'
>>> m_match.group(1) #多个模式中匹配第一个模式的内容，这里匹配(.)
'T'
>>> m_match.group(2) #多个模式中匹配第二个模式的内容，这里匹配(\w+)
'he'
>>> m_match.groups() #将多个模式匹配中匹配出来的元素构成元组
('T', 'he')
>>> m_match.groups(1) #这里面的数字目前没什么意义
('T', 'he')
>>> m_match.groups()[0] #取出第一个匹配模式首次匹配的内容和m_match.group(1)一样
'T'
>>> m_match.groups()[1]
'he
多匹配一个空格看看
>>> m=re.compile(r'(.)(\w+)(\s+)')
>>> m_match=m.search(text)
>>> m_match.group()
'The '
>>> m_match.group(0)
'The '
>>> m_match.group(1)
'T'
>>> m_match.group(3)
' '
>>> m_match.groups()
('T', 'he', ' ')
>>> m_match.groups()[2]
'he'
8、groupdict() 研究
返回一个命名组字典
#!/usr/bin/evn python
import sys
import re
log_line_re=re.compile(r'(?P<remote_host>\S+)\s+\S+\s+\S+\s+\[[^\[\]]+\]\s+"[^"]+"\s+(?P<status>\d+)\s+(?P<bytes_sent>-|\d+)\s*')
def formatlogline(logfile):
for line in logfile:
m=log_line_re.match(line)
groupdict=m.groupdict()
print groupdict
if __name__=='__main__':
if not len(sys.argv) > 1:
sys.exit(1)
infile_name=sys.argv[1]
try:
infile=open(infile_name,'r')
except IOError:
print "infile_name not found!"
print __doc__
sys.exit(1)
else:
formatlogline(infile)
infile.close()
python logtest.py /var/log/httpd-access.log
获取到数据的格式
{'status': '404', 'remote_host': '192.168.1.1', 'bytes_sent': '209'}
{'status': '200', 'remote_host': '192.168.1.1', 'bytes_sent': '44'}
{'status': '200', 'remote_host': '192.168.1.1', 'bytes_sent': '44'}
{'status': '200', 'remote_host': '192.168.1.200', 'bytes_sent': '44'}
{'status': '200', 'remote_host': '192.168.1.200', 'bytes_sent': '44'}
{'status': '200', 'remote_host': '192.168.1.200', 'bytes_sent': '44'}
编译的模式匹配里设置了多个匹配模式
(?P<remote_host>\S+)，(?P<status>\d+)，(?P<bytes_sent>-|\d+)
(?P<name>...) 分组，除了原有的编号外再指定一个额外的别名
EG：(?P<id>abc){2} 结果abcabc，有一个别名id；m.groupdict()方法后{'id':'abcabc'}
(?P<bytes_sent>-|\d+)：匹配|左右两边任意一个