python3 正则表达式 re (不全 用到哪个写哪个)

2023.10.31

之前只是知道有这么个东西,上学没好好学,之前工作也是边查边用,用完就忘。
最近空窗期备考华子刷题有用到,顺带整理和知识补足。
正则的东西有点多,从零开始理解,用到哪些就写到这来。

正则表达式,一个特殊的字符序列,用来描述一种模式,或者说成是规则。
然后可以对字符串进行操作,来判断字符串是否符合这种模式,
或者去查找字符串内是否包含满足这种模式的字符串,甚至进行替换。

正则表达式,这个序列的写法规则及对应的概念和意义:
        字符集合设定: 用中括号括起 [abc123] 来表示其中任一字符
                中划线 - :[a-zA-Z] 来表示 所有的大小写字母
                非 ^ :[^a-zA-Z]    写在中括号内开头 表示除了中括号内的字符之外的任意字符
                           [a-z^A-Z]    写在其他地方,就只表示它本身而没有取非的意思
                数字 \d :  等同于[0-9]
                非数字 \D : 等同于[^0-9]
                字母数字 \w : 等同于[a-zA-Z0-9]
                非字母非数字 \W : 等同于[^a-zA-Z0-9] 
        重复:用以表示前面紧挨着的字符集合的次数
                0+次  *  : 表示0次或以上
                1+次  + : 表示1次或以上
                0,1次 ? : 表示0次或者1次, 要么0要么1
                精确次数  {m,n}: 表示最少m次到最多n次之间
        组: 用以表示正则序列内的一部分
                用圆括号括起来 ( ) 即为一组
                ([a-zA-Z]+)(\d+) 这个正则序列内有两个组
                        组号0表示正则序列本身
                        组号1表示字母
                        组号2表示数组

正则的使用:
        1. 第一题用到的是匹配(查找)
                查找,在这里写两个方法,re.match() 和 re.search(),先看代码

import re
s = 'Seven77'
matcher = re.match(r'([a-zA-Z]+)(\d+)', s)
print(matcher)             # 
print(matcher.group(0))    # Seven77
print(matcher.group(1))    # Seven
print(matcher.group(2))    # 77
print(matcher.group(3))    # IndexError: no such group
import re
s = 'Seven77'
searcher = re.search(r'([a-zA-Z]+)(\d+)', s)
print(searcher)            # 
print(searcher.group(0))   # Seven77
print(searcher.group(1))   # Seven
print(searcher.group(2))   # 77
print(searcher.group(3))   # IndexError: no such group

两个方法都是查找匹配,并且可以用.group()来取到,匹配成功的部分对应的组内的值
区别见下例:

 

import re
s = '0Seven77'
matcher = re.match(r'([a-zA-Z]+)(\d+)', s)
print(matcher)             # None
print(matcher.group(0))    # AttributeError: 'NoneType' object has no attribute 'group'
print(matcher.group(1))    # AttributeError: 'NoneType' object has no attribute 'group'
print(matcher.group(2))    # AttributeError: 'NoneType' object has no attribute 'group'
import re
s = '0Seven77'
searcher = re.search(r'([a-zA-Z]+)(\d+)', s)
print(searcher)             # 
print(searcher.group(0))    # Seven77
print(searcher.group(1))    # Seven
print(searcher.group(2))    # 77

两者查找匹配,都是从前往后,但区别在于,如果match一开始没有查到满足的字串,则返回None
而search则会尝试向后查找,若有则返回。若无则返回None。

import re
ss = '0Seven'
searcher = re.search(r'([a-zA-Z]+)(\d+)', ss)
print(searcher)             # None
print(searcher.group(0))    # AttributeError: 'NoneType' object has no attribute 'group'
print(searcher.group(1))    # AttributeError: 'NoneType' object has no attribute 'group'
print(searcher.group(2))    # AttributeError: 'NoneType' object has no attribute 'group'

所以一般用完match()或者search()后,在取值之前要进行是否为None的判断。代码暂略。

知道这几块就可以解第一道报文重排序的题了。

==========================分割线=======================================

多带一嘴关于re.compile() 上代码

import re
s1 = 'eg11'
s2 = 'eg22'
s3 = 'eg33'
matcher1 = re.match(r'([a-zA-Z]+)(\d+)', s1)
matcher2 = re.match(r'([a-zA-Z]+)(\d+)', s2)
matcher3 = re.match(r'([a-zA-Z]+)(\d+)', s3)

此时正则被写了三次,虽说可以cv但还是有点麻烦,因此介入compile()

import re
s1 = 'eg11'
s2 = 'eg22'
s3 = 'eg33'
reg = re.compile(r'([a-zA-Z]+)(\d+)')
matcher1 = reg.match(s1)
matcher2 = reg.match(s2)
matcher3 = reg.match(s3)

 两种写法完全等效,同样可以用于search()和其他方法

参考文章:

python | 史上最全的正则表达式_python 正则表达式-CSDN博客

华为OD机试 - 报文重排序(Java & JS & Python & C)-CSDN博客

==========================分割线=======================================

2023.11.08

遇到了正则替换,就再来写一下关于re.sub(),把匹配上的部分进行替换。
可以看一下参考那篇文章

简单说起就是要有三个参数,1.正则 2.替换成什么 3.原字符串
更高级的可以声明做几次替换, 以及是否忽略大小写什么的

先记最质朴的:

import re
s = '[10,20,5]'
ret = re.sub(r'[\[\]]', '', s)
print(ret)                       # 10,20,5

或者

import re
s = '[10,20,5]'
reg = re.compile(r'[\[\]]')
ret = reg.sub('', s)
print(ret)                       # 10,20,5

顺带一提,如果正则写的时候没写原样字符标识r, 会抛一个警告:
SyntaxWarning: invalid escape sequence '\['
是在提示当前代码中的反斜线 \ 被视为转义字符
使用正则时候大多都要写r的,不然有时会很迷糊

以上。

        

参考文章:

re.sub()用法详解_IT之一小佬的博客-CSDN博客
SyntaxWarning: invalid escape sequence ‘\p‘-CSDN博客


==========================分割线=======================================

2024.01.05   关于符号与贪婪

首先是字符点 '.'  用来匹配除 "\n" 之外的任何单个字符。
(要匹配包括 '\n' 在内的任何字符,请使用如 '[.\n]' 的模式)
(当re.DOTALL标记被指定时,则可以匹配包括换行符的任意字符)
(如果使用了 ’S’ 选项,匹配包括 ’/n’ 的所有字符。)

其次是字符 '*', '+', '?'   此三者用来表明重复次数
*     表示前置规则重复 0次或1次或多次
+    表示前置规则重复 1次或多次
?    表示前置规则重复  0次或1次
+ 与 * 二者的后面,可以加 ? 来表示非贪婪

贪婪,顾名思义,尽可能多的
+ 本身,表示一次或多次匹配,在默认的贪婪模式下,会匹配尽可能多的字符
* 同理
这时引出, +?   表示一次或多次匹配,但是不贪婪,会匹配尽可能少的字符
*?   同理

下面的示例是搬运,先附原文链接,原作者写的太好了,连我都看懂了!
https://www.cnblogs.com/wjx-blog/p/12123279.html

1. .*
. 表示 匹配除换行符 \n 之外的任何单字符,*表示零次或多次。所以.*在一起就表示任意字符出现零次或多次。没有?表示贪婪模式。比如a.*b,它将会匹配最长的以a开始,以b结束的字符串。如果用它来搜索aabab的话,它会匹配整个字符串aabab。这被称为贪婪匹配。
又比如模式src=`.*`, 它将会匹配最长的以 src=` 开始,以`结束的最长的字符串。用它来搜索 时,将会返回 src=``test.jpg` width=`60px` height=`80px`

2. .*?
?跟在*或者+后边用时,表示懒惰模式。也称非贪婪模式。就是匹配尽可能少的字符。就意味着匹配任意数量的重复,但是在能使整个匹配成功的前提下使用最少的重复。
a.*?b匹配最短的,以a开始,以b结束的字符串。如果把它应用于aabab的话,它会匹配aab(第一到第三个字符)和ab(第四到第五个字符)。
又比如模式 src=`.*?`,它将会匹配 src=` 开始,以 ` 结束的尽可能短的字符串。且开始和结束中间可以没有字符,因为*表示零到多个。用它来搜索 时,将会返回 src=``。

3. .+?
同上,?跟在*或者+后边用时,表示懒惰模式。也称非贪婪模式。就意味着匹配任意数量的重复,但是在能使整个匹配成功的前提下使用最少的重复。
a.+?b匹配最短的,以a开始,以b结束的字符串,但a和b中间至少要有一个字符。如果把它应用于ababccaab的话,它会匹配abab(第一到第四个字符)和aab(第七到第九个字符)。注意此时匹配结果不是ab,ab和aab。因为a和b中间至少要有一个字符。
又比如模式 src=`.+?`,它将会匹配 src=` 开始,以 ` 结束的尽可能短的字符串。且开始和结束中间必须有字符,因为+表示1到多个。用它来搜索 时,将会返回 src=``test.jpg`。注意与.*?时的区别,此时不会匹配src=``,因为src=` 和 ` 之间至少有一个字符。

你可能感兴趣的:(python3,python)