python学习6:正则表达式
正则表达式格式
正则表达式包含一个元字符(metacharacter)的列表，列表值如下: . ^ $ * + ? {} [ ] \ | ( )
1.元字符([ ])，它用来指定一个character class。所谓character class就是你想要匹配的字符(character)的集合.字符(character)可以单个的列出，也可以通过"-"来分隔两个字符来表示一个范围。例如，[abc]匹配，b或者c当中任意一个字符，[abc]也可以用字符区间来表示[a-c]。如果想要匹配单个大写字母，你可以用[A-Z]。元字符(metacharacters)在character class里面不起作用，如[akm$]将匹配"a","k","m","$"中的任意一个字符。在这里元字符(metacharacter)"$"就是一个普通字符。
2.元字符[^]，你可以用补集来匹配不在区间范围内的字符。其做法是把"^"作为类别的首个字符；其它地方的"^"只会简单匹配 "^"字符本身。例如，[^5] 将匹配除 "5" 之外的任意字符。同时，在[ ]外，元字符^表示匹配字符串的开始，如"^ab+"表示以ab开头的字符串。
3.元字符(\)，元字符backslash，做为 Python 中的字符串字母，反斜杠后面可以加不同的字符以表示不同特殊意义。它也可以用于取消所有的元字符，这样你就可以在模式中匹配它们了。例如，如果你需要匹配字符 "[" 或 "\"，你可以在它们之前用反斜杠来取消它们的特殊意义： \[ 或 \\
4.元字符($)，匹配字符串的结尾或者字符串结尾的换行之前。（在MULTILINE模式下，"$"也匹配换行之前）
5.元字符(*)，匹配0个或多个
6.元字符(?)，匹配一个或者0个，非贪婪匹配应用：*,+,?都是贪婪匹配模式，*?, +?, ??则是非贪婪匹配模式
7.元字符(+)，匹配一个或者多个
8.元字符(|)，表示"或"，如A|B，其中A，B为正则表达式，表示匹配A或者B
9.元字符({})，{m},用来表示前面正则表达式的m次copy，如"a{5}"，表示匹配5个”a”,即"aaaaa"， {m.n}用来表示前面正则表达式的m到n次copy,尝试匹配尽可能多的copy，优先匹配n，而不是m。{m,n}? 用来表示前面正则表达式的m到n次copy，尝试匹配尽可能少的copy
10.元字符(( ))，用来表示一个group的开始和结束。比较常用的有(REs),(?P<name>REs),这是无名称的组和有名称的group，有名称的group，可以通过matchObject.group(name)获取匹配的group，而无名称的group可以通过从1开始的group序号来获取匹配的组，如matchObject.group(1)
11.元字符(.)，在默认模式下，匹配除换行符外的所有字符。在DOTALL模式下，匹配所有字符，包括换行符
模块内容
re.compile(pattern, flags=0)
编译正则表达式，返回RegexObject对象，然后可以通过RegexObject对象调用match()和search()方法。
prog = re.compile(pattern)
result = prog.match(string)
跟
result = re.match(pattern, string)
是等价的。第一种方式能实现正则表达式的重用。
编译标志：编译标志让你可以修改正则表达式的一些运行方式。在re模块中标志可以使用两个名字，一个是全名如IGNORECASE，一个是缩写，一字母形式如 I。多个标志可以通过按位或来指定。如 re.I | re.M 被设置成 I 和 M 标志：
I
IGNORECASE
使匹配对大小写不敏感；字符类和字符串匹配字母时忽略大小写。举个例子，[A-Z]也可以匹配小写字母，Spam 可以匹配 "Spam", "spam", 或 "spAM"。这个小写字母并不考虑当前位置。
L
LOCALE
影响 "w, "W, "b, 和 "B，这取决于当前的本地化设置。
locales是C语言库中的一项功能，是用来为需要考虑不同语言的编程提供帮助的。举个例子，如果你正在处理法文文本，你想用 "w+ 来匹配文字，但 "w 只匹配字符类 [A-Za-z]；它并不能匹配 "é" 或 "?"。如果你的系统配置适当且本地化设置为法语，那么内部的C函数将告诉程序 "é" 也应该被认为是一个字母。当在编译正则表达式时使用LOCALE标志会得到用这些 C 函数来处理 "w 后的编译对象；这会更慢，但也会象你希望的那样可以用 "w+ 来匹配法文文本。
M
MULTILINE
(此时 ^ 和 $ 不会被解释)
默认使用 "^" 只匹配字符串的开始，而 $ 则只匹配字符串的结尾和直接在换行前（如果有的话）的字符串结尾。当本标志指定后， "^" 匹配字符串的开始和字符串中每行的开始。同样的，$ 元字符匹配字符串结尾和字符串中每行的结尾（直接在每个换行之前）。
S
DOTALL
使 "." 特殊字符完全匹配任何字符，包括换行；没有这个标志， "." 匹配除了换行外的任何字符。
X
VERBOSE
该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。当该标志被指定时，在 RE 字符串中的空白符被忽略，除非该空白符在字符类中或在反斜杠之後；这可以让你更清晰地组织和缩进 RE。它也可以允许你将注释写入RE，这些注释会被引擎忽略；注释用 "#"号 来标识，不过该符号不能在字符串或反斜杠之后。
DEBUG
打印debug信息
re.search(pattern, string, flags=0)
在字符串中查找，是否能匹配正则表达式。返回_sre.SRE_Match对象，如果不能匹配返回None。
re.match(pattern, string, flags=0)
字符串的开头是否能匹配正则表达式。返回_sre.SRE_Match对象，如果不能匹配返回None。martch和search的区别：match是从字符串的起点开始做匹配，而search是从字符串做任意匹配.当正则表达式是'^'开头时，match与search是相同的。match当且仅当被匹配的字符串开头能匹配(或从pos参数的位置开始就能匹配)才会成功。
re.split(pattern, string, maxsplit=0)
通过正则表达式将字符串分离。如果用括号将正则表达式括起来，那么匹配的字符串(即分隔符)也会被列入到list中返回。maxsplit是分离的次数，maxsplit=1分离一次，默认为0，不限制次数。如果在字符串的开始或结尾就匹配，返回的list将会以空串开始或结尾。如果字符串不能匹配，将会返回整个字符串的list。
re.findall(pattern, string, flags=0)
找到RE匹配的所有子串,并把它们作为一个列表返回。这个匹配是从左到右有序地返回。如果无匹配，返回空列表。
re.finditer(pattern, string, flags=0)
找到 RE 匹配的所有子串，并把它们作为一个迭代器返回。这个匹配是从左到右有序地返回。如果无匹配，返回空列表。
re.sub(pattern, repl, string, count=0, flags=0)
找到 RE 匹配的所有子串，并将其用一个不同的字符串替换。可选参数 count 是模式匹配後替换的最大次数；count 必须是非负整数。缺省值是 0 表示替换所有的匹配。如果无匹配，字符串将会无改变地返回。
re.subn(pattern, repl, string, count=0, flags=0)
与re.sub方法作用一样，但返回的是包含新字符串和替换执行次数的两元组。
re.escape(string)
对字符串中的非字母数字进行转义
re.purge()
清空缓存中的正则表达式
正则表达式对象
re.RegexObject
re.compile()返回RegexObject对象;
re.RegexObject的方法属性，注意与re直接调用的不同：
search(string[, pos[, endpos]])
match(string[, pos[, endpos]])
split(string, maxsplit=0)
findall(string[, pos[, endpos]])
finditer(string[, pos[, endpos]])
sub(repl, string, count=0)
subn(repl, string, count=0)
re.MatchObject
由search/match方法返回
常用方法：
group([group1, ...]):返回匹配到的一个或多个子组。如果是一个参数,结果就是一个字符串;如果是多个参数,结果就是一个元组。group1的默认值为0(将返回所有的匹配值)，如果组号是负的或者比pattern中定义的组号大，那么将抛出IndexError异常。如果一个pattern可以匹配多个，那么组对应的是样式匹配的最后一个。另外，子组是根据括号从左向右来进行区分的。
groups([default]):返回一个包含所有子组的元组。Default用来设置没有匹配到的默认值的，默认是"None”
groupdict([default]):返回匹配到的所有命名子组的字典。key是命名值，value是匹配值。参数default是没有匹配到的默认值，默认为"None"，groupdict()对没有命名的子组不起作用
start([group]):返回匹配开始的位置，group默认值为0，指示整个匹配的开始位置，可以配置为N表示第N个匹配，下同
end([group]):返回匹配结束的位置
span([group]):返回一个元组包含匹配 (开始,结束) 的位置
例子
MatchObject.group()
>>> import re
>>> m = re.match(r"((\d.)+)(.*)","1a2b3cdd")
>>> print m.group()
1a2b3cdd
>>> print m.group(1)
1a2b3c
>>> print m.group(2)
3c
>>> print m.group(3)
dd
>>> print m.group(2,3)
('3c', 'dd')
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
MatchObject.groups()
>>> m = re.match(r"(\d+)\.(\d+)", "24.1632")
>>> m.groups()
('24', '1632')
>>> m = re.match(r"(\d+)\.?(\d+)?", "24")
>>> m.groups() # Second group defaults to None.
('24', None)
>>> m.groups('0') # Now, the second group defaults to '0'.
('24', '0')
MatchObject.groupdict()
>>> import re
>>> m=re.match("(\w+) (\w+)","hello world")
>>> print m.groupdict()
{}
>>> import re
>>> m=re.match("(?P<first>\w+) (?P<second>\w+)","hello world")
>>> print m.groupdict()
{'second': 'world', 'first': 'hello'}
MatchObject.start() 和MatchObject.end()
>>> email = "tony@tiremove_thisger.net"
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
'tony@tiger.net'
MatchObject.span()
>>> import re
>>> m = re.match(r"((\d.)+)(.*)","1a2b3cdd")
>>> print m.span()
(0, 8)
>>> print m.span(3)
(6, 8)
RegexObject.search(string[, pos[, endpos]])
>>> import re
>>> pattern = re.compile("d")
>>> print pattern.search("dog",1,5)
None
>>> print pattern.search("dogdog",1,5).group()
d
RegexObject.match(string[, pos[, endpos]])
>>> import re
>>> pattern = re.compile("d")
>>> print pattern.match("goddog")
None
>>> print pattern.match("goddog",2,5).group()
d
RegexObject.split(string, maxsplit=0)
>>> import re
>>> pattern = re.compile("\W+")
>>> print pattern.split('Words, words, words.')
['Words', 'words', 'words', '']
>>> pattern = re.compile("(\W+)")
>>> print pattern.split('Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> print pattern.split('...words, words...')
['', '...', 'words', ', ', 'words', '...', '']
>>> print pattern.split('words')
['words']
RegexObject.findall(string[, pos[, endpos]])
import re
pattern=re.compile('^a\d',re.M)
print pattern.findall('ba0\na1a2\ba3a4')
print pattern.findall('ba0\na1a2\ba3a4',1)
pattern=re.compile('a\d',re.M)
print pattern.findall('ba0\na1a2\ba3a4',2,5)
print pattern.findall('ba0\na1a2\ba3a4',2,6)
#print
['a1']
['a1']
[]
['a1']
RegexObject.finditer(string[, pos[, endpos]])
import re
pattern = re.compile("\d+")
r=pattern.finditer('12a32bc43jf3',1,7)
for m in r:
print m.group()
#print
2
32
RegexObject.sub(repl, string, count=0)
import re pattern = re.compile("\d+") print pattern.sub('*','12a32bc43jf3') print pattern.sub('*','12a32bc43jf3',2) #print *a*bc*jf* *a*bc43jf3
RegexObject.subn(repl, string, count=0)
import re pattern = re.compile("\d+") print pattern.subn('*','12a32bc43jf3') print pattern.subn('*','12a32bc43jf3',2) #print ('*a*bc*jf*', 4) ('*a*bc43jf3', 2)
浙公网安备 33010602011771号