Python 中的正则表达式全部用法速查

参考链接： Python中的正则表达式 2(搜索，匹配和查找全部)

正则表达式 

正则语法 

特性 

正则表达式可以拼接,如果A和B都是正则表达式,那么 AB也是正则表达式.如果字符串p匹配A并且另一个字符串q匹配B, 那么pq可以匹配 AB.这就构成了由简单构建复杂的基础.除非: 

  A或者B包含低优先级操作A和B存在边界条件存在命名组引用。  

字符 

元字符 : 特殊字符 

它们不匹配自己,在正则中具有其它的意义,匹配自己需要转义. 

元字符的完整列表: 

基础字符 

字符功能\转义[ ]匹配一类单个字符,在里面的字符除了[- ^ \s \S \d \D \w \W] 都是普通字符()分组.与数学中括号的作用大致相同.将括号内的内容视作一个独立字符或部分.

零宽度断言 

它们不用来代表字符,用来实现一些特殊的匹配功能 

字符功能|“or”运算符,优先级非常低.存在短路现象^[ ]内字符集的取反,或写在模式开头,代表以模式开头.MULTILINE 模式中,可以匹配在换行符之后的字符串内的任何位置。$写在模式结尾,代表以模式结尾.只有\n在结尾也算匹配成功\A不在 MULTILINE 模式时,和 ^ 相同.MULTILINE 模式中,\A 仍然只在字符串开头匹配\Z只匹配字符串尾\b匹配完整单词,前后都是非字母数字字符:r'\bclass\b'.必须使用r'',因为Python会把\b解析为退格\B不在字边界时才匹配\number匹配数字代表的组合

重复限定 

它们不能直接嵌套使用,避免了非贪婪后缀 ? 修饰符，和其他实现中的修饰符产生的多义性可以使用括号包围再进行嵌套 

字符功能.匹配一个任意字符一次,是否包括换行符取决于DOTALL参数{m,n}匹配前一个字符的出现次数范围, m<=出现次数<=n. 可以缺省其中一个,视为0或无上限{m}匹配前一个字符的m个重复,少于 m 的话就会导致匹配失败*{0,} 它的匹配是 贪婪的,先尽可能多地匹配,不成功再回退.+{1,}?{0,1}, 代表一个可选字符.还可做非贪婪后缀修饰符

一类单个字符 

语法含义同义替换[abc]a 或 b 或 ca|b|c[a-z]a-z 所有字符[^5]除了5所有的字符\d数字[0-9]\D非数字[^0-9]\s空白符[\t\n\r\f\v]\S非空白符[^ \t\n\r\f\v]\w大小写字母与数字[a-zA-Z0-9_ ]\W非字母与数字[^a-zA-Z0-9_ ]

Python 中的正则 – re 模块 

参考链接 

 Python re模块 官方文档 

 Python 正则入门 官方教程 

特性 

模式和被搜索的字符串既可以是 Unicode 字符串str ，也可以是8位字节串bytes.但不能混用.反斜杠灾难: python字符串中和正则中 / 都是转义字符,所以需要二次转义.正则中一个 ‘/’ 在字符串中就会写成 ‘’.解决方法是尽量使用 Python 的原始字符串表示法,在字符串前加 r ,例如: r’/'第三方模块regex, 提供了与标准库re模块兼容的API接口, 同时还提供了额外的功能和更全面的Unicode支持。正则表达式模式被编译成一系列字节码，然后由用 C 编写的匹配引擎执行.适当选择代码和正则: 虽然 Python 代码比精心设计的正则表达式慢，但它也可能更容易理解.是Python附带的C扩展模块 

API 

编译正则 

import re

p = re.compile('ab*')

//还可以接受一个可选的flag参数,用于启用各种特殊功能和语法变体

re.compile('ab*',re.IGNORECASE)

编译标志(选项) 

标志(前加 re.)缩写含义ASCIIA使几个转义如 \w、\b、\s 和 \d 仅与具有相应的 ASCII 字符匹配而不是完整匹配UnicodeDOTALLS使 . 匹配任何字符,包括换行符,否则不包括换行符IGNORECASEI忽略大小写LOCALEL进行区域设置感知匹配,应用于考虑到语言差异的程序MULTILINEM多行匹配，将每行(以换行符为分割)视作单独的字符串.VERBOSEX忽略正则中不在字符类里的空格将被忽略.使用户可以使用**空格,缩进,注释(#)**美化正则的格式DEBUG无显示编译时的debug信息

# VERBOSE

pat = re.compile(r"""

 \s*                 # Skip leading whitespace

 (?P<header>[^:]+)   # Header name

 \s* :               # Whitespace, and a colon

 (?P<value>.*?)      # The header's value -- *? used to

                     # lose the following trailing whitespace

 \s*$                # Trailing whitespace to end-of-line

""", re.VERBOSE)

匹配方法 

正则对象的方法和属性 

方法/属性 - 正则编译后的对象.方法名()功能match('字符串'[,起始位置[,结束位置]])从字符串开头开始匹配,返回匹配对象search('字符串'[,起始位置[,结束位置]])找到第一个匹配成功的子字符串,返回匹配对象findall('字符串'[,起始位置[,结束位置]])找到并用列表返回所有匹配的子字符串finditer('字符串'[,起始位置[,结束位置]])找到并返回所有匹配成功的匹配对象的iteratorfullmatch('字符串'[,起始位置[,结束位置]])对被查找串的完整匹配,相当于加了[^…$],返回匹配对象split('字符串',最大分割数=0)在正则匹配的所有地方将其拆分为列表.默认分割所有.就地sub('表达式','字符串',替换次数=0)替换匹配到的位置,默认替换所有.就地subn('表达式','字符串',替换次数=0)与 sub() 相同,但返回新字符串和替换次数.就地flags标记 参数 选项groups捕获组合的数量groupindex命名捕获组的字典,如果没有命名捕获组则字典为空pattern编译对象的原始样式字符串

模块的顶级方法 

 顶级函数允许同时传入正则表达式和要匹配的字符串,返回值和re.compile下方法的返回值相同  但是如果需要多次匹配,且正则表达式相同,则会进行很多次不必要的编译  每个函数还能在后面传入一个可选的标志参数,只能有一个标志  

方法/属性 - re.方法名()功能match('表达式','字符串',标志)从字符串开头开始匹配,返回匹配对象search('表达式','字符串',标志)找到第一个匹配成功的子字符串,返回匹配对象findall('表达式','字符串',标志)找到并用列表返回所有匹配的子字符串finditer('表达式','字符串',标志)找到并返回所有匹配成功的匹配对象的iteratorfullmatch('表达式','字符串',标志)对被查找串的完整匹配,相当于加了[^…$],返回匹配对象split('表达式','字符串',切割次数=0,标志)在正则匹配的所有地方将其拆分为列表.默认分割所有.就地sub('表达式','替换内容','字符串',替换次数=0,标志)替换匹配到的位置,默认替换所有.就地subn('表达式','替换内容','字符串',替换次数=0,标志)与 sub() 相同,但返回新字符串和替换次数.就地escape('表达式')将字符串中出现的正则元字符进行转义purge()清除正则表达式缓存error(*msg*, *pattern=None*, *pos=None*)返回一个生成的编译错误异常

匹配(结果)对象 

可以给group(),start(),end(),span()传入参数分组的序号,以获取模式中特定分组匹配到的内容.默认参数为0. 

组从0开始从左到右编号,它始终存在.要确定编号,只需计算从左到右的左括号字符. 

方法/属性 - m.方法名()功能group(分组引用1,引用2...)返回指定分组引用(数字和命名引用)匹配到的字符串,默认为引用0,即全局匹配结果__getitem__(分组引用)等价于m.group(g),允许更方便的引用一个匹配groups(分组未匹配到内容的默认值=None)返回一个元组，其中包含所有子组的字符串，从1开始所有子组groupdict(分组未匹配到内容的默认值=None)返回一个包含所有的命名子组的字典start(分组引用=0)返回匹配成功的开始位置,否则返回 -1end(分组引用=0)返回匹配成功的结束位置,否则返回 -1span(分组引用=0)返回元组: ( 开始位置 , 结束位置 ),未匹配到返回 ( -1,-1 )expand('转义模板')将结果集合中的元素,根据数字和命名引用填入到转义模板字符串的指定位置pos正则引擎开始搜索的索引位置endPos正则引擎结束搜索的索引位置lastindex最后一个匹配的组的数字引用,如果没有则为Nonelastgroup最后一个匹配的命名组的名字,如果没有则为Nonere返回产生这个实例的正则对象string返回被匹配的字符串

import re

# 一个处理匹配结果的小例子

m=re.compile('[a-z]+').match('string goes here')

print(m.group() if m else "匹配失败")  #根据结果m决定后续操作

#"string"

# 一个完整的例子

pattern = re.compile(r'(\w+) (\w+) (?P<word>.*)')

match = pattern.match('I love you!')

print("match.group(1,2):",match.group(1,2))

print("match[1]:",match[1])

print("match.groups():",match.groups())

print("match.groupdict():",match.groupdict())

print("match.start(2):",match.start(2))

print("match.end(2):",match.end(2))

print("match.span(2):",match.span(2))

print("match.expand(r'\\2 \\1 \\3'):",match.expand(r'\2 \1 \3'))

print("match.pos:",match.pos)

print("match.endpos:",match.endpos)

print("match.lastindex:",match.lastindex)

print("match.lastgroup:",match.lastgroup)

print("match.re:",match.re)

print("match.string:",match.string)

# match.group(1,2): ('I', 'love')

# match[1]: I

# match.groups(): ('I', 'love', 'you!')

# match.groupdict(): {'word': 'you!'}

# match.start(2): 2

# match.end(2): 6

# match.span(2): (2, 6)

# match.expand(r'\2 \1 \3'): love I you!

# match.pos: 0

# match.endpos: 11

# match.lastindex: 3

# match.lastgroup: word

# match.re: re.compile('(\\w+) (\\w+) (?P<word>.*)')

# match.string: I love you!

分组扩展 

基本操作 

组从0开始编号组0始终存在,表示整个正则匹配对象方法以0为默认参数子组从左到右从1向上编号。组可以嵌套,要确定编号只需计算从左到右的左括号字符 

p = re.compile('(a)b')

m = p.match('ab')

m.group()  #或者 m.group(0)

#'ab'

p = re.compile('(a(b)c)d')

m = p.match('abcd')

m.group(0)

# 'abcd'

m.group(1)

# 'abc'

m.group(2)

# 'b'

m.group(2,1,2)

# ('b', 'abc', 'b')

m.groups()

# ('abc', 'b')

分组扩展的方式设置参数 

(?参数) 

参数: 'a', 'i', 'L', 'm', 's', 'u', 'x' 中的一个或多个标记应该在表达式字符串的首位 

给patten的一部分设置参数 

(?a:表达式) 

(?aiLmsux-imsx:表达式) 

注释 

(?#注释内容) 

捕获组 -> 命名组 

用组名获取特定匹配结果 

(?P<组名>表达式) + result.group('组名') : 

#匹配一个单词

p = re.compile(r'(?P<word>\b\w+\b)')

result = p.search('(((( Lots of punctuation )))')

result.group('word')  # 或者result.group()

#'Lots'

#匹配一个时间对象

InternalDate = re.compile(r'INTERNALDATE "'

        r'(?P<day>[ 123][0-9])-(?P<mon>[A-Z][a-z][a-z])-'

        r'(?P<year>[0-9][0-9][0-9][0-9])'

        r' (?P<hour>[0-9][0-9]):(?P<min>[0-9][0-9]):(?P<sec>[0-9][0-9])'

        r' (?P<zonen>[-+])(?P<zoneh>[0-9][0-9])(?P<zonem>[0-9][0-9])'

        r'"')

......

m.group('zonem')

在正则后面引用前面的组 

(?P<组名>表达式) + (?P=<组名>) : 

p = re.compile(r'\b(?P<word>\w+)\s+(?P=word)\b')

p.search('Paris in the the spring').group()

# 'the the'

传递到 re.sub() 里的 repl 参数中 

非捕获组 

(?:表达式) 

对部分值进行匹配但不作为结果，也不会分配组号，当然也不能在表达式和程序中做进一步处理除了无法检索组匹配内容的事实外,非捕获组的行为与捕获组完全相同可以在里面放任何东西，用重复元字符重复它可以用它添加新组而不更改所有其他组的编号方 

import re

match = re.match(r"(?P<python>123)(?:456)(789)","123456789")

if match:

    print(match.group("python"))#123

    print(match.groups())#('123', '789')

re.findall("industr(?:y|ies)","industryOpqindustries")

# ['industry', 'industries']

零宽度断言组 - 向前(右) 

不代表字符,不会推进匹配过程只用来对前面的字符进行额外的验证验证通过后,还可以从断言组开始位置继续向后匹配 

正面 - 类似于 if 

(?=表达式) 

类似于 if 

#参考:判断一个字符串是否为[文件名.扩展名]的形式

'.*[.].*$'

#判断一个字符串是否为[文件名.扩展名]的形式,且扩展名为[bat]

#在这一应用中而这效果一样,但第二种写法没必要,只是为了说明功能

#第二种写法在匹配完[bat]后又退回到了[bat]的前面重新判断[.]后的后缀格式

match = re.match(".*[.]bat$","sample.batch")

match = re.match(".*[.](?=bat$)[^.]*$","sample.batch")

负面 - 类似于 if not 

(?!表达式) 

#判断一个字符串是否为[文件名.扩展名]的形式,且扩展名不为[bat/exe]

match = re.match(".*[.](?!bat$|exe$)[^.]*$","sample.batch")

零宽度断言组 - 向回(左) 

和向前断言类似 

正面 

(?<=表达式) 

负面 

(?<!表达式) 

三元零宽度断言组 - 向回 

(?(id/name)yes-pattern|no-pattern) 

修改方法 

split() 

p = re.compile(r'\W+')

p.split('This is a')

# ['This', 'is', 'a']

p.split('This is a',1)

# ['This', 'is a']

# 正则中如果有使用捕获括号，则它们的内容也将作为结果列表的一部分返回.

p = re.compile(r'\W+')

p.split('This... is a test.')

# ['This', 'is', 'a', 'test', '']

p2 = re.compile(r'(\W+)')

p2.split('This... is a test.')

# ['This', '... ', 'is', ' ', 'a', ' ', 'test', '.', '']

sub() 

p = re.compile('(blue|white|red)')

p.sub('colour', 'blue socks and red shoes')

# 'colour socks and colour shoes'

p.sub('colour', 'blue socks and red shoes', count=1)

# 'colour socks and red shoes'

# 仅当空匹配(*)与前一个空匹配不相邻时，才会进行替换

p = re.compile('x*')

p.sub('-', 'abxd')

# '-a-b--d-'

# replacement中的转义:

# 如果 replacement 是一个字符串，则处理其中的任何反斜杠转义。 也就是说，\n 被转换为单个换行符，\r 被转换为回车符，依此类推。 诸如 \& 之类的未知转义是孤立的

# 后向引用，例如 \6，被替换为正则中相应组匹配的子字符串。 这使你可以在生成的替换字符串中合并原始文本的部分内容

#这个例子匹配单词 section 后跟一个用 {，} 括起来的字符串，并将 section 改为 subsection

p = re.compile('section{ ( [^}]* ) }', re.VERBOSE)

p.sub(r'subsection{\1}','section{First} section{second}')

# 'subsection{First} subsection{second}'

# replacement中引用由 (?P<name>...) 语法定义的命名组:

# \g<name> 将使用名为 name 的组匹配的子字符串

# \g<number> 使用相应的组号

# \g<2> 等同于 \2

# \20 将被解释为对组 20 的引用

# 以下替换都是等效的，但使用所有三种变体替换字符串:

p = re.compile('section{ (?P<name> [^}]* ) }', re.VERBOSE)

p.sub(r'subsection{\1}','section{First}')

p.sub(r'subsection{\g<1>}','section{First}')

p.sub(r'subsection{\g<name>}','section{First}')

# 'subsection{First}'

# replacement 也可以是一个函数，它可以为你提供更多控制

# 如果 replacement 是一个函数，则为 pattern 的每次非重叠出现将调用该函数

# 在每次调用时，函数都会传递一个匹配的 匹配对象 参数，并可以使用此信息计算所需的替换字符串并将其返回。

# 在以下示例中，替换函数将小数转换为十六进制:

def hexrepl(match):

    value = int(match.group())

    return hex(value)

p = re.compile(r'\d+')

p.sub(hexrepl, 'Call 65490 for printing, 49152 for user code.')

# 'Call 0xffd2 for printing, 0xc000 for user code.'

# 使用模块级别 re.sub() 函数时，模式作为第一个参数传递。

# 图案可以作为对象或字符串提供；如果需要指定正则表达式标志，则必须使用模式对象作为第一个参数，或者在模式字符串中使用嵌入式修饰符，# sub("(?i)b+", "x", "bbbb BBBB")

# 返回 'x x'

subn() 

p = re.compile('(blue|white|red)')

p.subn('colour', 'blue socks and red shoes')

# ('colour socks and colour shoes', 2)

p.subn('colour', 'no colours at all')

# ('no colours at all', 0)

常见问题 - 陷阱 

不用正则进行简单字符串替换 

如果你匹配固定字符串或单个字符类,如果你匹配固定字符串或单个字符类，并且你没有使用任何re功能，例如IGNORECASE标志，那么正则表达式的全部功能可能不是必需的。 字符串有几种方法可以使用固定字符串执行操作，它们通常要快得多，因为实现是一个针对此目的而优化的单个小 C 循环，而不是大型、更通用的正则表达式引擎。 

**单个子串替换,用replace()替换re.sub().**为了避免对单词的部分进行替换，模式必须是 \bword\b，以便要求 word 在任何一方都有一个单词边界。这使得工作超出了 replace() 的能力。将多个字符替换为其它多个字符或删除,使用translate()替换re.sub() 

在转向re模块之前，请考虑是否可以使用更快更简单的字符串方法解决问题 

区别search()和match() 

总体来说search()更强一些不要偷懒在match()的pattern开头加入.*来直接代替search()的功能.这样做会使编译器对search()的一些优化无法发挥作用,降低来效率.在search()中，可以用 '^' 作为开始来限制匹配到字符串的首位MULTILINE多行模式中函数match()只匹配字符串的开始，但使用 search()和以 '^' 开始的正则表达式会匹配每行的开始 

贪婪与非贪婪 

正则默认是贪婪模式(匹配为尽可能 少 的文字): 

s = '<html><head><title>Title</title>'  #32个字符

print(re.match('<.*>', s).group())

# '<html><head><title>Title</title>'

使用非贪婪的限定符 

非贪婪:匹配为尽可能少的文字 

*? 、 +? 、 ?? 、 {m,n}? 

避免用正则解析HTML 

使用正则表达式解析 HTML 或 XML 很痛苦。HTML 和 XML 有特殊情况会破坏明显的正则表达式；当你编写正则表达式处理所有可能的情况时，模式将非常复杂。使用 HTML 或 XML 解析器模块来执行此类任务。 

– 完 –