正则表达式及其在python上的应用

发布时间：2020-12-13 21:54:55 所属栏目：百科来源：网络整理

导读：今天学习了一早上正则表达式。如下内容部分转载自《读懂正则表达式就这么简单》 1.1 什么是正则表达式正则表达式是一种特殊的字符串模式，用于匹配一组字符串，就好比用模具做产品，而正则就是这个模具，定义一种规则去匹配符合规则的字符。 1.2 常用的正则

今天学习了一早上正则表达式。如下内容部分转载自《读懂正则表达式就这么简单》

1.1 什么是正则表达式

正则表达式是一种特殊的字符串模式，用于匹配一组字符串，就好比用模具做产品，而正则就是这个模具，定义一种规则去匹配符合规则的字符。

1.2 常用的正则匹配工具

在线匹配工具：

　　1. http://www.regexpal.com/
2. http://rubular.com/

3. http://tools.aspzz.cn/regex/create_reg

4. txt2re ：这个在线网站支持解析一句话，从中可以生成匹配的正则表达式，且可以生成诸多类型的代码。语言支持：Perl PHP Python Java Javascript ColdFusion C C++ Ruby VB VBScript J#.net C#.net C++.net VB.net

正则匹配软件

McTracer

用过几个之后还是觉得这个是最好用的，支持将正则导成对应的语言如java C# js等还帮你转义了，Copy直接用就行了很方便，另外支持把正则表达式用法解释，如哪一段是捕获分组，哪段是贪婪匹配等等，总之用起来 So Happy .

二正则字符简单介绍

2.1 元字符介绍

"^" ：^会匹配行或者字符串的起始位置，有时还会匹配整个文档的起始位置。

"$" ：$会匹配行或字符串的结尾

如图

而且被匹配的字符必须是以This开头有空格也不行，必须以Regex结尾，也不能有空格与其它字符

"b" :不会消耗任何字符只匹配一个位置，常用于匹配单词边界如我想从字符串中"This is Regex"匹配单独的单词 "is" 正则就要写成 "bisb"

　　 b 不会匹配is 两边的字符，但它会识别is 两边是否为单词的边界

"d": 匹配数字，

　　例如要匹配一个固定格式的电话号码以0开头前4位后7位，如0737-5686123 正则:^0ddd-ddddddd$ 这里只是为了介绍"d"字符，实际上有更好的写法会在下面介绍。

"w"：匹配字母，数字，下划线.

　　例如我要匹配"a2345BCD__TTz" 正则："w+" 这里的"+"字符为一个量词指重复的次数，稍后会详细介绍。

"s"：匹配空格

　　例如字符 "a b c" 正则："wswsw" 一个字符后跟一个空格，如有字符间有多个空格直接把"s" 写成 "s+" 让空格重复

"."：匹配除了换行符以外的任何字符

　　这个算是"w"的加强版了"w"不能匹配空格如果把字符串加上空格用"w"就受限了，看下用 "."是如何匹配字符"a23 4 5 B C D__TTz" 正则：".+"

"[abc]": 字符组匹配包含括号内元素的字符

这个比较简单了只匹配括号内存在的字符，还可以写成[a-z]匹配a至z的所以字母就等于可以用来控制只能输入英文了，

2.2 几种反义

　　写法很简单改成大写就行了，意思与原来的相反，这里就不举例子了

"W" 匹配任意不是字母，数字，下划线的字符

"S" 匹配任意不是空白符的字符

　"D" 匹配任意非数字的字符

"B" 匹配不是单词开头或结束的位置

"[^abc]" 匹配除了abc以外的任意字符

2.3 量词

　　先解释关于量词所涉及到的重要的三个概念

贪婪(贪心) 如"*"字符贪婪量词会首先匹配整个字符串，尝试匹配时，它会选定尽可能多的内容，如果失败则回退一个字符，然后再次尝试回退的过程就叫做回溯，它会每次回退一个字符，直到找到匹配的内容或者没有字符可以回退。相比下面两种贪婪量词对资源的消耗是最大的，

懒惰(勉强) 如 "?" 懒惰量词使用另一种方式匹配，它从目标的起始位置开始尝试匹配，每次检查一个字符，并寻找它要匹配的内容，如此循环直到字符结尾处。

占有如"+" 占有量词会覆盖事个目标字符串，然后尝试寻找匹配内容，但它只尝试一次，不会回溯，就好比先抓一把石头，然后从石头中挑出黄金

"*"(贪婪) 重复零次或更多

　　　例如"aaaaaaaa" 匹配字符串中所有的a 正则： "a*" 会出到所有的字符"a"

"+"(懒惰) 重复一次或更多次

　　例如"aaaaaaaa" 匹配字符串中所有的a 正则： "a+" 会取到字符中所有的a字符， "a+"与"a*"不同在于"+"至少是一次而"*" 可以是0次，

　　稍后会与"?"字符结合来体现这种区别

"?"(占有) 重复零次或一次

　　例如"aaaaaaaa" 匹配字符串中的a 正则： "a?" 只会匹配一次，也就是结果只是单个字符a

　 "{n}" 重复n次

　　例如从"aaaaaaaa" 匹配字符串的a 并重复3次正则： "a{3}" 结果就是取到3个a字符 "aaa";

　 "{n,m}" 重复n到m次

　　例如正则 "a{3,4}" 将a重复匹配3次或者4次所以供匹配的字符可以是三个"aaa"也可以是四个"aaaa" 正则都可以匹配到

"{n,}" 重复n次或更多次

　　与{n,m}不同之处就在于匹配的次数将没有上限，但至少要重复n次如正则"a{3,}" a至少要重复3次

把量词了解了之后之前匹配电话号码的正则现在就可以改得简单点了^0ddd-ddddddd$ 可以改为"^0d+-d{7}$"。

这样写还不够完美如果因为前面的区号没有做限定，以至于可以输入很多们，而通常只能是3位或者4位，

现在再改一下 "^0d{2,3}-d{7}"如此一来区号部分就可以匹配3位或者4位的了

2.4 懒惰限定符

　　"*?" 重复任意次，但尽可能少重复

　　如 "acbacb" 正则 "a.*?b" 只会取到第一个"acb" 原本可以全部取到但加了限定符后，只会匹配尽可能少的字符，而"acbacb"最少字符的结果就是"acb"

　　"+?" 重复1次或更多次，但尽可能少重复

　　与上面一样，只是至少要重复1次

　　"??" 重复0次或1次，但尽可能少重复

　　如 "aaacb" 正则 "a.??b" 只会取到最后的三个字符"acb"

　　"{n,m}?" 重复n到m次，但尽可能少重复

如 "aaaaaaaa" 正则 "a{0,m}" 因为最少是0次所以取到结果为空

　　"{n,}?" 重复n次以上，但尽可能少重复

如 "aaaaaaa" 正则 "a{1,}" 最少是1次所以取到结果为 "a"

三正则进阶

3.1 捕获分组

　　先了解在正则中捕获分组的概念，其实就是一个括号内的内容如 "(d)d" 而"(d)" 这就是一个捕获分组，可以对捕获分组进行后向引用 (如果后而有相同的内容则可以直接引用前面定义的捕获组，以简化表达式) 如(d)d1 这里的"1"就是对"(d)"的后向引用

那捕获分组有什么用呢看个例子就知道了

如 "zery zery" 正则 b(w+)bs1b 所以这里的"1"所捕获到的字符也是与(w+)一样的"zery"，为了让组名更有意义，组名是可以自定义名字的

"b(?<name>w+)bsk<name>b" 用"?<name>"就可以自定义组名了而要后向引用组时要记得写成 "k<name>";自定义组名后,捕获组中匹配到的值就会保存在定义的组名里

下面列出捕获分组常有的用法

"(exp)" 匹配exp,并捕获文本到自动命名的组里

"(?<name>exp)" 匹配exp,并捕获文本到名称为name的组里

"(?:exp)" 匹配exp,不捕获匹配的文本，也不给此分组分配组号

以下为零宽断言

"(?=exp)" 匹配exp前面的位置

　　如 "How are you doing" 正则"(?<txt>.+(?=ing))" 这里取ing前所有的字符，并定义了一个捕获分组名字为 "txt" 而"txt"这个组里的值为"How are you do";

"(?<=exp)" 匹配exp后面的位置

　　如 "How are you doing" 正则"(?<txt>(?<=How).+)" 这里取"How"之后所有的字符，并定义了一个捕获分组名字为 "txt" 而"txt"这个组里的值为" are you doing";

"(?!exp)" 匹配后面跟的不是exp的位置

　　如 "123abc" 正则 "d{3}(?!d)"匹配3位数字后非数字的结果

"(?<!exp)" 匹配前面不是exp的位置

　　如 "abc123 " 正则 "(?<![0-9])123" 匹配"123"前面是非数字的结果也可写成"(?!<d)123"

python正则表达式

关于python的正则表达式，主要使用re模块。

我们以任务为导向介绍python正则表达式的用法。

假设给我们下面这段话：

I1113 23:35:50.763059  4460 solver.cpp:218] Iteration 400 (27.3075 iter/s,0.7324s/20 iters),loss = 0.0202583
I1113 23:35:50.763141  4460 solver.cpp:237]     Train net output #0: rpn_cls_loss = 0.00101873 (* 1 = 0.00101873 loss)
I1113 23:35:50.763165  4460 solver.cpp:237]     Train net output #1: rpn_loss_bbox = 0.0192396 (* 1 = 0.0192396 loss)
I1113 23:35:50.763175  4460 sgd_solver.cpp:105] Iteration 400,lr = 0.001
I1113 23:35:51.751206  4460 solver.cpp:218] Iteration 420 (20.2456 iter/s,0.987868s/20 iters),loss = 0.00228514
I1113 23:35:51.751341  4460 solver.cpp:237]     Train net output #0: rpn_cls_loss = 0.00140554 (* 1 = 0.00140554 loss)
I1113 23:35:51.751379  4460 solver.cpp:237]     Train net output #1: rpn_loss_bbox = 0.000879596 (* 1 = 0.000879596 loss)
I1113 23:35:51.751410  4460 sgd_solver.cpp:105] Iteration 420,lr = 0.001
I1113 23:35:52.523890  4460 solver.cpp:218] Iteration 440 (25.8933 iter/s,0.772401s/20 iters),loss = 0.0132958
I1113 23:35:52.523974  4460 solver.cpp:237]     Train net output #0: rpn_cls_loss = 0.00312161 (* 1 = 0.00312161 loss)
I1113 23:35:52.523988  4460 solver.cpp:237]     Train net output #1: rpn_loss_bbox = 0.0101742 (* 1 = 0.0101742 loss)
I1113 23:35:52.523998  4460 sgd_solver.cpp:105] Iteration 440,lr = 0.001
I1113 23:35:53.461998  4460 solver.cpp:218] Iteration 460 (21.3325 iter/s,0.937539s/20 iters),loss = 0.0154897
I1113 23:35:53.462057  4460 solver.cpp:237]     Train net output #0: rpn_cls_loss = 0.00780452 (* 1 = 0.00780452 loss)
I1113 23:35:53.462069  4460 solver.cpp:237]     Train net output #1: rpn_loss_bbox = 0.00768522 (* 1 = 0.00768522 loss)
I1113 23:35:53.462082  4460 sgd_solver.cpp:105] Iteration 460,lr = 0.001
I1113 23:35:54.356657  4460 solver.cpp:218] Iteration 480 (22.3584 iter/s,0.894517s/20 iters),loss = 0.00275768
I1113 23:35:54.356729  4460 solver.cpp:237]     Train net output #0: rpn_cls_loss = 0.00107937 (* 1 = 0.00107937 loss)
I1113 23:35:54.356739  4460 solver.cpp:237]     Train net output #1: rpn_loss_bbox = 0.00167831 (* 1 = 0.00167831 loss)
I1113 23:35:54.356748  4460 sgd_solver.cpp:105] Iteration 480,lr = 0.001
I1113 23:35:55.153437  4460 solver.cpp:218] Iteration 500 (25.1734 iter/s,0.79449s/20 iters),loss = 0.0230187
I1113 23:35:55.153519  4460 solver.cpp:237]     Train net output #0: rpn_cls_loss = 0.0105348 (* 1 = 0.0105348 loss)
I1113 23:35:55.153530  4460 solver.cpp:237]     Train net output #1: rpn_loss_bbox = 0.0124839 (* 1 = 0.0124839 loss)
I1113 23:35:55.153542  4460 sgd_solver.cpp:105] Iteration 500,lr = 0.001
I1113 23:35:56.104395  4460 solver.cpp:218] Iteration 520 (21.0352 iter/s,0.950785s/20 iters),loss = 0.0144106
I1113 23:35:56.104485  4460 solver.cpp:237]     Train net output #0: rpn_cls_loss = 0.00135394 (* 1 = 0.00135394 loss)
I1113 23:35:56.104504  4460 solver.cpp:237]     Train net output #1: rpn_loss_bbox = 0.0130567 (* 1 = 0.0130567 loss)
I1113 23:35:56.104521  4460 sgd_solver.cpp:105] Iteration 520,lr = 0.001
I1113 23:35:56.854631  4460 solver.cpp:218] Iteration 540 (26.6699 iter/s,0.749909s/20 iters),loss = 0.0167331
I1113 23:35:56.854696  4460 solver.cpp:237]     Train net output #0: rpn_cls_loss = 0.00285695 (* 1 = 0.00285695 loss)
I1113 23:35:56.854710  4460 solver.cpp:237]     Train net output #1: rpn_loss_bbox = 0.0138762 (* 1 = 0.0138762 loss)
I1113 23:35:56.854720  4460 sgd_solver.cpp:105] Iteration 540,lr = 0.001
I1113 23:35:57.824692  4460 solver.cpp:218] Iteration 560 (20.6206 iter/s,0.969902s/20 iters),loss = 0.00817935
I1113 23:35:57.824774  4460 solver.cpp:237]     Train net output #0: rpn_cls_loss = 0.00557839 (* 1 = 0.00557839 loss)
I1113 23:35:57.824791  4460 solver.cpp:237]     Train net output #1: rpn_loss_bbox = 0.00260096 (* 1 = 0.00260096 loss)
I1113 23:35:57.824806  4460 sgd_solver.cpp:105] Iteration 560,lr = 0.001
I1113 23:35:58.670575  4460 solver.cpp:218] Iteration 580 (23.6486 iter/s,0.845714s/20 iters),loss = 0.00420315
I1113 23:35:58.670637  4460 solver.cpp:237]     Train net output #0: rpn_cls_loss = 0.0020043 (* 1 = 0.0020043 loss)
I1113 23:35:58.670648  4460 solver.cpp:237]     Train net output #1: rpn_loss_bbox = 0.00219884 (* 1 = 0.00219884 loss)
I1113 23:35:58.670658  4460 sgd_solver.cpp:105] Iteration 580,lr = 0.001
I1114 00:34:17.348683  4460 sgd_solver.cpp:105] Iteration 79980,lr = 0.0001
speed: 0.044s / iter
Wrote snapshot to: /data1/caiyong.wang/program/py-faster-rcnn/output/faster_rcnn_alt_opt/voc_2007_trainval/zf_rpn_stage1_iter_80000.caffemodel

希望我们解析出

Iteration 500 (25.1734 iter/s,loss = 0.0230187

中的Iteration与loss值。其实这是faster rcnn生成的log文件一部分。

我们通过上面的语法学习，在MTracer中生成了正则表达式：

bIterations(?<Iteration>d+)s(.*).*losss=s(?<loss>d*.*d+)b

并且采用多行模式解析出了我们想要的结果。

上面的表达式中，我们使用了捕获分组。

如下图：

那么如何转化成python代码？

正确的代码如下：

import re

pattern = re.compile(r'bIterations(?P<Iteration>d+)s(.*).*losss=s(?P<loss>d*.*d+)b')
arr=pattern.search("I1113 23:35:50.763059  4460 solver.cpp:218] Iteration 400 (27.3075 iter/s,loss = 0.0202583")
arr.groups()
arr.group()
arr.group("Iteration")
arr.group("loss")

结果为：

arr.groups()
Out[147]: ('400','0.0202583')

arr.group()
Out[148]: 'Iteration 400 (27.3075 iter/s,loss = 0.0202583'

arr.group("Iteration")
Out[149]: '400'

arr.group("loss")
Out[150]: '0.0202583'

这里python的命名组与以往的不一样，使用的是 (?P<name>exp) 取代(?<name>exp)

而且compile里面必须加上r。

参考文献：

http://blog.csdn.net/lwnylslwnyls/article/details/8901273

https://www.cnblogs.com/tk091/p/3702307.html

PYTHON的RE模块理解（RE.COMPILE、RE.MATCH、RE.SEARCH）

下面再列举python正则表达式的一些用法。

1. 多行匹配：
```
python多行匹配
r = re.compile("需要的正则表达式",re.M)

匹配到需要的字符，可以获取红括号内的数字
r = re.compile("r([0-9]{5,})")

举个例子： 需要获取20462和24729连个数字
import re
data = """
       r24062 line1
       hello word !!!!
       r24729 line2
       revision:24181
       """

   r = re.compile("^r([0-9]{5,})",re.M)
   nums = r.findall(data)
   print nums

---------------------
output:["24062","24729"]
```
2. 无捕获分组
当你要将一部分规则作为一个整体对它进行某些操作，比如指定其重复次数时，你需要将这部分规则用
```
(?:)
```
把它包围起来。

分支条件
在正则表达式中，分支条件是一个很常用的条件。

满足条件A 或者满足条件B ，这个时候我们就可以使用分支条件了。

分支条件使用的符号为
```
|
```
代码示例：

我们突然发现，它把字符串分割成两个部分了

I have a dog和 cat 而不是 I have a dog 和 I have a cat

如果我们只要区分dog和cat呢？正则要怎么写？我添加一个括号试试

还是不对，前面的 “I have a ”根本没有匹配

正确的写法是应该使用无捕获分组

参考：PYTHON的RE模块理解（RE.COMPILE、RE.MATCH、RE.SEARCH）

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!

正则表达式及其在python上的应用

python正则表达式

代码示例：