re模块的方法总结

一，查找

1：match

匹配string 开头，成功返回Match object, 失败返回None，只匹配一个。

示例：

1 s="abc221kelvin4774"
2 print(re.match("ab",s)) #<re.Match object; span=(0, 2), match=‘ab‘>
3 print(re.match("kelvin",s)) #None

2：findall

在string中查找所有 匹配成功的组, 即用括号括起来的部分。返回list对象，每个list item是由每个匹配的所有组组成的list。

示例：

1 res1=re.findall("\d+","sd223dfar5621ff3f")
2 print(res1) #[‘223‘, ‘5621‘, ‘3‘]

3：search

在string中进行搜索，成功返回Match object, 失败返回None, 只匹配一个。

示例：

1 ret1=re.search("a\d+b","eaa1b4gha12das")
2 print(ret1.group()) # a1b

4：finditer

在string中查找所有 匹配成功的字符串, 返回iterator，每个item是一个Match object。

示例：

 1 import re
 2
 3 p1 = re.compile(r‘\d+‘)
 4 a_str = ‘one1two2three3four4‘
 5
 6 #正则对象的split方法，使用正则匹配进行分割字符串
 7 #以列表的形式返回
 8 print(p1.split(a_str)) #[‘one‘, ‘two‘, ‘three‘, ‘four‘, ‘‘]
 9
10 #正则对象的findall方法，来查找符合对象的字符串
11 #最后是以列表的形式返回
12 print (p1.findall(a_str)) #[‘1‘, ‘2‘, ‘3‘, ‘4‘]
13
14 for i in p1.finditer(a_str):
15         print (i.group())
16
17 #1
18 #2
19 #3
20 #4

二，字符串处理的扩展 ：split切割；sub/subn替换

1：split切割

1 s = ‘alex|taibai|egon|‘
2 print(s.split(‘|‘))
3 s = ‘alex83taibai40egon25‘
4 ret = re.split(‘\d+‘,s)
5 print(ret)
6
7 结果:
8 [‘kelvin‘, ‘bob‘, ‘siri‘, ‘‘]
9 [‘kelvin‘, ‘bob‘, ‘siri‘, ‘‘]

2：sub:替换,谁 旧的 新的 替换次数

 1 ret1 = re.sub(‘\d+‘,‘*‘,‘kelvin83bob40siri25‘) #如果不指定替换个数，则全部替换
 2 print(ret1)
 3
 4 ret2 = re.sub(‘\d+‘,‘*‘,‘kelvin83bob40siri25‘,2) #如果指定了替换个数，则替换前指定个数个
 5 print(ret2)
 6
 7 ret3 = re.sub(‘\d+‘,‘*‘,‘kelvin83bob40siri25‘,4) #如果指定了替换个数，且个数大于符合匹配条件个数，则全部匹配
 8 print(ret3)
 9
10 #输出结果：
11 #kelvin*bob*siri*
12 #kelvin*bob*siri25
13 #kelvin*bob*siri*

3：subn:返回一个元组,第二个元素是替换的次数

1 ret = re.subn(‘\d+‘,‘*‘,‘kelvin83bob40siri25‘)
2 print(ret)
3
4 #结果：
5 #(‘kelvinHbobHsiriH‘, 3)

三，re模块的进阶:时间/空间

1：compile:节省你使用正则表达式解决问题的时间

作用：编译 正则表达式 编译成 字节码，在多次使用的过程中,不会多次编译

1 ret = re.compile(‘\d+‘)   # 已经完成编译了
2 print(ret)  # re.compile(‘\\d+‘)
3 print(type(ret))  # <class ‘re.Pattern‘>
4 res = ret.findall(‘kelvin83bob40siri25‘)
5 print(res)   # [‘83‘, ‘40‘, ‘25‘]
6 res = ret.search(‘sjkhk172按实际花费928‘)
7 print(res.group())  # 172 

2:finditer:节省你使用正则表达式解决问题的空间/内存

1 ret = re.finditer(‘\d+‘,‘kelvin83bob40siri25‘)
2 for i in ret:
3     print(i.group())
4
5 #结果：
6 #‘83‘
7 #‘40‘
8 #‘25‘

四，小结

(1)findall:返回列表,找所有的匹配项

(2)search:匹配就返回一个变量,通过group取匹配到的第一个值,不匹配就返回None,group会报错

(3)match:相当于search的正则表达式中加了个‘^‘

(4)spilt:返回列表,按照正常规则切割,默认匹配到的内容会被切掉

(5)sub/subn:替换,按照正则规则去寻找要被替换掉的内容,subn返回元组,第二个值是替换的次数

(6)compile:编译一个正则表达式,用这个结果去search,match,findall,finditer能够节省时间

(7)finditer:返回一个迭代器,所有的结果都在这个迭代器中,需要通过循环+group的形式取值,能够节省内存

五，分组在re模块中的使用

引例：

 1 s = ‘<a>wahaha</a>‘  # 标签语言 html 网页
 2 ret = re.search(‘<(\w+)>(\w+)</(\w+)>‘,s)
 3 print(ret.group())  # 所有的结果
 4 print(ret.group(1)) # 数字参数代表的是取对应分组中的内容
 5 print(ret.group(2))
 6 print(ret.group(3))
 7
 8 #结果:
 9 #<a>wahaha</a>
10 #a
11 #wahaha
12 #a

1.为了findall也可以顺利取到分组中的内容,有一个特殊的语法,就是优先显示分组中的内容

1 s = ‘<a>wahaha</a>‘
2 ret = re.findall(‘(\w+)‘,s)
3 print(ret)
4 ret = re.findall(‘>(\w+)<‘,s)
5 print(ret)
6
7 #结果:
8 #[‘a‘, ‘wahaha‘, ‘a‘]
9 #[‘wahaha‘]

2.取消分组优先(?:正则表达式)

1 ret = re.findall(‘\d+(?:\.\d+)?‘,‘1.234*4‘)
2 print(ret)
3
4 #结果:
5 #[‘1.234‘, ‘4‘]

3.关于分组

对于正则表达式来说 有些时候我们需要进行分组,来整体约束某一组字符出现的次数
(\.[\w]+)?

对于python语言来说 分组可以帮助你更好更精准的找到你真正需要的内容
<(\w+)>(\w+)</(\w+)>

4.切割split(使用分组切割可以保留切割点)

1 ret = re.split(‘\d+‘,‘alex83taibai40egon25‘)
2 print(ret)
3 ret = re.split(‘(\d+)‘,‘alex83taibai40egon25aa‘)
4 print(ret)
5
6 #结果:
7 #[‘alex‘, ‘taibai‘, ‘egon‘, ‘‘]
8 #[‘alex‘, ‘83‘, ‘taibai‘, ‘40‘, ‘egon‘, ‘25‘, ‘‘]

5：分组命名（？P<分组名>正则表达式）

1 s = ‘<a>wahaha</a>‘
2 ret = re.search(‘>(?P<con>\w+)<‘,s)
3 print(ret.group(1))
4 print(ret.group(‘con‘))
5
6 #结果:
7 #wahaha
8 #wahaha

6.使用前面的分组,要求使用这个名字的分组和前面同名分组中的内容匹配的必须一致

 1 s = ‘<a>wahaha</a>‘
 2 pattern = ‘<(\w+)>(\w+)</(\w+)>‘
 3 ret = re.search(pattern,s)
 4 print(ret.group(1) == ret.group(3))
 5
 6 #结果:
 7 #True
 8
 9 s = ‘<a>wahaha</b>‘
10 pattern = ‘<(?P<tab>\w+)>(\w+)</(?P=tab)>‘
11 ret = re.search(pattern,s)
12 print(ret)
13
14 #结果:
15 #None
16
17
18 s = ‘<a>wahaha</a>‘
19 pattern = ‘<(?P<tab>\w+)>(\w+)</(?P=tab)>‘
20 ret = re.search(pattern,s)
21 print(ret)
22
23 #结果:
24 #<_sre.SRE_Match object; span=(0, 13), match=‘<a>wahaha</a>‘>

六，使用正则表达式的技巧

1.用法:你要匹配的内容太没有特点,容易和你不想匹配的内容混在一起

 1 # 精准的取到整数 过滤掉小数
 2 ret=re.findall(r"\d+\.\d+|\d+","1-2*(60+(-40.35/5)-(-4*3))")
 3 print(ret)
 4 ret=re.findall(r"\d+\.\d+|(\d+)","1-2*(60+(-40.35/5)-(-4*3))")
 5 ret.remove(‘‘)
 6 print(ret)
 7
 8 #结果:
 9 #[‘1‘, ‘2‘, ‘60‘, ‘40.35‘, ‘5‘, ‘4‘, ‘3‘]
10 #[‘1‘, ‘2‘, ‘60‘, ‘5‘, ‘4‘, ‘3‘]

***正则表达式如果写的足够好的话,能够最大限度的简化我们的操作

2.正则表达式的重要程度

(1)掌握练习中的所有内容
(2)能够看懂常用的正则表达式
(3)并且能够做出一些公司特异性要求的修改

正则表达式中的特殊字符总结：

特殊字符有：

‘.‘
    （点号。）在默认模式下，匹配除换行以外的任意字符.如果 DOTALL 标志被指定, 则匹配包括换行符在内的所有字符.
‘^‘
    （脱字符号。）在默认模式下匹配字符串的起始位置, 在MULTILINE模式下也匹配换行符之后的位置.
‘$‘
    匹配字符串的末尾或者字符串末尾换行符之前的位置，在MULTILINE模式下还匹配换行符之前的位置。foo既匹配‘foo’也匹配‘foobar’，但是foo$只匹配‘foo’。更有趣的是，正常情况下foo.$只匹配‘foo1\nfoo2\n‘ ‘foo2’，但是在MULTILINE模式下还能匹配‘foo1’；在‘foo\n‘中搜索单个$将找到两个（空的）匹配：一个是换行符之前，一个是字符串的末尾。
‘*‘
    匹配前面重复出现的正则表达式零次或多次，尽可能多的匹配。ab*将匹配‘a’、‘ab’或‘a’ 后面跟随任意数目的‘b’。
‘+‘
    引起生成的RE匹配1个或多个前导的RE，尽可能多的匹配。ab+将匹配‘a’之后跟随任意多个数目不为零的‘b’，它将不能匹配单纯的一个‘a’。
‘?‘
    引起生成的RE匹配0个或1个前导的RE。ab?将匹配‘a’或者‘ab’。
*?, +?, ??
    ‘*‘、‘+‘和‘?‘限定符是贪婪的； 它们匹配尽可能多的文本。有时这个行为不是想要的；如果用正则表达式<.*>来匹配‘<H1>title</H1>‘，它将匹配完整的字符串，而不会只是‘<H1>‘。在限定符之后加上‘?‘将使得匹配以非贪婪的或最小的方式进行；因为它将匹配尽可能少的字符。在刚才的表达式中使用.*?将只匹配‘<H1>‘。
{m}
    表示精确匹配前面的正则表达式的m个拷贝；较少的匹配将导致整个表达式不能匹配。例如，a{6}将精确匹配6个‘a‘字符，5个将不能匹配。
{m,n}
    引起生成的正则表达式匹配前导正则表达式的m到n个重复，尝试匹配尽可能多的重复。例如，a{3,5}将匹配3到5个‘a‘字符。省略m表示下界为0，省略n表示上界无限大。举个例子，a{4,}b将匹配aaaab或一千个‘a‘字符后跟随一个b，但不能匹配aaab。逗号不可以省略，否则该修改符将与前面的形式混淆。
{m,n}?
    例如，对于6个字符的字符串‘aaaaaa‘，a{3,5}将匹配5个‘a‘字符，而a{3,5}?将只匹配3个字符。
‘\‘
    对任一特殊字符进行转义（允许您匹配字符（如‘*‘，‘ ? ‘，等等），或只是一个特殊的序列；特殊序列在下面讨论。
    如果你不使用原始字符串来表达模式，记住在字符串字面值中Python也使用反斜杠作为转义序列；如果转义序列不能被Python解析器识别，那么结果字符串中包含反斜杠和后面的字符。但是，如果Python会识别所产生的序列，反斜杠应该重复两次。这比较复杂和难以理解，因此强烈建议你为所有即使是最简单的表达式使用原始字符串。
[]
    用来表示一个字符集合。在一个集合中：
        字符可以一个一个列出来，例如[amk]将匹配‘a‘、‘m‘或‘k‘。
        通过给出两个字符并用‘-‘分隔，可以给出一段范围的字符，例如[a-z]将匹配任意一个小写的ASCII字符，[0-5][0-9]将匹配00到59之间所有的两位数字，[0-9A-Fa-f]将匹配任意一个十六进制数字。如果-被转义（例如[a\-z]）或者如果它位于第一个或最后一个字符（例如[a-]），它将只匹配一个字面值‘-‘。
        在集合内部，特殊字数将失去它们特殊的含义。例如，[(+*)]将匹配字符字面值‘(‘、‘+‘、‘*‘或‘)‘。
        在集合中还接受字符类别，例如\w或\S（在下文定义），尽管它们匹配的字符取决于LOCALE或UNICODE模式是否是强制的。
        不在一段范围之内的字符可以通过补集匹配。如果集合的第一个字符是‘^‘，那么所有不在集合中的字符都将被匹配。例如，[^5]将匹配除‘5‘之外的所有字符，[^^]将匹配除‘^‘之外的所有字符。^如果不是集合中的第一个字符则没有特殊的含义。
        若要匹配集合中的一个字符字面值‘]‘，可以在它前面放一个反斜线或者将它放在集合的开始。例如，[()[\]{}]和[]()[{}]都将匹配一个圆括号。

‘|‘
    A|B, 此处的 A 和 B 可以是任意的正则表达式, 创建的这个正则表达式要么匹配 A 要么匹配 B. ‘|‘可以用来隔开任意个数的正则表达式，着同样可以用在组里面。 当扫描字符串时，REs 被用‘|‘从左到右分隔。当一个模式被完全匹配时，这个被匹配的模式就被接受。这意味着一旦 匹配A , B 就不在被尝试, 即使他会产生更长的整体匹配. 换句话说,  ‘|‘ 不是贪婪操作符. 匹配符号 ‘|‘,用 |, 或者把它包含在组内, 就像是 [|].
(...)
    匹配任何在圆括号内的正则表达式, 并表明分组的开始和结束; 分组的内容在完成匹配后可以提取出来，而且可以在后面的字符串中用特殊的number序列匹配，下面有描述。若要匹配字面值‘(‘或‘)‘，请使用( or )，或它们放入字符类的括号中：[(] [)]。
(?...)
    This is an extension notation (a ‘?‘ following a ‘(‘ is not meaningful otherwise). The first character after the ‘?‘ determines what the meaning and further syntax of the construct is. Extensions usually do not create a new group; (?P<name>...) is the only exception to this rule.Following are the currently supported extensions.
(?iLmsux)
    （集合‘i‘, ‘L‘, ‘m‘, ‘s‘, ‘u‘, ‘x‘中的一个或多个字母。）这个分组空字符串；这些字母给真个正则表达式设置相应的标记：re.I（忽略大小写），re.L（依赖区域设置），re.M（多行），re.S（点号匹配所有字符），re.U（依赖Unicode），re.X（详细模式）。（这些标志在模块的内容中讲述）。它用于如果你想要包含这些标志作为正则表达式的一部分，而不是将flag参数传递给re.compile()函数。
    请注意，(?x)标志更改解析表达的方式。它应使用在表达式字符串的开始，或一个或多个空白字符之后。如果在这个标志之前有非空白字符，结果是未定义的。
(?:...)
    括号形式的正则表达式的非匹配版本。匹配括号中的任何正则表达式，但是匹配的子字符串不能在匹配后提取或在模式中引用。
(?P<name>...)
    通过符号组名称name可以访问类似于常规的括号，但由组匹配的子字符串。组名必须是有效的 Python 标识符，并且每个组名必须在正则表达式内只有一次定义。海员象征性的组织也是带编号的组，就好像组未被命名。

原文地址：https://www.cnblogs.com/sun-10387834/p/10352734.html