15.python正则匹配元字符、转义、重复、或、捕获、分组、断言：零度断言、负向零宽断言、贪婪非贪婪、引擎选项、re模块：re.compile re.match re.search re.fullmatch re.findall re.finditer re.sub re.runb re.split

正则表达式

概述

正则表达式，Regular Expression，缩写为regex、regexp、RE等。
正则表达式是文本处理极为重要的技术，用它可以对字符串按照某种规则进行检索、替换。
1970年代，Unix之父Ken Thompson将正则表达式引入到Unix中文本编辑器ed和grep命令中，由此正则表达式普及开来。
1980年后，perl语言对Henry Spencer编写的库，扩展了很多新的特性。1997年开始，Philip Hazel开发出了PCRE (Perl Compatible Regular Expressions)，它被PHP和HTTPD等工具采用。
正则表达式应用极其广泛，shell中处理文本的命令、各种高级编程语言都支持正则表达式。
参考 https://www.w3cschool.cn/regex_rmjc/

基本语法

元字符

metacharacter

代码	说明	举例.
.	匹配除换行符外任意一个字符
[abc]	字符集合，只能表示一个字符位置。匹配所包含的任意一个字符	[abc]匹配plain中的'a'
[^abc]	字符集合，只能表示一个字符位置。匹配除去集合内字符的任意一个字符	[^abc]可以匹配plain中的'p'、'l'、'i'或者'n'
[a-z]	字符范围，也是个集合，表示一个字符位置,匹配所包含的任意一个字符	常用[A-z]或 [0-9]
[^a-z]	字符范围，也是个集合，表示一个字符位置,匹配除去集合内字符的任意一个字符
\b	匹配单词的边界	\bb 在文本中找到单词中b开头的b字符
\B	不匹配单词的边界	t\B 包含t的单词但是不以t结尾的t字符，例如write, \Bb不以b开头的含有b的单词，例如able
\d	[0-9]匹配1位数字	\d
\D	[^0-9]匹配1位非数字
\s	匹配1位空白字符，包括换行符、制表符、空格[ \f\r\n\t\v]
\S	匹配1位非空白字符
\w	匹配[a-zA-Z0-9_]，包括中文的字	\w
\W	匹配\w之外的字符

转义

凡是在正则表达式中有特殊意义的符号，如果想使用它的本意，请使用\转义。
反斜杠自身，得使用\
\r、\n还是转义后代表回车、换行

重复

代码	说明	举例
*	表示前面的正则表达式会重复0次或多次	e\w* 单词中e后面可以有非空白字符
+	表示前面的正则表达式重复至少1 次	e\w+ 单词中e后面至少有一个非空白字符
？	表示前面的正则表达式会重复0次或1次	e\w? 单词中e后面至多有一个非空白字符
	重复固定的n次	e\w{1} 单词中e后面只能有一个非空白字符
	重复至少n次	e\w{1,} 等价 e\w+ e\w{0,} 等价 e\w* e\w{0,1} 等价 e\w?
	重复n到m次	e\w{1,10} 单词中e后面至少1个，至多10个非空

练习：
1、匹配手机号码
字符串为手机号码13851888188。

[1-9]{11}
\d{11}

2、匹配中国座机
字符串为"号码025-83105736、0543-5467328。"

\d{3,4}-\d{7,8}

或

代码	说明	举例
x\|y	匹配x或者y	wood took foot food, 使用 w\|food 或者 (w\|f)ood

捕获

代码	说明	举例
(pattern)	使用小括号指定一个子表达式也叫分组, 捕获后会自动分配组号从1开始可以改变优先级
\数字	匹配对应的分组	(very) \1 匹配very very，但捕获的组
(?:pattern)	如果仅仅为了改变优先级，就不需要捕获分组	(?:w\|f)ood 'industr(?:y\|ies)等价,'industry\|industries'
(?exp) (?'name'exp)	命名分组捕获，但是可以通过name访问分组 Python语法必须是(?Pexp)

断言

零宽断言

测试字符串为wood took foot food

代码	说明	举例
(?=exp)	零宽度正预测先行断言断言exp一定在匹配的右边出现，也就是说断言后面一定跟个exp	f(?=oo) f后面一定有oo出现
(?<=exp)	零宽度正回顾后发断言断言exp一定出现在匹配的左边出现，也就是说前面一定有个exp前缀	(?<=f)ood、(?<=t)ook分别匹配ood、 ook，ook前一定有t出现

负向零宽断言

代码	说明	举例
(?!exp)	零宽度负预测先行断言断言exp一定不会出现在右侧，也就是说断言后面一定不是exp	\d{3}(?!\d)匹配3位数字，断言3位数字后面一定不能是数字 foo(?!d) foo后面一定不是d
(?<!exp)	零宽度负回顾后发断言断言exp一定不能出现在左侧，也就是说断言前面一定不能是exp	(?<!f)ood ood的左边一定不是f

代码	说明	举例
(?#comment)	注释	f(?=oo)(?#这个后断言不捕获)

注意：
断言会不会捕获呢？也就是断言占不占分组号呢？
断言不占分组号。断言如同条件，只是要求匹配必须满足断言的条件。

分组和捕获是同一个意思。
使用正则表达式时，能用简单表达式，就不要复杂的表达式。

贪婪与非贪婪

默认是贪婪模式，也就是说尽量多匹配更长的字符串。

非贪婪很简单，在重复的符号后面加上一个?问号，就尽量的少匹配了。

代码	说明	举例
*?	匹配任意次，但尽可能少重复
+?	匹配至少1次，，但尽可能少重复
??	匹配0次或1次，，但尽可能少重复
{n,}?	匹配至少n次，但尽可能少重复
{n,m}?	匹配至少n次，至多m次，但尽可能少重复

very very happy 使用v.y和v.?y

引擎选项

代码	说明	Python
IgnoreCase	匹配时忽略大小写	re.I re.IGNORECASE
Singleline	单行模式 . 可以匹配所有字符，包括\n	re.S re.DOTALL
Multiline	多行模式 ^ 行首、$ 行尾	re.M re.MULTILINE
IgnorePatternWhitespace	忽略表达式中的空白字符，如果要使用空白字符用转义，#可以用来做注释	re.X re.VERBOSE

单行模式：
. 可以匹配所有字符，包括换行符
^ 表示整个字符串的开头，$整个字符串的结尾
多行模式：
. 可以匹配除了换行符之外的字符，多行不影响.点号
^ 表示行首，$行尾，只不过这里的行是每一个行
默认模式：可以看做待匹配的文本是一行，不能看做多行，.点号不能匹配换行符，^和$表示行首和行
尾，而行首行尾就是整个字符串的开头和结尾
单行模式：基本和默认模式一样，只是.点号终于可以匹配任意一个字符包括换行符，这时所有文本就是
一个长长的只有一行的字符串。^就是这一行字符串的行首，$就是这一行的行尾。
多行模式：重新定义了行的概念，但不影响.点号的行为，^和$还是行首行尾的意思，只不过因为多行模
式可以识别换行符了。"开始"指的是\n后紧接着下一个字符；"结束"指的是\n前的字符，注意最后一行
结尾可以没有\n
简单讲，单行模式只影响.点号行为，多行模式重新定义行影响了^和$
注意：注意字符串中看不见的换行符,\r\n会影响e$的测试，e$只能匹配e\n

举例
very very happy
my primary key

上面2行happy之后，有可能是\r\n结尾。
y$ 单行匹配key的y，多行匹配happy和key的y。
.$指的是此行的结尾，而默认模式和单行模式都是一行，指的是这个大字符串的最后一个字符，就是key的y。

python正则表达式

Python使用re模块提供了正则表达式处理的能力。

常量

常量	说明
re.M re.MULTILINE	多行模式
re.S re.DOTALL	单行模式
re.I re.IGNORECASE	忽略大小写
re.X re.VERBOSE	忽略表达式中的空白字符

使用 | 位或运算开启多种选项

方法

编译

re.compile

re.compile(pattern, flags=0)
设定flags，编译模式，返回正则表达式对象regex。
pattern就是正则表达式字符串，flags是选项。正则表达式需要被编译，为了提高效率，这些编译后的结果被保存，下次使用同样的pattern的时候，就不需要再次编译。
re的其它方法为了提高效率都调用了编译方法，就是为了提速。

单次匹配

re.match

re.match(pattern, string, flags=0)
regex.match(string[, pos[, endpos]])
match匹配从字符串的开头匹配，regex对象match方法可以重设定开始位置和结束位置,从选定位置第一个开始匹配，不存在返回none.
返回match对象

re.search

re.search(pattern, string, flags=0)
regex.search(string[, pos[, endpos]])
从头搜索直到第一个匹配，regex对象search方法可以重设定开始位置和结束位置
返回match对象

re.fullmatch

re.fullmatch(pattern, string, flags=0)
regex.fullmatch(string[, pos[, endpos]])
整个字符串和正则表达式匹配，匹配全部内容
返回match对象

例子

import re
s = '''bottle\nbag\nbig\napple'''
for i,c in enumerate(s, 1):
    print((i-1, c), end='\n' if i%10==0 else ' ')
print()
(0, 'b')(1, 'o')(2, 't')(3, 't')(4, 'l')(5, 'e')(6, '\n')(7, 'b')(8, 'a')(9, 
'g') (10, '\n')(11, 'b')(12, 'i')(13, 'g')(14, '\x07')(15, 'p')(16, 'p')(17, 'l') (18, 'e')

# match方法
print('--match--')
result = re.match('b', s) # 找到一个就不找了
print(1, result) # bottle
result = re.match('a', s) # 没找到，返回None
print(2, result)
result = re.match('^a', s, re.M) # 依然从头开始找，多行模式没有用
print(3, result)
result = re.match('^a', s, re.S) # 依然从头开始找
print(4, result)
# 先编译，然后使用正则表达式对象
regex = re.compile('a')
result = regex.match(s) # 依然从头开始找
print(5, result)
result = regex.match(s, 15) # 把索引15作为开始找
print(6, result) # apple
print()

# search方法
print('--search--')
result = re.search('a', s) # 扫描找到匹配的第一个位置
print(7, result) # apple
regex = re.compile('b')
result = regex.search(s, 1)
print(8, result) # bag
regex = re.compile('^b', re.M)
result = regex.search(s) # 不管是不是多行，找到就返回
print(8.5, result) # bottle
result = regex.search(s, 8)
print(9, result) # big

# fullmatch方法
result = re.fullmatch('bag', s)
print(10, result)
regex = re.compile('bag')
result = regex.fullmatch(s)
print(11, result)
result = regex.fullmatch(s, 7)
print(12, result)
result = regex.fullmatch(s, 7, 10)
print(13, result) # 要完全匹配，多了少了都不行, [7, 10)

全文搜索

re.findall

re.findall(pattern, string, flags=0)
regex.findall(string[, pos[, endpos]])
对整个字符串，从左至右匹配
返回所有匹配项的 列表

re.finditer

re.finditer(pattern, string, flags=0)
regex.finditer(string[, pos[, endpos]])
对整个字符串，从左至右匹配，返回所有匹配项，返回迭代器。
注意每次迭代返回的是match对象。

例子

import re

s = '''bottle\nbag\nbig\nable'''
for i,c in enumerate(s, 1):
    print((i-1, c), end='\n' if i%10==0 else ' ')
print()

(0, 'b') (1, 'o') (2, 't') (3, 't') (4, 'l') (5, 'e') (6, '\n') (7, 'b') (8, 
'a') (9, 'g') (10, '\n') (11, 'b') (12, 'i') (13, 'g') (14, '\n') (15, 'a') (16, 'b') (17, 
'l') (18, 'e') 

# findall方法
result = re.findall('b', s)
print(1, result)
regex = re.compile('^b')
result = regex.findall(s)
print(2, result)
regex = re.compile('^b', re.M)
result = regex.findall(s, 7)
print(3, result) # bag big
regex = re.compile('^b', re.S)
result = regex.findall(s)
print(4, result) # bottle
regex = re.compile('^b', re.M)
result = regex.findall(s, 7, 10)
print(5, result) # bag

# finditer方法
regex = re.compile('^b\w+', re.M)
result = regex.finditer(s)
print(type(result))
r = next(result)
print(type(r), r) # Match对象
print(r.start(), r.end(), s[r.start():r.end()])
r = next(result)
print(type(r), r)
print(r.start(), r.end(), s[r.start():r.end()])

匹配替换

re.sub

re.sub(pattern, replacement, string, count=0, flags=0)
regex.sub(replacement, string, count=0)
使用pattern对字符串string进行匹配，对匹配项使用repl替换。
replacement可以是string、bytes、function。

re.subn

re.subn(pattern, replacement, string, count=0, flags=0)
regex.subn(replacement, string, count=0)
同sub返回一个元组（new_string， number_of_subs_made）

例子

s = '''bottle\nbag\nbig\napple'''
for i,c in enumerate(s, 1):
    print((i-1, c), end='\n' if i%8==0 else ' ')
print()

(0, 'b') (1, 'o') (2, 't') (3, 't') (4, 'l') (5, 'e') (6, '\n') (7, 'b') (8, 
'a') (9, 'g') (10, '\n')(11, 'b')(12, 'i')(13, 'g')(14, '\n')(15, 'a')(16, 'p')(17, 'p') (18, 'l')(19, 'e')

# 替换方法
regex = re.compile('b\wg')
result = regex.sub('magedu', s)
print(1, result) # 被替换后的字符串
result = regex.sub('magedu', s, 1) # 替换1次
print(2, result) # 被替换后的字符串

regex = re.compile('\s+')
result = regex.subn('\t', s)
print(3, result) # 被替换后的字符串及替换次数的元组

分组

使用小括号的pattern捕获的数据被放到了组group中。
match、search函数可以返回match对象；findall返回字符串列表；finditer返回一个个match对象
如果pattern中使用了分组，如果有匹配的结果，会在match对象中

使用group(N)方式返回对应分组，1到N是对应的分组，0返回整个匹配的字符串，N不写缺省为0
如果使用了命名分组，可以使用group('name')的方式取分组
也可以使用groups()返回所有组
使用groupdict() 返回所有命名的分组

例子

import re
s = '''bottle\nbag\nbig\napple'''
for i,c in enumerate(s, 1):
   print((i-1, c), end='\n' if i%10==0 else ' ')
print()

# 分组
regex = re.compile('(b\w+)')
result = regex.match(s) # 从头匹配一次
print(type(result))
print(1, 'match', result.group(), result.group(0), result[0], 
result.groups())

result = regex.search(s, 1) # 从指定位置向后匹配一次
print(2, 'search', result.groups()) #

# 命名分组
regex = re.compile('(b\w+)\n(?P<name2>b\w+)\n(?P<name3>b\w+)')
result = regex.match(s)
print(3, 'match', result)
print(4, result.group(3), result.group(2), result.group(1))
print(5, result.group(0).encode()) # 0 返回整个匹配字符串，即match
print(6, result.group('name2'), result.group('name3'))
print(6, result.groups())
print(7, result.groupdict())

result = regex.findall(s) # 返回什么，有几项？
for x in result: # 有分组里面放的东西不一样
    print(type(x), x)
    
regex = re.compile('(?P<head>b\w+)')
result = regex.finditer(s)
for x in result:
    print(type(x), x, x.group(), x.group('head'), x['head'], x[0])

如果有分组，findall返回的是分组的内容，而不是match匹配的字符串。
有没有分组，都可以使用Match对象的group(0)，它总是为匹配的字符串。

分割字符串

re.split

字符串的分割函数split，太难用，不能指定多个字符进行分割。
re.split(pattern, string, maxsplit=0, flags=0)
re.split分割字符串

例子

import re
s = """
os.path.abspath(path) 
normpath(join(os.getcwd(), path)).
"""
# 把每行单词提取出来
print(s.split())  # 做不到['os.path.abspath(path)', 
'normpath(join(os.getcwd(),', 'path)).']
print(re.split('[\.()\s,]+', s))

posted on 2022-01-17 17:32 无语至极阅读(162) 评论(0) 编辑收藏举报

刷新页面返回顶部

麻烦先认清人再说话 ok？