正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符是否与某种模式匹配。
Python1.5版本提供了re模块，该模块提供所有的正则表达式功能
使用re模块，首先导入re模块：import re
| 模式 | 描述 | 例子 | 是否重点 |
|---|---|---|---|
^ |
匹配字符串的开头。 | √ | |
$ |
匹配字符串的末尾。 | √ | |
. |
匹配任意字符，除了换行符\n，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。 |
||
[...] |
用来表示一组字符，表示范围。 | 例如：单独列出：[amk]匹配 ‘a‘,‘m‘或者 ‘k‘， |
|
[^...] |
匹配不在 [] 中的字符。 |
例如： [^abc]匹配除了a,b,c之外的字符 |
|
re* |
匹配0个或者多个的表达式。 | √ | |
re+ |
匹配1个或者多个的表达式。 | √ | |
re? |
匹配0个或者1个由前面的正则表达式定义的片段，非贪婪方式。 | √ | |
re{n} |
精确匹配n个前面表达式。 | 例如： o{2}不能匹配“Bob”中的“o”，但是能匹配“food”中的两个“o”。 |
√ |
re{n,} |
匹配 至少n个 前面表达式。 | 例如： o{2,}不能匹配“Bob”中的“o”，但是能匹配“fooooood”中的所有“o”。o{1,} == o+ 。 o{0,} == o* |
√ |
re{n,m} |
匹配 n-m次 由前面的正则表达式定义的片段，贪婪方式。 | 例如：o{2,3}不能匹配“Bob”中的“o”，但是能匹配“food”|“foood”中的“o”。 |
√ |
a|b |
匹配 a或者b | 例如： P|python 匹配Python和python |
√ |
(re) |
对正则表达式 分组 并且记住匹配的文本 | √ | |
(?imx) |
正则表达式包含三种可选标志：i,m,x。只影响括号中的区域。 |
||
(?-imx) |
正则表达式关闭 i,m,x可选标志。只影响括号中的区域。 |
||
(?: re) |
类似 (...)，但是不表示一个组。 |
||
(?imx: re) |
在括号中使用 i,m,x 可选标志。 |
||
(?-imx: re) |
在括号中不使用 i,m,x 可选标志。 |
||
(?#...) |
注释。 | ||
(?= re) |
前向肯定定位符。 | ||
(?| re) |
前向否定定位符。 | ||
(?> re) |
匹配的独立模式，省去回溯。 | ||
\w |
匹配字母数字下划线。 | ||
\W |
匹配非字母数字下划线 | ||
\s |
匹配 任意空白字符 ，等价于 [\t\n\r\f]。 |
||
\S |
匹配 任意非空白字符 。 | ||
\d |
匹配任意 数字，等价于 [0-9] |
||
\D |
匹配任意 非数字 | ||
\A |
匹配字符串开始 | ||
\Z |
匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串 | ||
\z |
匹配字符串结束 | ||
\G |
匹配最后匹配完成的位置 | ||
\b |
匹配 一个单词 边界，也就是指单词和空格间的位置。 | 例如：‘er\b‘能匹配"never"中的er，但不能匹配"verb"中的er |
|
\B |
匹配 非单词 边界。 | 例如：‘er\B‘能匹配"verb"中的er，但不能匹配"never"中的er |
|
\n,\t,等 |
匹配一个换行符。匹配一个制表符。等 | ||
\1...\9 |
匹配第n个分组的内容。 | ||
\10 |
匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。 |
[Pp]ython：匹配 "Python|python"。类似于P|python
rub[ye]：匹配"ruby|rube"。类似于ruby|e
[aeiou]：匹配中括号内的任意一个字符。
[0-9]：匹配任何数字。类似于[0123456789]
[a-z]：匹配任何小写字母。
[A-Z]：匹配任何大写字母
[a-zA-Z0-9]：匹配任何字母和数字。类似于
[^aeiou]：匹配除了aeiou之外的所有字符
[^0-9]：匹配除了数字外的字符
pattern：匹配的正则表达式。
string：要匹配的字符串。
repl：替换的字符串，也可以为一个函数
count：模式匹配后替换的最大次数，默认0表示替换所有的匹配。
flags：标志位，可用于控制正则表达式的匹配方式，如是否区分大小写，多行匹配等。
re.I：使匹配对大小写不敏感
re.L：做本地化识别匹配
re.M：多行匹配，影响 ^和$
re.S：使 . 匹配包括换行以内的所有字符
re.U：根据Unicode字符集解析字符。这个标志影响\W,\w,\b,\B。
re.X：该标志通过给予你更灵活的格式以便你将正则表达式写得更容易理解。
re.match(pattern,string,flags=0)
re.match()尝试从字符串的起始位置匹配一个模式，
匹配成功re.match()返回一个匹配的对象。
如果不是起始位置匹配成功的话，re.match()就返回None；
我们可以使用group(num)|groups()匹配对象函数获取匹配表达式。
group(num=0)：匹配的整个表达式的字符串。group()可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
groups()：返回一个包含所有小组字符串的元组，从1到所含的小组号。
import re
?
# 在起始位置匹配
print(re.match(‘www‘,"www.xw.com").span())
# 不在起始位置匹配
print(re.match(‘com‘,‘www.xw.com‘))
?
"""---------------------------------------"""
line = "Cat are smarter than dogs"
"""
re.match(pattern,string,flags)
‘‘‘
.：匹配一个任意字符
re*：匹配 >=0个 的表达式。.*：匹配任意个任意字符
re?：匹配 0|1个 由前面的正则表达式定义的片段。
‘‘‘
"""
# .*：匹配任意个任意字符。
# .*?：
matchObj = re.match(r‘(.*) are (.*?) .*‘,line,re.I|re.M)
?
if matchObj:
print("matchObj.group()：",matchObj.group())
print("matchObj.group(1)：",matchObj.group(1))
print("matchObj.group(2)：",matchObj.group(2))
print("matchObj.groups()：",matchObj.groups())
re.search(pattern,string,flags=0)
re.search()扫描整个字符串，并且返回第一个成功的匹配。
匹配成功：re.search()返回一个匹配的对象
匹配失败：re.search()返回None
我们可以使用group(num)|groups()匹配对象函数获取匹配表达式。
group(num=0)：匹配的整个表达式的字符串。group()可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
groups()：返回一个包含所有小组字符串的元组，从1到所含的小组号。
import re
?
# 在起始位置匹配
print(re.search(‘www‘,"www.xw.com").span())
# 不在起始位置匹配
print(re.search(‘com‘,‘www.xw.com‘).span())
?
"""---------------------------------------"""
line = "Cat are smarter than dogs"
"""
re.search(pattern,string,flags)
‘‘‘
.：匹配一个任意字符
re*：匹配 >=0个 的表达式。.*：匹配任意个任意字符
re?：匹配 0|1个 由前面的正则表达式定义的片段。
‘‘‘
"""
# (.*)：匹配任意个任意字符，并且分组。
# (.*?)：匹配任意个任意字符，
searchObj = re.search(r‘(.*) are (.*?) .*‘,line,re.I|re.M)
?
if searchObj:
print("searchObj.group()：",searchObj.group())
print("searchObj.group(1)：",searchObj.group(1))
print("searchObj.group(2)：",searchObj.group(2))
print("searchObj.groups()：",searchObj.groups())
re.search与re.match的区别：
re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None
re.search匹配整个字符串，直到找到第一个匹配。
re.sub(pattern,repl,string,count=0,flags=0)
用于替换字符串中的匹配项。
import re
"""
re.sub(pattern,repl,string,count=0,flags=0)
"""
?
# repl为普通参数：
phone = "133-8716-6270 #注释"
?
# 删除字符串中的 #注释
num = re.sub(r‘#.*$‘," ",phone)
print("电话号码：",num)
?
# 删除非数字 -
num = re.sub(r‘\D‘,‘‘,phone)
print("电话号码：",num)
?
# repl为函数：
# 将匹配的数字 *2
def double(matched):
value = int(matched.group(‘value‘))
return str(value *2)
?
s = ‘AAAA##$$$$33456‘
print(re.sub(‘(?P<value>\d+)‘,double,s))
re.compile(pattern[,flags])
re.compile()函数用于编译正则表达式，生成一个表达式（Pattern）对象，给match()和search()这两个函数使用。
import re
?
# 用于匹配至少一个数字
pattern = re.compile(r‘\d+‘)
?
# 查找头部，没有匹配
m = pattern.match(‘one12twossfaf34fag‘)
print(m)
?
# 从字符串索引为(3-14)的位置匹配，匹配成功
m = pattern.match(‘one12twossfaf34fag‘,3,14)
print(m)
?
print(m.group())
print(m.start())
print(m.end())
print(m.span())
group([group1],...)
方法用于获取一个或者多个分组匹配的字符串，当要获取整个匹配的子串时，可直接使用group()|groups()
start([group])
方法用于获取分组匹配的子串在整个字符串中的起始位置（子串第一个字符的索引），参数默认值为0
end([group])
方法用于获取分组匹配的子串在整个字符串中的结束位置（子串最后一个字符的索引+1），参数默认值为0
span([group])
方法返回(start(group) , end(group))
findall(string[,pos[,endpos]])
在字符串中找到正则表达式所匹配的所有子串，并且返回一个列表，如果没有找到匹配的，则返回空列表。
match和search是匹配一次findall匹配所有。
参数：
string：待匹配的字符串
pos：可选参数，指定字符串的起始位置，默认为0
endpos：可选参数，指定字符串的结束位置，默认是字符串的长度。
re.finditer(pattern,string,flags=0)
和findall类似，在字符串中找到正则表达式所匹配的所有子串，并且它们作为一个迭代器返回。
import re
?
# findall：
pattern = re.compile(r‘\d+‘) #查找数字
result1 = pattern.findall(‘rnoob 1414‘)
result2 = pattern.findall(‘rnoob1afsafasf21g5gr155161‘,5,77)
print(result1)
print(result2)
?
# re.finditer：
it = re.finditer(r‘\d+‘,"121415fag516 afag")
for m in it:
print(m.group())
re.split(pattern,string[,maxsplit=0,flags=0])
re.split()方法安照能够匹配的子串将字符串分割后返回列表。
参数：
maxsplit：分割次数，maxsplit=1分割一次，默认为0，不限制次数。
import re
?
cut = ‘11fag51,53-52sg,,g3 y6shsgl‘
?
print(re.split(‘\W+‘,cut))
print(re.split(‘\d+‘,cut))
re.compile()返回 RegexObject对象
group()返回被RE匹配的字符串
start()：返回匹配开始的位置
end()：返回匹配结束的位置
span()：返回一个元组包含匹配（开始，结束）的位置。
原文：https://www.cnblogs.com/bright-future/p/14727809.html