正则表达式笔记

前言：最近学习了Python的正则表达式re模块的基本使用方法，综合了网上一些文章和视频的内容加上自己的理解总结了以下的内容，留作以后方便查阅，也希望能给读者一些帮助，有些地方理解还不透彻，如有错误欢迎指正，谢谢
学无止境！

正则表达式

导入re模块

import re

正则表达式模式

• 模式字符串使用特殊的语法来表示一个正则表达式：

• 字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。

• 多数字母和数字前加一个反斜杠时会拥有不同的含义。

• 标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。

• 反斜杠本身需要使用反斜杠转义。

• 由于正则表达式通常都包含反斜杠，所以你最好使用原始字符串来表示它们。模式元素(如 r’\t’，等价于 \t )匹配相应的特殊字符。

常用正则表达式语法

符号	描述
^	匹配字符串的开头
$	匹配字符串的结尾
re*	匹配0个或多个re（*前面的一个re表达式）表达式
re+	匹配1个或者多个表达式
re?	匹配0个或者1个re表达式，非贪婪模式（尽可能少得匹配）
a|b	匹配a或者b

字母	描述
\w	匹配包括下划线的任何单词字符（数字字母下划线）。等价于’[A-Za-z0-9_]’
\W	匹配任何非单词字符（非数字字母下划线）。等价于 ‘[^A-Za-z0-9_]’
\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,\2,…,\9	匹配第n个分组的内容，即第几个括号的内容

小括号	描述
(re)	匹配括号内的re表达式，表示一个组，可以用group()方法取出每个组的内容
(?imx)	正则表达式包含三种可选标志：i,m或x。只影响括号内的区域？
(?-imx)	正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域
(?: re)	类似 (…), 但是不表示一个组
(?imx: re)	在括号中使用i, m或 x 可选标志
(?-imx: re)	在括号中不使用i, m或 x 可选标志
(?#…)	注释
(?= re)	前向肯定界定符。如果所含正则表达式，以 … 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边
(?! re)	前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功
(?> re)	匹配的独立模式，省去回溯

中括号	描述
[…]	用来表示一组字符，单独列出：[amk]匹配’a’,’m’或者’k’
[^…]	表示不再括号内的内容，如[^abc]匹配除了’a’,’b’,’c’以外的内容

大括号	描述
re{n}	精确匹配前面的re表达式的n个,例如，”o{2}”不能匹配”Bob”中的”o”，但是能匹配”foooooood”中的两个o三次
re{n,}	匹配n个前面表达式。例如，”o{2,}”不能匹配”Bob”中的”o”，但能匹配”foooooood”中的所有o。”o{1,}”等价于”o+”。”o{0,}”则等价于”o*”
re{n,m}	匹配n到m次前面的re表达式片段，贪婪模式

#0{2}和o{2,}的区别
content ='foooooood'
result1 = re.findall('o{2,}',content)
result2 = re.findall('o{2}',content)
print(result1)
print(result2)

['ooooooo']
['oo', 'oo', 'oo']

修饰符

• 修饰符被指定为一个可选的标志，放在匹配函数中作为一个参数用于控制匹配模式。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志
• 例如：re.findall(pattern, content, re.S)

修饰符	描述
re.I	使匹配对大小写不敏感
re.L	做本地化识别（locale-aware）匹配
re.M	多行匹配，影响^和$
re.S	使点 . 能够匹配包括换行符在内的所有字符
re.U	根基Unicode字符集解析字符，这个标志影响\w,\W,\b,\B
re.X	该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解

正则表达式的对象

re.RegexObject

• re.compile()函数返回的对象，便于反复使用

re.MatchObject

• group()返回被RE匹配的字符串组，可以用数字指定第几个组
• start()返回匹配起始位置
• end()返回匹配结束的位置
• span()返回一个元组，包含起始位置和结束位置

re.match( )

re.match(pattern, string, flags=0)
* 必须从第一个字符开始匹配，比较不方便

最常规的匹配

content = 'Hello 123 4567 World_This is a Regex Demo'
print(len(content))
result = re.match('^Hello\s\d\d\d\s\d{4}\s\w{10}.*Demo$',content)
print(result)
print(result.group())   ##匹配的结果，如果匹配取出多个括号中的内容group()里面可以指定是第几个括号的内容
print(result.span())    ##匹配的长度

41
<_sre.SRE_Match object; span=(0, 41), match='Hello 123 4567 World_This is a Regex Demo'>
Hello 123 4567 World_This is a Regex Demo
(0, 41)

泛匹配

content = 'Hello 123 4567 World_This is a Regex Demo'
result = re.match('^Hello.*Demo$',content)
print(result)
print(result.group())  
print(result.span())

<_sre.SRE_Match object; span=(0, 41), match='Hello 123 4567 World_This is a Regex Demo'>
Hello 123 4567 World_This is a Regex Demo
(0, 41)

目标匹配

将需要匹配的目标用括号括起来

content = 'Hello 1234567 World_This is a Regex Demo'
result = re.match('^Hello\s(\d+)\sWorld.*Demo$',content)
print(result)
print(result.group())     ##如果group没有参数就不能取出括号的值
print(result.group(1))
print(result.span())

<_sre.SRE_Match object; span=(0, 40), match='Hello 1234567 World_This is a Regex Demo'>
Hello 1234567 World_This is a Regex Demo
1234567
(0, 40)

贪婪匹配

贪婪模式会尽可能多的匹配

content = 'Hello 1234567 World_This is a Regex Demo'
result = re.match('^He.*(\d+).*Demo$',content)  ##贪婪模式的.*会匹配尽可能多的字符，而\d+至少要一个数字，所以7前面的数字被.*匹配掉了
print(result)
print(result.group(1))

<_sre.SRE_Match object; span=(0, 40), match='Hello 1234567 World_This is a Regex Demo'>
7

非贪婪模式

在匹配模式后面加?表示非贪婪模式，会尽可能少的匹配

content = 'Hello 1234567 World_This is a Regex Demo'
result = re.match('^He.*?(\d+).*Demo$',content)  ##非贪婪模式的.*会匹配尽可能少的字符，所以只匹配到数字前面的冒号
print(result)
print(result.group(1))

<_sre.SRE_Match object; span=(0, 40), match='Hello 1234567 World_This is a Regex Demo'>
1234567

匹配模式

match函数的re.S参数表示匹配模式中的点能够匹配换行符

content = '''Hello 1234567 World_This
is a Regex Demo'''
result1 = re.match('^He.*?(\d+).*Demo$',content)
print(result1)
result2 = re.match('^He.*?(\d+).*Demo$',content,re.S)
print(result2.group(1))

None
1234567

转义

content = 'price is $50'
result1 = re.match('price is $50',content)
print(result1)
result2 = re.match('price is \$50',content)    ##用反斜杠转义
print(result2.group())

None
price is $50

re.search( )

用法类似于match函数
* 扫描整个字符串，并返回第一个匹配的结果，不需要从头开始匹配

content = 'Hello 1234567 World_This is a Regex Demo'
result1 = re.match('lo\s(\d+)\sW',content)
print(result1)
result2 = re.search('lo\s(\d+)\sWorld',content)
print(result2.group(1))

None
1234567

re.findall( )

• 功能类似于search，但是以列表的方式返回所有能匹配的字符串

content = 'Hello 1234567 World_This is a Regex Demo'
result1 = re.findall('\d',content)  #以列表的方式输出，若有多个括号则以元组的形式表示，然后组成列表
result2 = re.findall('\d\d',content)  #匹配完的内容不再进行匹配
print(result1)
print(result2)

['1', '2', '3', '4', '5', '6', '7']
['12', '34', '56']

• 括号除了可以用表示要取出的东西以外，可以表示是一个整体如(

re.finditer( )

类似于re.findall()，只是将结果作为一个迭代器返回

content = '12a34b56c78d9'
results = re.findall('\d+',content)#返回一个列表
for result in results:
    print(result)

results = re.finditer('\d+',content)#返回一个迭代器
for result in results:
    print(result.group())

12
34
56
78
9
12
34
56
78
9

re.sub( )

re.sub(pattern,replacement,string)
* 替换字符串中每一个匹配的子串之后返回替换后的字符串
* 可以先用这个函数对一些不够规律的html进行预处理

content = 'Hello 1234567 World_This is a Regex Demo'
result = re.sub('\d','@',content)
print(result)

Hello @@@@@@@ World_This is a Regex Demo

content = 'Hello 1234567 World_This is a Regex Demo'
result = re.sub('(\d\d)(\d)',r'\1 ** \2 *',content)   #当匹配有多个括号的时候，可以用\1,\2这些来指定第几个括号的值，用这些值去替换
print(result)

Hello 12 ** 3 *45 ** 6 *7 World_This is a Regex Demo

re.compile( )

• 将一个正则表达式串编译成正则对象，以便于重复使用该匹配模式

content = '''Hello 1234567 World_This
is a Regex Demo'''
pattern = re.compile('\d',re.S)
result = pattern.findall(content)
print(result)

['1', '2', '3', '4', '5', '6', '7']

re.split( )

split方法能都匹配的子串将字符串分割之后返回列表

re.split(pattern,string[,maxsplit = 0, flags = 0])(方括号表示可选项）
* pattern匹配的正则表达式
* string要分割的字符串
* maxsplit最大分割次数，默认没有
* flags修饰符

string = 'apple, banana, orange'
result1 = re.split('\W+',string)  #在匹配的地方左右两边切开，返回的列表取出匹配的那部分字符
result2 = re.split('(\W+)',string) #在括号内匹配的结果两边切开，返回的结果包含所有内容
result3 = re.split('\W+',string,1) #指定了最大切分次数为1，切了一次后就停止了
result4 = re.split('\d',string) #如果没有可以匹配的位置则split不会做出分割
print(result1)
print(result2)
print(result3)
print(result4)

['apple', 'banana', 'orange']
['apple', ', ', 'banana', ', ', 'orange']
['apple', 'banana, orange']
['apple, banana, orange']