Python中正则表达式（re模块）的使用_Linux编程_Linux公社-Linux系统门户网站
你好，游客
Python中正则表达式（re模块）的使用
来源：Linux社区&
作者：dayi123
1、正则表达式的概述
（1）概述：正则表达式是一些由字符和特殊符号组成的字符串，他们描述了模式的重复或者表示多个字符，正则表达式能按照某种模式匹配一系列有相似特征的字符串。正则表达式是一种小型的、高度的专业化的编程语言，
（2）Python语言中的正则表达式内嵌在Python中通过re模块实现，正则表达式被编译成一系列的字节码，然后由C编写的匹配引擎执行
2、字符匹配
（1）符号匹配
匹配文本字符串的字面值literal
匹配字符串root
匹配正则表达式re1或者re2
root|admin
匹配字符串root或者admin
匹配除换行外的任意字符
匹配ac中间有任意一个字符的选项
匹配字符串的起始部分
匹配以root开头的结果
匹配字符串的结束部分
匹配以sh结尾的内容
匹配0次或多次前面出现的内容的正则表达式
匹配0次或多次出现小写字母
匹配1次或多次前面出现的内容的正则表达式
匹配大写字母至少出现一次
匹配0次或1次前面出现的正则表达式
匹配go或者goo
匹配来自字符集的任一单一字符
匹配ac中间出现一个数字
匹配x到y范围中的任一单一字符
不匹配此字符集中出现的任何一个字符，包括某一范围字符
[^A-Za-z0-9]
匹配非字母、数字
匹配n次前面出现的正则表达式
匹配三个数字
匹配n到m此前面出现的正则表表达式
[0-9]{5,7}
匹配数字出现5到7次
匹配封闭的正则表达式，然后另存为子组
（[0-9]{3}\.）
匹配三个数字+.存为一个组
（2）特殊字符的匹配
匹配任何十进制数字，与[0-9]一致
data\d+.txt
匹配任何非数字
匹配任何字母数字字符（\W与之相反）
[A-Za-z]\w+
匹配任何空格字符，与[\n\t\r\v\f]相同，\S功能相反
匹配任何单词边界（\B功能相反）
匹配以保存的子组N
price：\16
匹配字符串的起始（结束）
3、Python正则表达式的使用（即re模块的使用）
compile（pattern,flags=0）
使用任何可选的标记来编译正则表达式的模式，然后返回一个正则表达式对象
re模块函数和正则表达式对象的方法
match(pattern,string,flags=0)
尝试使用带有可选的标记的正则表达式的模式来匹配字符串，如果匹配成功就返回匹配对象；失败，返回none
search(pattern,string,flags=0)
使用可选标记搜索字符串中第一次出现正则表达式的模式，如果匹配成功则返回匹配对象，失败，返回none
findall(pattern,string[,flags])
查找字符串中所有（非重复）出现的正则表达式模式，如果匹配成功，则返回匹配对象，如果失败，返回none
finditer(patter，string[,flags])
与findall函数相同，但返回的不是一个列表，而是一个迭代器，对于每一次匹配，迭代器都返回一个匹配对象
split(pattern,string,max=0)
根据正则表达式的模式分隔符，split函数将字符串分割为列表，然后返回成功匹配的列表，分割最多操作max次（默认分割所有）
sub(pattern,repl,string,count=0)
使用repl替换所有正则表达式的模式在字符串中出现的位置，除非定义count,否则，就替换所有出现的位置
清楚隐式编译的正则表达式
group(num=0)
返回整个匹配对象，或者编号为num的特定子组
groups(default=None)
返回一个包括所有子组的元组，（如果没有匹配成功，则返回一个空元组）
groupdict(default=None)
返回一个包含所有匹配的的命名子组的字典，所有的子组名称作为字典的键（如果没有匹配，则返回空字典）
（1）compile()函数
1）re.compile(strPattern[,flag])方法概述：
这个方法是Pattern类的工厂方法，用于将字符串形式的正则表达式编译为Pattern对象。第二个参数flag是匹配模式取值可以使用按位或运算符，&|&表示同时生效，比如re.I|re.M
2）作用：可以把经常使用的正则表达式编译成正则表达式对象，这样可以提高一定的效率。如：
import& re
text = "Jgood& is a handsome boy,he is cool,clever, and so on..."
regex =& re.compile(r'\w*oo\w*')& & #将正则表达式编译成对象
print(regex.findall(text))
（2）通过match（）方法匹配字符串
import& re &text = "Jgood& is a handsome boy,he is cool,clever, and so on..."&regex =& re.compile(r'\w*oo\w*')& & #将正则表达式编译成对象 &print(regex.findall(text))
（2）通过match（）方法匹配字符串&
1）作用：从起始位置(开头)开始匹配，匹配成功返回一个对象，未匹配成功返回None&
2）语法：match(pattern, string, flags=0)& & &
pattern： 正则模型& & &
string： 要匹配的字符串& & &
falgs& ： 匹配模式&
3）matchobect对象的方法& & & group()：返回被RE匹配的的字符串& & & start()：返回匹配开始的位置& & & end()：返回匹配结束的位置& & & span()：返回一个元组包含匹配（开始，结束）的位置& & & group()：返回re整体匹配的字符串，可以一次输入多个组号，对应组号匹配的字符串& & & group(n,m) ：返回组号为n,m所匹配的字符串，如果组号不存在，则返回组号匹配的字符串& & & groups()：返回一个包括正则表达式中所有小组字符串的元组，从1到所含的小组号，通常& & & groups()不需要参数，返回一个元组，元组中元素是正 则表达式中定义的组import re origin = "has dfuojqwlm098"# r = re.match("h\w+", origin) # r = re.match("h(\w+)", origin)& #在匹配到的数据中再通过\w+去匹配 r = re.match("h(?P&name&\w+)", origin)&
#给分组名名 print(r.group())& # 获取匹配到的所有结果 print(r.groups())& # 获取模型中匹配到的分组结果 print(r.groupdict())& # 获取模型中匹配到的分组结果
（3）使用search（）在一个字符串中查找匹配&
1）作用：search（）会用它的字符串参数，在任意位置对给定正则表达式模式搜索第一次出现的匹配情况。如果搜索到成功的匹配，就会返回一个匹配对象；否则，返回None.&
2)用法：同match()importre m =re.match('foo','seafood') if m isnot None: & & print(m.group())& & #使用match匹配不到，所以没有打印 &
m =re.search('foo','seafood') if m isnot None:& & & print(m.group())& &
#使用search匹配到了foo & origin = "has dayi haha hal dfuojdayi098"& r = re.search("d(\w+).*(?P&name&\d)$", origin) print(r.group())& # 获取匹配到的所有结果 print(r.groups())& # 获取模型中匹配到的分组结果 print(r.groupdict())& # 获取模型中匹配到的分组中所有执行了key的组
（4）重复、特殊字符及分组匹配&
正则表达式中最常见的情况包括特殊字符的使用，正则表达式模式的重复出现，以及使用圆括号对匹配模式的各???分进行分组和提取操作。import re #一个分组多次匹配 # patt = '\w+@(\w+\.)?\w+\.com'& &
#创建一个匹配规则，要求括号中的内容出现0次或一次 # print(re.match(patt, 'linuxidc@126.edu.com is mail').group()) & patt = '\w+@(\w+\.)*\w+\.com'& &
#创建一个匹配规则，匹配括号中的内容出现0次或多次 print(re.match(patt,'linuxidc@126.edu.dayi.com is mail').group()) & #多个分组分别匹配 m = re.match('(\w\w\w)-(\d\d\d)', 'abc-123') print(m.group(1))&
#打印分组以中的内容 print(m.group(2))& #打印分组2中的内容 print(m.group())& #打印分组中的所有内容 & #分组嵌套匹配 n = re.match('(a(b))', 'abcdefgh') print(n.group(1))&
#打印匹配到的分组1,即'(a(b))' print(n.group(2))&
#打印匹配到的分组2即'（b）' print(n.groups())& #打印匹配到的所有分组，即'(ab)','(b)'
（5）匹配字符串的起始结尾及单词边界import re & #开头匹配 print(re.search('^linuxidc', 'dayi123 is nb').group()) # print(re.search('^dayi', 'her is dayi').group()) & #边界匹配 print(re.search(r'\bhello', 'hello world').group())#print(re.search(r'\Bhello','worldhellower').group()) #有边界匹配时会报错 print(re.search(r'\Bhello', 'worldhellower').group())
（6）使用findall和finditer()查找每一次出现的位置&
findall()查询字符串中某个正则表达式模式全部的非重复出现的情况，findall返回的是一个列表，如果没有匹配到则返回一个空列表，如果匹配成功，列表包含所有成功的匹配部分（从左向有按顺序排列）import re origin = "has haha hal dfuojqwlm098"& print(re.findall("h\w+", origin))&
#找到字符串中所有的匹配到的内容 print(re.findall("h(\w+)", origin))&
#打印匹配到的列表 r = re.findall("h(\w+)a(bc)c", origin) #因为匹配不到所有打印一个空列表 print(r)
finditer()函数与findall函数类似，但finditer（）返回的是一个可迭代的对象。import re s = 'This and that'print(re.findall(r'(Th\w+) and (th\w+)', s, re.I)) print(re.finditer(r'(Th\w+) and (th\w+)', s, re.I).__next__().groups()) #调用返回值 print(re.finditer(r'(Th\w+) and (th\w+)', s, re.I).__next__().group(1)) it = re.finditer(r'(Th\w+)', s, re.I)&
#生成一个生成器对象 g = it.__next__()&
#调用 print(g.groups())&
#打印出This,以元组的形式 print(g.group(1)) g = it.__next__()& #再次调用 print(g.groups())& #打印出that #将匹配到的内容生产一个列表，列表中包含两个元组 print([g.groups(1) for g in re.finditer(r'(Th\w+)', s, re.I)])
（7）使用sub()和subn()搜索替换sub()只替换搜索到的内容，subn()不但替换搜索到的内容，并返回替换的次数。import re print(re.sub("g.t","have",'I get A, I got B,I gut C'))& #对匹配到的单词替换 print(re.subn("g.t","have",'I get A, I got B,I gut C')) #对匹配到的单词替换，并返回替换次数 print(re.sub('[bd]','Y','abcdef')) print(re.subn('[bd]','Y','abcdef'))& & #对字符串替换，并打印替换的字符串的的次数
分组和替换的综合应用（替换日期的表示方法）：import re import time,datetime day1 = str(datetime.date.today()) print(day1) #将月/日/年的时间格式转化成&日/月/年&，将r加在左引号之前，主要目的是为了避免转义特殊字符串字符 print(re.sub(r'(\d{1,2})/(\d{1,2})/(\d{2}|\d{4})', r'\2/\1/\3', '05/06/2017')) print(re.sub(r"(\d{2}|\d{4})-(\d{1,2})-(\d{1,2})", r"\3/\2/\1", day1))
（8）使用split分割字符串import re print(re.split('\d+','one1two2three3,for4')) #以匹配到的数字对字符串以&,&进行分割
4、正则表达式的应用（1）对Linux系统who命令输出内容进行处理将Linux系统who命令输出结果保存到whodata.txt中：
[root@linuxidc ~]# cat whodata.txt liu2& & :0& & & & &
22:10 (:0)liu2& & pts/0& & & &
22:11 (:0)root& & pts/1& & & &
03:51(172.16.252.112)root& & pts/2& & & &
03:51(172.16.252.112)root& & pts/3& & & &
03:52 (172.16.252.112)对who命令输出的内容进行处理：import re f = open('whodata.txt','r') for line in f:& &
& & #对匹配到的行的内容以逗号分隔，将每一行的内容分别存到一个列表中 & & print(re.split(r'\s\s+',line.rstrip()))& f.close()
使用findall()函数处理win下tasklist命令：import os import re f = os.popen('tasklist /nh', 'r') for line in f: & & print(re.findall(r'([\w.]+(?:[\w]+)*)\s\s+(\d+) \w+\s\s+\d+\s\s+([\d,]+ K)', line.rstrip()))& & & #读取每一行中自己需要的数据 & f.close()
（2）生成用于正则表达式练习的数据#!/usr/bin/env python from random import randrange,choice from stringimport ascii_letters as lc from sys import maxsize from time import ctime & tlds = ('com','deu','net','org','gov') for i in range(randrange(5,11)): & & dtint = randrange(maxsize)& & & & #生成一个随机数字组 & & #在属组中取一个6到十位的随机数作为时间戳生成一个日期 & & dtstr = ctime(int(str(dtint)[0:randrange(6,10)]))& & & llen = randrange(4,8)&
#生成一个4-8的随机数字 & & login = ''.join(choice(lc) for j in range(llen)) #生成邮箱@符号前的字符 & & dlen = randrange(llen,13) & & dom = ''.join(choice(lc) for j in range(dlen))& #生成@后的字符，长度有dlen来决定 & & #choice(tlds)为在tlds总随机选择一个域名后缀 & & print('%s::%s@%s.%s::%d-%d-%d' % (dtstr,login,dom,choice(tlds),dtint,llen,dlen))
将上面生成的数据保存到一个文件中用于后面练习：#!/usr/bin/env python import re with open('gendata.txt','r') as f: & & for line in f: & & & & patt = '.+(\d+-\d+-\d+)' #为贪婪匹配，匹配前面为任意字符，后面组中为如&5-7-10&的数据 & & & & print(re.match(patt, line).group(1))& & & &
& & & & '''"?"要求正则表达式引擎匹配尽可能少的字符，在"+","*","？"后使用可达到预期效果'''& & & & patt1= '.+?(\d+-\d+-\d+)' #通过"?",匹配到了符合分组中的所有字符串 & & & & print(re.match(patt1, line).group(1))
本文永久更新链接地址：
相关资讯 & & &
& (03月21日)
& (10/18/:45)
& (03月21日)
& (01月05日)
& (10/04/:11)
　　　同意评论声明
　　　发表
尊重网上道德，遵守中华人民共和国的各项有关法律法规
承担一切因您的行为而直接或间接导致的民事或刑事法律责任
本站管理人员有权保留或删除其管辖留言中的任意内容
本站有权在网站内转载或引用您的评论
参与本评论即表明您已经阅读并接受上述条款每天坚持阅读，记录，定时输出
python 正则匹配文本并返回字典列表
今天有遇到要匹配网页的table元素里面的内容，部分内容为
&td&60&/td&
&td&&a&leeliao&/a&&/td&
&td&&a&leeliao&/a&&/td&
&td&￥56.82 元&/td&
&td&￥56.82元&/td&
&td& 23:33:54&/td&
&td&手动&/td&
&td&&div class='iconBidState0' /&&/td&
&td&61&/td&
&td&&a&luo321654&/a&&/td&
&td&&a&luo321654&/a&&/td&
&td&￥4,000.00 元&/td&
&td&￥4,000.00元&/td&
&td& 23:34:32&/td&
&td&手动&/td&
&td&&div class='iconBidState0' /&&/td&
我想要匹配每一个&tr&里面的头两个&td&，用python的正则加findall函数便可实现。但是要想获取类似字典一样的匹配（即可以通过group('key')类似的形式获取值得话），我需要对正则进行进一步改造。
我写的正则为r'''&td&(?P&number&\d+)&/td&.*?&td&&a&(?P&name&\w+)&/a&&/td'''
(?P&name&...)的形式是用命名的形式分组，可以生成对应name的字典
实现功能的全部代码是
r = re.compile(r'''&td&(?P&number&\d+)&/td&.*?&td&&a&(?P&name&\w+)&/a&&/td''', re.S)
result = re.finditer(r, content)
print [m.groupdict() for m in result]
得到的最终结果
[{'number': '60', 'name': 'leeliao'}, {'number': '61', 'name': 'luo321654'}]
这里的groupdict是返回匹配到的所有命名子组的字典，至于为什么不用findall呢，这是因为findall最后返回的是匹配到的字符元组，类似
'leeliao'), ( '61',
'luo321654')]
而finditer返回一个正则匹配的一个对象。
具体可以参考
正则是一个强大的工具，需要我慢慢摸索学习，以此文记录学习的过程。
有错漏之处，欢迎指正。
参考文章：
没有更多推荐了，菜鸟问个问题哈，如何用 python 找到没有扩展名的文件呢，一直不知道是怎么匹配的呢，其实主要还是正则表达式学的不好 - V2EX
V2EX = way to explore
V2EX 是一个关于分享和探索的地方
已注册用户请 &
菜鸟问个问题哈，如何用 python 找到没有扩展名的文件呢，一直不知道是怎么匹配的呢，其实主要还是正则表达式学的不好
22:30:47 +08:00 · 4669 次点击
25 回复 &| &直到
10:32:02 +08:00
& & 04:22:22 +08:00
试试 ^[^.]+$
& & 05:25:13 +08:00 via iPhone
'.' not in filename
& & 07:20:21 +08:00
@ 你们难道不考虑文件名中有.的情况?
& & 07:55:11 +08:00
&A filename extension is a suffix (separated from the base filename by a dot or space) to the name of a computer file applied to indicate the encoding (file format) of its contents or usage.&
参考
通常使用句号'.'作为分隔符
& & 08:19:46 +08:00
文件名中有“.”就算是有了扩展名，不管“.”后面是什么。
& & 08:30:23 +08:00
@ test-v1.0-stable.tar.gz
& & 08:48:05 +08:00 via Android
.gz 是 gnuzip 的压缩包是 zip 的gnu版
.tar 是 tar 命令打出来的包，没压缩
所以 tar.gz 是告诉软件和你，这个包是包成了 tar 然后用 gz 压缩过！
类似有 tar.bz2
当然，文件类型都在文件头有信息
& & 09:34:08 +08:00
@ 你根本没明白我的意思
& & 09:39:13 +08:00
@ 我的理解是你想说形如‘test-v1.0-stable’这样的文件应该视为没有扩展名的文件。 如果按照扩展名为3个字符以内的约定。可以使用 .+?\.[^\.]{4,}$
这样形如
test-v1.0-stable
.test-v1.0-stable
都可以match。
而 test-stable-v1.0 这样的不能match
按楼主要求使用正则的话目前就想到这么多。 选择性参考。
& & 09:39:39 +08:00
@ 你的意思是beta v0.1这样的文件也算没有扩展名吗？
& & 09:41:24 +08:00
& & 10:15:54 +08:00 via Android
哦，我知道了。那样的话，需要一个有效拓展名列表！
& & 10:22:44 +08:00
@ 你就不允许人家拓展名叫 0-stable 吗！
& & 11:06:29 +08:00
直接做个函数做判断好了。。。简单明了
& & 11:30:32 +08:00
实际上os.path.splitext都只是按.来split
& & 11:38:22 +08:00
提供一个库方案：mimetypes.guess_type，返回(None, None)就没扩展
& & 11:40:20 +08:00
@ 1.docx 也要算是没有扩展名的文件么= =
& & 11:54:06 +08:00
从 SO 上看到的：
^([^\\]*)\.(\w+)$
可以匹配 index.html, 1.docx, pack.7z, ring.mp3, .bash_profile 等等，不会匹配test-v1.0-stable
但是看 wikipedia 上面的扩展名列表，发现不少猎奇的= =
像 temp.$$$ 就没法匹配
& & 13:34:09 +08:00
@ 只有一个点并且在最后呢？
& & 08:02:55 +08:00
@ 大神看我代码，为啥匹配不到呢
# -*- coding: utf-8 -*-
#########################################################################
# Author: Yao Kun
# Created Time: 五
8/ 8 07:42:26 2014
# File Name: testmac.py
# Description:
#########################################################################
import os
# 用于获得操作系统信息
import platform
import fnmatch
print &尝试删除扩展名为空，或者是不需要同步的文件&
sys = platform.system()
if sys == &Darwin&:
sys = &Mac OS X&
print &Your system is&, sys, &, this is a delete-file script...&
else:
print &您的操作系统是&, sys, &,这是删除文件脚本&
def iterfindfiles(path, fnexp):
for root, dirs, files in os.walk(path):
# 遍历某个目录
for filename in fnmatch.filter(files, fnexp):
yield os.path.join(root, filename)
if sys == &Mac OS X&:
search_path = r&/Users/mac-prisonbreak/百度云同步盘/&
else:
search_path = r&D:/百度云/Project&
print &Your current search dir is&, search_path
flag = False
command = &check&
logfile = open(&delete_log.txt&, &w+&)
for filename in iterfindfiles(search_path, &^([^\\]*)\.(\w+)$&):
print filename
logfile.write(&\n&+filename)
# 删除是危险操作，需要确认
if command == &all& or command == &yes&:
os.remove(filename)
if command == &yes&:
command = &check&
elif command == &none&:
print &Do nothing&
command = raw_input()
#关闭文件
logfile.close()
& & 08:05:22 +08:00
@ 匹配不到呀，我上面贴了一下代码
& & 08:12:49 +08:00
@ 我知道了，好像是这个fnmatch的问题哈
& & 09:34:05 +08:00
@ 我用 re 简单试的= =
& & 10:22:10 +08:00
之前的有点问题 应该改成 .+?\.?[^\.]{4,}$
& & 10:32:02 +08:00
fnmatch的文档里第一句写着呢。
This module provides support for Unix shell-style wildcards, which are NOT the same as regular expressions。
它用的pattern不是正则表达式。
& · & 2926 人在线 & 最高记录 3541 & · &
创意工作者们的社区
World is powered by solitude
VERSION: 3.9.8.1 · 22ms · UTC 09:22 · PVG 17:22 · LAX 02:22 · JFK 05:22? Do have faith in what you're doing.Python入门篇之正则表达式
转载 &更新时间：日 10:16:00 & 投稿：hebedich
正则表达式是一个很有用的工具，可处理复杂的字符匹配和替换工作。在Python中内置了一个re模块以支持正则表达式。本文我们就来详细探讨下Python中正则表达式。
&正则表达式有两种基本的操作，分别是匹配和替换。
匹配就是在一个文本字符串中搜索匹配一特殊表达式；
替换就是在一个字符串中查找并替换匹配一特殊表达式的字符串。
1.基本元素
正则表达式定义了一系列的特殊字符元素以执行匹配动作。
正则表达式基本字符
匹配text字符串
匹配除换行符之外的任意一个单个字符
匹配一个字符串的开头
匹配一个字符串的末尾
在正则表达式中，我们还可用匹配限定符来约束匹配的次数。
匹配限定符
重复匹配前表达式零次或多次
重复匹配前表达式一次或多次
重复匹配前表达式零次或一次
精确重复匹配前表达式m次
至少重复匹配前表达式m次
至少重复匹配前表达式m次，至多重复匹配前表达式n次
据上所述，".*"为最大匹配，能匹配源字符串所有能匹配的字符串。".* "为最小匹配，只匹配第一次出现的字符串。如：d.*g能匹配任意以d开头，以g结尾的字符串，如"debug"和"debugging"，甚至"dog is walking"。而d.* g只能匹配"debug"，在"dog is walking"字符串中，则只匹配到"dog "。
在一些更复杂的匹配中，我们可用到组和运算符。
组和运算符
匹配集合内的字符，如[a-z],[1-9]或[,./;']
匹配除集合外的所有字符，相当于取反操作
匹配表达式A或B，相当于OR操作
表达式分组，每对括号为一组，如([a-b]+)([A-Z]+)([1-9]+)
匹配在number表达式组内的文本
有一组特殊的字符序列，用来匹配具体的字符类型或字符环境。如\b匹配字符边界，food\b匹配"food"、"zoofood"，而和"foodies"不匹配。
特殊字符序列
只匹配字符串的开始
匹配一个单词边界
匹配一个单词的非边界
匹配任意十进制数字字符，等价于r'[0-9]'
匹配任意非十进制数字字符，等价于r'[^0-9]'
匹配任意空格字符（空格符、tab制表符、换行符、回车、换页符、垂直线符号）
匹配任意非空格字符
匹配任意字母数字字符
匹配任意非字母数字字符
仅匹配字符串的尾部
匹配反斜线字符
有一套声明(assertion)对具体事件进行声明。
正则表达式声明
匹配空字符串，iLmsux字符对应下表的正则表达式修饰符。
匹配圆括号内定义的表达式，但不填充字符组表。
( P&name&)
匹配圆括号内定义的表达式，但匹配的表达式还可用作name标识的符号组。
匹配所有与前面命名的字符组相匹配的文本。
引入注释，忽略圆括号内的内容。
如果所提供的文本与下一个正则表达式元素匹配，这之间没有多余的文本就匹配。这允许在一个表达式中进行超前操作，而不影响正则表达式其余部分的分析。如"Martin"其后紧跟"Brown"，则"Martin( =Brown)"就只与"Martin"匹配。
仅当指定表达式与下一个正则表达式元素不匹配时匹配，是( =...)的反操作。
如果字符串当前位置的前缀字符串是给定文本，就匹配，整个表达式就在当前位置终止。如( &=abc)def表达式与"abcdef"匹配。这种匹配是对前缀字符数量的精确匹配。
如果字符串当前位置的前缀字符串不是给定的正文，就匹配，是( &=...)的反操作。
正则表达式还支持一些处理标志，它会影响正则式的执行方法。
I或IGNORECASE
忽略表达式的大小写来匹配文本。
通过re模块，我们就可在python中利用正则式对字符串进行搜索、抽取和替换操作。如：re.search()函数能执行一个基本的搜索操作，它能返回一个MatchObject对象。re.findall()函数能返回匹配列表。
&&& import re
&&& a="this is my re module test"
&&& obj = re.search(r'.*is',a)
&&& print obj
&_sre.SRE_Match object at 0xb7d7a218&
&&& obj.group()
&&& re.findall(r'.*is',a)
['this is']
MatchObject对象方法
expand(template)
展开模板中用反斜线定义的内容。
m.group([group,...])
返回匹配的文本，是个元组。此文本是与给定group或由其索引数字定义的组匹配的文本，如果没有组定组名，则返回所有匹配项。
m.groups([default])
返回一个元组，该元组包含模式中与所有组匹配的文本。如果给出default参数，default参数值就是与给定表达式不匹配的组的返回值。default参数的默认取值为None。
m.groupdict([default])
返回一个字典，该字典包含匹配的所有子组。如果给出default参数，其值就是那些不匹配组的返回值。default参数的默认取值为None。
m.start([group])
返回指定group的开始位置，或返回全部匹配的开始位置。
m.end([group])
返回指定group的结束位置，或返回全部匹配的结束位置。
m.span([group])
返回两元素组，此元组等价于关于一给定组或一个完整匹配表达式的(m.start(group),m.end(group)))列表
传递给match()或search()函数的pos值。
传递给match()或search()函数的endpos值。
m.lastindex
m.lastgroup
创建这个MatchObject对象的正则式对象
提供给match()或search()函数的字符串。
使用sub()或subn()函数可在字符串上执行替换操作。sub()函数的基本格式如下：
&sub(pattern,replace,string[,count])
& 代码如下:
&&& str = 'The dog on my bed'
&&& rep = re.sub('dog','cat',str)
&&& print rep
The cat on my bed
replace参数可接受函数。要获得替换的次数，可使用subn()函数。subn()函数返回一个元组，此元组包含替换了的文本和替换的次数。
如果需用同一个正则式进行多次匹配操作，我们可把正则式编译成内部语言，提高处理速度。编译正则式用compile()函数来实现。compile()函数的基本格式如下：
&compile(str[,flags])
str表示需编译的正则式串，flags是修饰标志符。正则式被编译后生成一个对象，该对象有多种方法和属性。
正则式对象方法/属性
r.search(string[,pos[,endpos]])
同search()函数，但此函数允许指定搜索的起点和终点
r.match(string[,pos[,endpos]])
同match()函数，但此函数允许指定搜索的起点和终点
r.split(string[,max])
同split()函数
r.findall(string)
同findall()函数
r.sub(replace,string[,count])
同sub()函数
r.subn(replace,string[,count])
同subn()函数
创建对象时定义的标志
r.groupindex
将r'( Pid)'定义的符号组名字映射为组序号的字典
在创建对象时使用的模式
转义字符串用re.escape()函数。
通过getattr获取对象引用
&&& li=['a','b']
&&& getattr(li,'append')
&&& getattr(li,'append')('c')&&&&&&&&& #相当于li.append('c')
['a', 'b', 'c']
&&& handler=getattr(li,'append',None)
&&& handler
&built-in method append of list object at 0xb7d4a52c&
&&& handler('cc')&&&&&&&&&&&&&&&&&&&&& #相当于li.append('cc')
['a','b','c','cc']
&&&result = handler('bb')
['a','b','c','cc','bb']
&&&print result
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具