python正则表达式详解
发布时间：2020-12-20 10:30:57 所属栏目：Python 来源：网络整理
导读：正则表达式是一个很强大的字符串处理工具，几乎任何关于字符串的操作都可以使用正则表达式来完成，正则表达式的在不同的语言中使用方式可能不一样，不过只要学会了任意一门语言的正则表达式用法，其他语言中大部分也只是换了个函数的名称而已，本质都是一样
|
正则表达式是一个很强大的字符串处理工具，几乎任何关于字符串的操作都可以使用正则表达式来完成，正则表达式的在不同的语言中使用方式可能不一样，不过只要学会了任意一门语言的正则表达式用法，其他语言中大部分也只是换了个函数的名称而已，本质都是一样的。下面，我来介绍一下python中的正则表达式是怎么使用的。 首先，python中的正则表达式大致分为以下几部分：
所有关于正则表达式的操作都使用 python 标准库中的 re 模块。 一、元字符 （参见 python 模块 re 文档）
二、模式
?
正则表达式的模式是可以同时使用多个的，在 python 里面使用按位或运算符 | 同时添加多个模式 如 re.compile(‘‘,re.I|re.M|re.S) 每个模式在 re 模块中其实就是不同的数字 print re.I # output> 2 print re.L # output> 4 print re.M # output> 8 print re.S # output> 16 print re.X # output> 64 print re.U # output> 32 三、函数 （参见 python 模块 re 文档） python 的 re 模块提供了很多方便的函数使你可以使用正则表达式来操作字符串，每种函数都有它自己的特性和使用场景，熟悉之后对你的工作会有很大帮助
给定一个正则表达式 pattern，指定使用的模式 flags 默认为0 即不使用任何模式,然后会返回一个 SRE_Pattern (参见?第四小节 re 内置对象用法) 对象 regex = re.compile(".+")
print regex
# output> <_sre.SRE_Pattern object at 0x00000000026BB0B8>
这个对象可以调用其他函数来完成匹配，一般来说推荐使用 compile 函数预编译出一个正则模式之后再去使用，这样在后面的代码中可以很方便的复用它，当然大部分函数也可以不用 compile 直接使用，具体见 findall 函数 s = ‘‘‘first line
second line
third line‘‘‘
#
regex = re.compile(".+")
# 调用 findall 函数
print regex.findall(s)
# output> [‘first line‘,‘third line‘]
# 调用 search 函数
print regex.search(s).group()
# output> first lin
转义 如果你需要操作的文本中含有正则的元字符，你在写正则的时候需要将元字符加上反斜扛 去匹配自身， 而当这样的字符很多时，写出来的正则表达式就看起来很乱而且写起来也挺麻烦的，这个时候你可以使用这个函数,用法如下 s = ".+d123"
#
regex_str = re.escape(".+d123")
# 查看转义后的字符
print regex_str
# output> .+d123
# 查看匹配到的结果
for g in re.findall(regex_str,s):
print g
# output> .+d123
参数 pattern 为正则表达式,string 为待操作字符串,flags 为所用模式，函数作用为在待操作字符串中寻找所有匹配正则表达式的字串，返回一个列表，如果没有匹配到任何子串，返回一个空列表。 s = ‘‘‘first line
second line
third line‘‘‘
# compile 预编译后使用 findall
regex = re.compile("w+")
print regex.findall(s)
# output> [‘first‘,‘third‘,‘line‘]
# 不使用 compile 直接使用 findall
print re.findall("w+",s)
# output> [‘first‘,‘line‘]
参数和作用与 findall 一样，不同之处在于 findall 返回一个列表， finditer 返回一个迭代器(参见http://www.cnblogs.com/huxi/archive/2011/07/01/2095931.html?)， 而且迭代器每次返回的值并不是字符串，而是一个?SRE_Match?(参见 第四小节 re 内置对象用法)?对象，这个对象的具体用法见 match 函数。 s = ‘‘‘first line
second line
third line‘‘‘
regex = re.compile("w+")
print regex.finditer(s)
# output> <callable-iterator object at 0x0000000001DF3B38>
for i in regex.finditer(s):
print i
# output> <_sre.SRE_Match object at 0x0000000002B7A920>
# <_sre.SRE_Match object at 0x0000000002B7A8B8>
# <_sre.SRE_Match object at 0x0000000002B7A920>
# <_sre.SRE_Match object at 0x0000000002B7A8B8>
# <_sre.SRE_Match object at 0x0000000002B7A920>
# <_sre.SRE_Match object at 0x0000000002B7A8B8>
使用指定正则去待操作字符串中寻找可以匹配的子串,返回匹配上的第一个字串，并且不再继续找，需要注意的是 match 函数是从字符串开始处开始查找的，如果开始处不匹配，则不再继续寻找，返回值为 一个 SRE_Match?(参见?第四小节 re 内置对象用法)?对象，找不到时返回 None s = ‘‘‘first line
second line
third line‘‘‘
# compile
regex = re.compile("w+")
m = regex.match(s)
print m
# output> <_sre.SRE_Match object at 0x0000000002BCA8B8>
print m.group()
# output> first
# s 的开头是 "f",但正则中限制了开始为 i 所以找不到
regex = re.compile("^iw+")
print regex.match(s)
# output> None
当你在程序中使用 re 模块，无论是先使用 compile 还是直接使用比如 findall 来使用正则表达式操作文本，re 模块都会将正则表达式先编译一下， 并且会将编译过后的正则表达式放到缓存中，这样下次使用同样的正则表达式的时候就不需要再次编译， 因为编译其实是很费时的，这样可以提升效率，而默认缓存的正则表达式的个数是 100,当你需要频繁使用少量正则表达式的时候，缓存可以提升效率，而使用的正则表达式过多时，缓存带来的优势就不明显了 (参考 《python re.compile对性能的影响》http://blog.trytofix.com/article/detail/13/)， 这个函数的作用是清除缓存中的正则表达式，可能在你需要优化占用内存的时候会用到。
函数类似于 match，不同之处在于不限制正则表达式的开始匹配位置 s = ‘‘‘first line second line third line‘‘‘ # 需要从开始处匹配 所以匹配不到 print re.match(‘iw+‘,s) # output> None # 没有限制起始匹配位置 print re.search(‘iw+‘,s) # output> <_sre.SRE_Match object at 0x0000000002C6A920> print re.search(‘iw+‘,s).group() # output> irst
参数 maxsplit 指定切分次数， 函数使用给定正则表达式寻找切分字符串位置，返回包含切分后子串的列表，如果匹配不到，则返回包含原字符串的一个列表 s = ‘‘‘first 111 line second 222 line third 333 line‘‘‘ # 按照数字切分 print re.split(‘d+‘,s) # output> [‘first ‘,‘ linensecond ‘,‘ linenthird ‘,‘ line‘] # .+ 匹配不到 返回包含自身的列表 print re.split(‘.+‘,s,1) # output> [‘first 111 linensecond 222 linenthird 333 line‘] # maxsplit 参数 print re.split(‘d+‘,1) # output> [‘first ‘,‘ linensecond 222 linenthird 333 line‘] ?
替换函数，将正则表达式 pattern 匹配到的字符串替换为 repl 指定的字符串,? 参数 count 用于指定最大替换次数 s = "the sum of 7 and 9 is [7+9]."
# 基本用法 将目标替换为固定字符串
print re.sub(‘[7+9]‘,‘16‘,s)
# output> the sum of 7 and 9 is 16.
# 高级用法 1 使用前面匹配的到的内容 1 代表 pattern 中捕获到的第一个分组的内容
print re.sub(‘[(7)+(9)]‘,r‘21‘,s)
# output> the sum of 7 and 9 is 97.
# 高级用法 2 使用函数型 repl 参数,处理匹配到的 SRE_Match 对象
def replacement(m):
p_str = m.group()
if p_str == ‘7‘:
return ‘77‘
if p_str == ‘9‘:
return ‘99‘
return ‘‘
print re.sub(‘d‘,replacement,s)
# output> the sum of 77 and 99 is [77+99].
# 高级用法 3 使用函数型 repl 参数,处理匹配到的 SRE_Match 对象 增加作用域 自动计算
scope = {}
example_string_1 = "the sum of 7 and 9 is [7+9]."
example_string_2 = "[name = ‘Mr.Gumby‘]Hello,[name]"
def replacement(m):
code = m.group(1)
st = ‘‘
try:
st = str(eval(code,scope))
except SyntaxError:
exec code in scope
return st
# 解析: code=‘7+9‘
# str(eval(code,scope))=‘16‘
print re.sub(‘[(.+?)]‘,example_string_1)
# output> the sum of 7 and 9 is 16.
作用与函数 sub 一样， 唯一不同之处在于返回值为一个元组，第一个值为替换后的字符串，第二个值为发生替换的次数
这个吧，咋一看和 compile 差不多，不过不支持 +、？、*、｛｝ 等这样的元字符，只要是需要有重复功能的元字符，就不支持，查了查资料，貌似没人知道这个函数到底是干嘛的... ? 四、re 内置对象用法
属性：
函数：可使用 findall、finditer、match、search、split、sub、subn 等函数
属性：
函数：
五、分组用法 ??? python 的正则表达式中用小括号 "(" 表示分组，按照每个分组中前半部分出现的顺序 "(" 判定分组的索引，索引从 1 开始，每个分组在访问的时候可以使用索引，也可以使用别名 s = ‘Hello,Mr.Gumby : 2016/10/26‘
p = re.compile("(?P<name>w+.w+).*?(d+)(?#comment)")
m = p.search(s)
# 使用别名访问
print m.group(‘name‘)
# output> Mr.Gumby
# 使用分组访问
print m.group(2)
# output> 2016
??? 有时候可能只是为了把正则表达式分组，而不需要捕获其中的内容，这时候可以使用非捕获分组 s = ‘Hello,Mr.Gumby : 2016/10/26‘
p = re.compile("""
(?: # 非捕获分组标志 用于使用 |
(?P<name>w+.w+)
|
(d+/)
)
""",re.X)
m = p.search(s)
# 使用非捕获分组
# 此分组将不计入 SRE_Pattern 的 分组计数
print p.groups
# output> 2
# 不计入 SRE_Match 的分组
print m.groups()
# output> (‘Mr.Gumby‘,None)
??? 如果你在写正则的时候需要在正则里面重复书写某个表达式，那么你可以使用正则的引用分组功能，需要注意的是引用的不是前面分组的?正则表达式?而是捕获到的?内容，并且引用的分组不算在分组总数中. s = ‘Hello,Mr.Gumby : 2016/2016/26‘
p = re.compile("""
(?: # 非捕获分组标志 用于使用 |
(?P<name>w+.w+)
|
(d+/)
)
.*?(?P<number>d+)/(?P=number)/
""",re.X)
m = p.search(s)
# 使用引用分组
# 此分组将不计入 SRE_Pattern 的 分组计数
print p.groups
# output> 3
# 不计入 SRE_Match 的分组
print m.groups()
# output> (‘Mr.Gumby‘,None,‘2016‘)
# 查看匹配到的字符串
print m.group()
# output> Mr.Gumby : 2016/2016/
? 六、环视用法 环视还有其他的名字，例如 界定、断言、预搜索等，叫法不一。 环视是一种特殊的正则语法，它匹配的不是字符串，而是?位置，其实就是使用正则来说明这个位置的左右应该是什么或者应该不是什么，然后去寻找这个位置。 环视的语法有四种，见第一小节元字符，基本用法如下。 s = ‘Hello,Mr.Gumby : 2016/10/26 Hello,r.Gumby : 2016/10/26‘
# 不加环视限定
print re.compile("(?P<name>w+.w+)").findall(s)
# output> [‘Mr.Gumby‘,‘r.Gumby‘]
# 环视表达式所在位置 左边为 "Hello,"
print re.compile("(?<=Hello,)(?P<name>w+.w+)").findall(s)
# output> [‘Mr.Gumby‘]
# 环视表达式所在位置 左边不为 ","
print re.compile("(?<!,)(?P<name>w+.w+)").findall(s)
# output> [‘Mr.Gumby‘]
# 环视表达式所在位置 右边为 "M"
print re.compile("(?=M)(?P<name>w+.w+)").findall(s)
# output> [‘Mr.Gumby‘]
# 环视表达式所在位置 右边不为 r
print re.compile("(?!r)(?P<name>w+.w+)").findall(s)
# output> [‘Mr.Gumby‘]
高级一些的例子参见《正则基础之——环视(Lookaround)》(http://www.cnblogs.com/kernel0815/p/3375249.html) ? 参考文章： 《Python正则表达式指南》(http://www.cnblogs.com/huxi/archive/2010/07/04/1771073.html) 《Python 正则式学习笔记?》(http://www.voidcn.com/article/p-njlxwgtf-tn.html) （编辑：李大同） 【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容! |