python正则表达式

正则在线查询是否正确以及查询步骤

https://regex101.com/

字符串前加r,防止转义

string = 'aaAAA\d123'
print(re.findall('\d',string))   #['1', '2', '3']
print(re.findall('\\d',string))  #['1', '2', '3']
print(re.findall(r'\d',string))  #['1', '2', '3']
print(re.findall(r'\\d',string)) #['\\d']

贪婪和非贪婪模式

默认为贪婪模式:在满足第二组规则的前提下,满足第一组的最大长度的字符

string = 'aaaabbbb'
res = re.match('(a*b*)(b*)',string)
print(res.groups())  #('aaaabbbb', '')

非贪婪模式(结尾加?表示非贪婪模式):在满足第二组规则的前提下,满足第一组的最小长度的字符

string = 'aaaabbbb'
res = re.match('(a*b*?)(b*)',string)
print(res.groups())  #('aaaa', 'bbbb')

特殊字符匹配

对于.*+?等特殊符号的匹配可以使用转义符’\.‘或’[.]’

符号    功能
.       匹配任意1个字符(除了\n)
[]      用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k'
[^]	    不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。
\d      匹配数字,也就是0-9
\D      匹配非数字,也就是匹配不是数字的字符
\s      匹配空白符,也就是 空格\tab
\S      匹配非空白符,\s取反
\w      匹配单词字符, a-z, A-Z, 0-9, _
\W      匹配非单词字符, \w取反
\        转义符

字符数量

符号    功能
*       匹配前一个字符出现0次多次或者无限次,可有可无,可多可少
+       匹配前一个字符出现1次多次或则无限次,直到出现一次
?       匹配前一个字符出现1次或者0次,要么有1次,要么没有
{m}     匹配前一个字符出现m次
{m,}    匹配前一个字符至少出现m次
{m,n}   匹配前一个字符出现m到n次

字符串边界

符号    功能
^       匹配字符串开头   ^a:以a开头
$       匹配字符串结尾   b$:以b结尾
\b      匹配一个单词的边界
\B      匹配非单词边界

分组

符号       功能
|           匹配左右任意一个表达式  
(ab)        将括号中字符作为一个分组
\num        引用分组num匹配到的字符串 num为0/1/2..即分组的第几部分
(?P<name>)  分组起别名(原有分组有名字)
(?P=name)   引用别名为name分组匹配到的字符串

例如:
	‘ I have a dog’ 或 ’I have a cat’ ，需要写成 r’I have a (?:dog|cat)’ ，而不能写成 r’I have a dog|cat’

括号内容

括号中 ’…’ 代表你希望匹配的字符串的前面应该出现的字符串。

(...)	      对正则表达式分组并记住匹配的文本
(?:...)	      类似 (...), 但是不表示一个组
(?imx:...)	  正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。
(?-imx:...)	  正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
(?#...)	      注释
(?<=…)        前向界定，不表示一个组
(?=...)	      为某字符串，不表示一个组
(?!...)	      后向否定，不为某字符串，不表示一个组
(?<!...)	  前向否定，不为某字符串，不表示一个组（只能处理定长字符）
(?> re)	      匹配的独立模式，省去回溯。

例如:
	s='/# comment 1 #/  code  /# comment 2 #/'
	res = re.findall('(?<=/#).+?(?=#/)' , s)
	print(res)                                     #[' comment 1 ', ' comment 2 ']

匹配不包含某字符串的字符串

text = '13245'

#非2或者3的字符(单个字符,没有顺序关系)
patt = '1([^23]*?)5'    
print(re.findall(patt,text))    #[]

#非23的字符串(字符串)
patt = '1((?!.*?23.*?).*?)5'  
print(re.findall(patt,text))    #['324']


#提取12和34
s = '二是12包含(?P<e0>.+?)的需求34工作(?P<n1>.{7}?)'
res = re.finditer('(?:P<.\d+)|(?:\.{\d+})|(\d+)',s)
# res = re.sub('(?:P<.\d+)|(\d+)','(?:\d+)',s)
index = []
for i in res:
    if i.groups()[0]:
        print(i.group()) #12   34

分组命名

'''
	(?P<name>)  分组起别名(原有分组有名字)
	(?P=name)   引用别名为name分组匹配到的字符串
'''
text = 'This is some text -- with --  punctuation.'

pattern = '(?P<first_word>\w+).*?(?P<flag>--).*?(?P=flag)'

res = re.search(pattern,text)

print(res.group('flag'))
print(res.groupdict())

交换字符串位置

s = 'abc#xyz'
print(re.sub(r'(.*)#(.*)', r'\2+\1', s))

函数功能

re.compile()用于将字符串形式的正则表达式编译为Pattern对象

无需要时也可直接用字符串表示规则

import re
# re.I(re.IGNORECASE): 忽略大小写（括号内是完整写法，下同）
# re.M(MULTILINE): 多行模式，改变'^'和'$'变为每一行的开头结尾
# re.S(DOTALL): 点任意匹配模式，可以解决文本多行匹配问题
# re.L(LOCALE): 使预定字符类 \w \W \b \B \s \S 取决于当前区域设定
# re.U(UNICODE): 使预定字符类 \w \W \b \B \s \S \d \D 取决于unicode定义的字符属性
# re.X(VERBOSE): 详细模式。这个模式下正则表达式可以是多行，忽略空白字符，并可以加入注释。

string = 'aaAAA'
print(re.findall('a*',string))           #['aa', '', '', '', '']
pattern = re.compile('a*',re.I)
print(re.findall(pattern,string))       #['aaAAA', '']

pattern= re.compile('a*',re.I)
pattern= re.compile(r '\d +  # the integral part
               						\.    # the decimal point
               						\d *  # some fractional digits', re.X)

re.escape()批量进行特殊字符转义

pattern_str = '.*?'
safe_pattern_str = re.escape(pattern_str)
print(safe_pattern_str)                                   #\.\*\?

re.match()一次匹配的结果（从字符串开始匹配，开始位置匹配不到就返回None）

string = 'aa1d123'
res = re.match('(.*)(?P<数字>\d+)([a-z]+)',string)

# 属性
print(res.string)       # 匹配时使用的文本。               aa1d123
print(res.re)           # 匹配时使用的Pattern对象          re.compile('(.*)(?P<数字>\\d+)([a-z]+)')
print(res.pos)          # 文本中正则表达式开始搜索的索引      0
print(res.endpos)       # 文本中正则表达式结束搜索的索引      7
print(res.lastindex)    # 分组数量                          3
print(res.lastgroup)    # 最后一个被捕获的分组的别名         None

# 方法
#获得分组截获的字符串；可以使用编号也可以使用别名；0代表整个匹配的子串；默认group(0)
print(res.group(1,2,3))            #('aa', '1', 'd')
#相当于调用group(1,2,…last)
print(res.groups())                #('aa', '1', 'd')
#返回以有别名的组的别名为键、以该组截获的子串为值的字典
print(res.groupdict())             #{'数字': '1'}
#返回指定的组截获的子串在string中的起始索引。group默认值为0。
print(res.start(2))                #2,'1'的索引为2
#返回指定的组截获的子串在string中的结束索引（子串最后一个字符的索引+1）。group默认值为0。
print(res.end(2))                  #3,'1'的结束索引为2，2+1=3
#返回(start(group), end(group))。
print(res.span(2))                 #(2, 3)

re.search()查找字符串中可以匹配成功的子串（依次从字符串的所有位置匹配直到成功,匹配不到返回Neno）

相当于从第一个字符开始依次向后re.match

match到第一组后停止,相当于re.finditer()[0]

string = 'aa1d123'
# 若用re.match则返回None
res = re.search('(?P<数字>\d+)([a-z]+)',string)
# 属性
print(res.string)       # 匹配时使用的文本。               aa1d123
print(res.re)           # 匹配时使用的Pattern对象          re.compile('(?P<数字>\\d+)([a-z]+)')
print(res.pos)          # 文本中正则表达式开始搜索的索引      0
print(res.endpos)       # 文本中正则表达式结束搜索的索引      7
print(res.lastindex)    # 分组数量                          2
print(res.lastgroup)    # 最后一个被捕获的分组的别名         None

# 方法

#获得分组截获的字符串；可以使用编号也可以使用别名；0代表整个匹配的子串；默认group(0)
print(res.group(1,2))                #('1', 'd')
#相当于调用group(1,2,…last)
print(res.groups())                  #('1', 'd')
#返回以有别名的组的别名为键、以该组截获的子串为值的字典
print(res.groupdict())               #{'数字': '1'}
#返回指定的组截获的子串在string中的起始索引。group默认值为0。
print(res.start(2))                  #3,'d'的索引为3
#返回指定的组截获的子串在string中的结束索引（子串最后一个字符的索引+1）。group默认值为0。
print(res.end(2))                    #4,'d'的结束索引为3，3+1=4
#返回(start(group), end(group))。
print(res.span(2))                 #(3, 4)

re.findall()以列表形式返回全部能匹配的子串

string = 'aa1d123'
res = re.findall('(?P<数字>\d+)([a-z]?)',string)
print(res)  #[('1', 'd'), ('123', '')]

re.finditer()搜索string，返回一个顺序访问每一个匹配结果（Match对象）的迭代器。

string = 'aa1d123'
res = re.finditer('(?P<数字>\d+)([a-z]?)',string)
for i in res:
    print(i.groups())
'''
('1', 'd')
('123', '')
'''

re.split()字符串分割,以列表形式返回分割结果

string = 'a,a,1?d?123'
#以,或者?为分隔符,最多分割3次
#默认全部分割
res = re.split(',|[?]',string,maxsplit=3)
print(res)    #['a', 'a', '', '?d?123']

#保留分隔符,需要加入()
string = 'a,a'
#res = re.split(r"(,|\?)", string)
res = re.split(r"([,?])", string) 
print(res)  #['a', ',', 'a']
res.append("")
res = ["".join(i) for i in zip(res[0::2], res[1::2])]
print(res)  # ['a,', 'a']

re.sub()，re.subn()字符替换,返回替换后的字符串

#只替换规则的某一部分
string1 = '4:4'
string2 = 'd:d'
res1 = re.sub(r"(\d)(:)(\d)", r"\1@\3", string1)
res2 = re.sub(r"(\d)(:)(\d)", r"\1@\3", string2)
print(res1)  # 4@4
print(res2)  # d:d

string = 'a,a,1?d?123'
#用'b'替换','或者'?',最多替换3次
#默认全部替换
res = re.sub(',|[?]','b',string,3)
print(res)  #abab1bd?123

#返回替换后的字符串以及替换次数
res = re.subn(',', 'b', string, 3)
print(res)  # ('abab1?d?123', 2)