python正则表达式re应用举例,python正则表达式re.match

　　本文介绍了Python中的re正则表达式模块，并通过示例代码对其进行了详细介绍。对大家的学习或者工作都有一定的参考价值，有需要的朋友可以参考一下。

一、re模块的基本使用

　　Python量词默认是贪婪的，总是试图匹配尽可能多的字符。正则表达式用于匹配处理字符串。

　　如果需要匹配文本中的字符，Python使用一个原生字符串来表示：r\\ 。同样，\\d匹配一个数字可以写成r\d 。

1、python 中使用正则表达式需要引入re模块

　　导入#第一步是引入re模块

　　A=re.findall(匹配规则，此字符串是否有匹配规则的字符)#第二步，调用模块函数。

　　Print(a) #以列表形式返回匹配的字符串。

　　# [匹配规则]

2、常见元字符

　　^元字符：匹配字符串开头。,$元字符：匹配字符串末尾。,*元字符：匹配前一个字符0或多次,+元字符：匹配前一个字符1次或无限次,?元字符(防止贪婪匹配):匹配一个字符0次或1次：,的另一个功能是添加？不。为了防止贪婪的匹配。{}元字符(范围):自定义字符数{ m }匹配前一个字符m次，

　　{m，n}匹配前一个字符m到n次；如果省略n，则匹配m无限次。

　　{0，}匹配前一个字符0次或更多次，相当于*元字符。

　　{，}匹配前一个字符一次或无限次，相当于元字符。

　　{0，1}匹配前一个字符0或1次，相当于？meta-[]元字符(字符集):[]里的任意一个字符就匹配字符集。字符集中的字符可以一个一个地列出，也可以给定一个范围，比如[abc]或[a-c]。【abc】表示否定，即不是ABC。

　　所有特殊字符在字符集中都失去了原来的特殊含义。使用\反斜杠转义来恢复特殊字符的特殊含义。[^]:反取，匹配出除[^]里面的字符.

　　如果将元字符写入字符集中，则由\d:匹配任何十进制数，它相当于类[0-9],\D:匹配任何非数字字符，它相当于类[^0-9],\s:匹配任何空白字符，它相当于类[\t\n\r\f\v],\S:匹配任何非空白字符，它相当于类[^\t\n\r\f\v],\w:匹配包括下划线在内任何字母数字字符，它相当于类[a-zA-Z0-9_],\W:匹配非任何字母数字字符包括下划线在内，它相当于类[^a-zA-Z0-9_]和()元字符(分组):.()进行匹配，内部是一个组，也可以理解为一个整体。

　　如果()后面跟有特殊元字符，如(adc)*，那么* control的前导字符就是()中的全部内容，而不是前导字符。元字符(或):就是前后其中一个符合就匹配

二、re模块中常用功能函数

1、 正则表达式的两种书写方式

　　1.一种是直接在函数中写规则，推荐使用.

　　进口re

　　A=re.findall(匹配规则，此字符串是否有匹配规则的字符)

　　打印(a) # [匹配规则]

　　2.另一种方式是将正则表达式的字符串形式编译成模式实例，然后使用模式实例处理文本并获取匹配结果(一个匹配实例)，最后使用匹配实例获取信息并执行其他操作。

　　re.compile(pattern[, flag])函数：用于将字符串形式的正则表达式编译为Pattern对象

　　这个方法是Pattern类的工厂方法。第二个参数flag是一个匹配模式，它的值可以用按位or运算符“”表示同时有效，比如re。我 re。M

　　此外，还可以直接在模式字符串中指定模式，这比

　　如re.compile('pattern', re.I re.M)与re.compile('(?im)pattern')是等价的。

import re
　　# 将正则表达式编译成Pattern对象
　　pattern = re.compile(rhello)
　　# 使用Pattern匹配文本，获得匹配结果，无法匹配时将返回None
　　match = pattern.match(hello world!)
　　if match:
　　 # 使用Match获得分组信息
　　 print(match.group()) # hello

2、匹配模式

　　下表是所有的正则匹配模式：

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

1、 re.S：扩展

　　在Python的正则表达式中，有一个参数为re.S。它表示 . 的作用扩展到整个字符串，包括\n。看如下代码：

import re
　　a = asdfhellopass:
　　 worldaf
　　b = re.findall(hello(.*?)world, a)
　　c = re.findall(hello(.*?)world, a, re.S)
　　print(b is , b) # b is []
　　print(c is , c) # c is [pass:\n ]

　　正则表达式中，.的作用是匹配除\n以外的任何字符，也就是说，它是在一行中进行匹配。这里的行是以\n进行区分的。a字符串有每行的末尾有一个\n，不过它不可见。

　　如果不使用re.S参数，则只在每一行内进行匹配，如果一行没有，就换下一行重新开始，不会跨行。而使用re.S参数以后，正则表达式会将这个字符串作为一个整体，将\n当做一个普通的字符加入到这个字符串中，在整体中进行匹配。

2、 re.I：不区分大小写

import re
　　res = re.findall(r"A", "abc", re.I)
　　print(res)# [a]

3、 分组函数

　　?P：（只对正则函数返回对象时有用）# ?P<>定义组里匹配内容的key(键)，<>里面写key名称，值就是匹配到的内容

　　取出匹配对象三种方法：（只对正则函数返回对象的有用）

• group() # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来，有参取匹配到的第几个如2
• groups() # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
• groupdict() # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果

3、re.match(常用)：从头匹配一个符合规则的字符串，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None

　　match(pattern, string, flags=0)

• pattern： 正则模型
• string ： 要匹配的字符串
• falgs ： 匹配模式

　　注意：match()函数 与 search()函数基本是一样的功能，不一样的就是match()匹配字符串开始位置的一个符合规则的字符串，search()是在字符串全局匹配第一个符合规则的字符串

import re
　　# 无分组
　　origin = "hello egon bcd egon lge egon acd 19"
　　r = re.match("h\w+", origin) # match，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None
　　print(r.group()) # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
　　print(r.groups()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
　　print(r.groupdict()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果
　　# hello
　　# ()
　　# {}
　　# 有分组
　　# 为何要有分组？提取匹配成功的指定内容（先匹配成功全部正则，再匹配成功的局部内容提取出来）
　　r = re.match("h(\w+)", origin) # match，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None
　　print(r.group()) # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
　　print(r.groups()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
　　print(r.groupdict()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果
　　# hello
　　# (ello,)
　　# {}
　　# 有两个分组定义了key
　　# 为何要有分组？提取匹配成功的指定内容（先匹配成功全部正则，再匹配成功的局部内容提取出来）
　　# ?P<>定义组里匹配内容的key(键)，<>里面写key名称，值就是匹配到的内容
　　r = re.match("(?Ph)(?P\w+)", origin)
　　print(r.group()) # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
　　print(r.groups()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
　　print(r.groupdict()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果
　　# hello
　　# (h, ello)
　　# {n1: h, n2: ello}

4、 re.search(pattern, string[, flags])：浏览整个字符串去匹配第一个符合规则的字符串，未匹配成功返回None

　　search(pattern, string, flags=0)

• pattern： 正则模型
• string ： 要匹配的字符串
• falgs ： 匹配模式

　　注意：match()函数 与 search()函数基本是一样的功能，不一样的就是match()匹配字符串开始位置的一个符合规则的字符串，search()是在字符串全局匹配第一个符合规则的字符串

import re
　　# 无分组
　　origin = "hello alex bcd alex lge alex acd 19"
　　# search浏览全部字符串，匹配第一符合规则的字符串，浏览整个字符串去匹配第一个，未匹配成功返回None
　　r = re.search("a\w+", origin)
　　print(r.group() ) # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
　　print(r.groups() ) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
　　print(r.groupdict() ) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果
　　# alex
　　# ()
　　# {}
　　# 有分组
　　# 为何要有分组？提取匹配成功的指定内容（先匹配成功全部正则，再匹配成功的局部内容提取出来）
　　r = re.search("a(\w+).*(\d)", origin)
　　print(r.group()) # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
　　print(r.groups()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
　　print(r.groupdict()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果
　　# alex bcd alex lge alex acd 19
　　# (lex, 9)
　　# {}
　　# 有两个分组定义了key
　　# 为何要有分组？提取匹配成功的指定内容（先匹配成功全部正则，再匹配成功的局部内容提取出来）
　　# ?P<>定义组里匹配内容的key(键)，<>里面写key名称，值就是匹配到的内容
　　r = re.search("a(?P\w+).*(?P\d)", origin)
　　print(r.group()) # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
　　print(r.groups()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
　　print(r.groupdict()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果
　　# alex bcd alex lge alex acd 19
　　# (lex, 9)
　　# {n1: lex, n2: 9}

5、 re.findall()(常用)：浏览全部字符串，匹配所有合规则的字符串，匹配到的字符串放到一个列表中，未匹配成功返回空列表

　　findall(pattern, string, flags=0)

• pattern： 正则模型
• string ： 要匹配的字符串
• falgs ： 匹配模式

　　注意：一旦匹配成，再次匹配，是从前一次匹配成功的，后面一位开始的，也可以理解为匹配成功的字符串，不在参与下次匹配。

1、无分组：匹配所有合规则的字符串，匹配到的字符串放到一个列表中

import re
　　# 无分组
　　r = re.findall("\d+\w\d+", "a2b3c4d5") # 浏览全部字符串，匹配所有合规则的字符串，匹配到的字符串放到一个列表中
　　print(r) # 注意：匹配成功的字符串，不在参与下次匹配,所以3c4也符合规则但是没匹配到
　　# [2b3, 4d5]

　　注意：如果没写匹配规则，也就是空规则，返回的是一个比原始字符串多一位的，空字符串列表

import re
　　# 无分组
　　r = re.findall("", "a2b3c4d5") # 浏览全部字符串，匹配所有合规则的字符串，匹配到的字符串放到一个列表中
　　print(r) # 注意：如果没写匹配规则，也就是空规则，返回的是一个比原始字符串多一位的，空字符串列表
　　# [, , , , , , , , ]

2、有分组：只将匹配到的字符串里组的部分放到列表里返回，相当于groups()方法

import re
　　origin = "hello alex bcd alex lge alex acd 19"
　　r = re.findall("a(\w+)", origin) # 有分组：只将匹配到的字符串里，组的部分放到列表里返回
　　print(r)
　　# [lex, lex, lex, cd]

　　注意：如果规则里只有一个组，而组后面是就表示组里的内容可以是0个或者多个，这样组里就有了两个意思，一个意思是匹配组里的内容，二个意思是匹配组里0内容（即是空白），所以尽量避免使用，否则会有可能匹配出空字符串

import re
　　origin = "hello alex bcd alex lge alex acd 19"
　　r = re.findall("(a)*", origin)
　　print(r)
　　# [, , , , , , a, , , , , , , , , a, , , , , , , , , a, , , , , a, , , , , , ]

3、多个分组：只将匹配到的字符串里组的部分放到一个元组中，最后将所有元组放到一个列表里返回。

　　相当于在group()结果里再将组的部分，分别拿出来放入一个元组，最后将所有元组放入一个列表返回

import re
　　origin = "hello alex bcd alex lge alex acd 19"
　　# 多个分组：只将匹配到的字符串里，组的部分放到一个元组中，最后将所有元组放到一个列表里返回
　　r = re.findall("(a)(\w+)", origin)
　　print(r)
　　# [(a, lex), (a, lex), (a, lex), (a, cd)]

4、分组中有分组：只将匹配到的字符串里组的部分放到一个元组中，先将包含有组的组，看作一个整体也就是一个组，把这个整体组放入一个元组里，然后在把组里的组放入一个元组，最后将所有组放入一个列表返回

import re
　　origin = "hello alex bcd alex lge alex acd 19"
　　# 分组中有分组：只将匹配到的字符串里，组的部分放到一个元组中，先将包含有组的组，看作一个整体也就是一个组，把这个整体组放入一个元组里，然后在把组里的组放入一个元组，最后将所有组放入一个列表返回
　　r = re.findall("(a)(\w+(e))", origin)
　　print(r)
　　# [(a, le, e), (a, le, e), (a, le, e)]

5、?:在有分组的情况下findall()函数，不只拿分组里的字符串，拿所有匹配到的字符串。

　　注意?:只用于不是返回正则对象的函数如findall()

import re
　　origin = "hello alex bcd alex lge alex acd 19"
　　# ?:在有分组的情况下，不只拿分组里的字符串，拿所有匹配到的字符串，注意?:只用于不是返回正则对象的函数如findall()
　　b = re.findall("a(?:\w+)", origin)
　　print(b)
　　# [alex, alex, alex, acd]

6、re.split()：根据正则匹配分割字符串，返回分割后的一个列表

　　split(pattern, string, maxsplit=0, flags=0)

• pattern： 正则模型
• string ： 要匹配的字符串
• maxsplit：指定分割个数
• flags ： 匹配模式

　　按照一个字符将全部字符串进行分割

import re
　　origin = "hello alex bcd alex lge alex acd 19"
　　r = re.split("a", origin) # 根据正则匹配分割字符串
　　print(r)
　　# [hello , lex bcd , lex lge , lex , cd 19]

　　将匹配到的字符串作为分割标准进行分割

import re
　　origin = "hello alex bcd alex lge alex 2acd 19"
　　r = re.split("a\w+", origin) # 根据正则匹配分割字符串
　　print(r)
　　# [hello , bcd , lge , 2, 19]

7、 re.sub()：替换匹配成功的指定位置字符串

　　sub(pattern, repl, string, count=0, flags=0)

• pattern： 正则模型
• repl ： 要替换的字符串
• string ： 要匹配的字符串
• count ： 指定匹配个数
• flags ： 匹配模式

import re
　　origin = "hello alex bcd alex lge alex acd 19"
　　r = re.sub("a", "替换", origin) # 替换匹配成功的指定位置字符串
　　print(r)
　　# hello 替换lex bcd 替换lex lge 替换lex 替换cd 19
　　l = [1 2 , 2 3, 3 4]
　　print(eval(re.sub(r\s*, , str(l))))
　　# [12, 23, 34]

8、 re.subn()：替换匹配成功的指定位置字符串,并且返回替换次数，可以用两个变量分别接受

　　subn(pattern, repl, string, count=0, flags=0)

• pattern： 正则模型
• repl ： 要替换的字符串
• string ： 要匹配的字符串
• count ： 指定匹配个数
• flags ： 匹配模式

import re
　　origin = "hello alex bcd alex lge alex acd 19"
　　a, b = re.subn("a", "替换", origin) # 替换匹配成功的指定位置字符串,并且返回替换次数，可以用两个变量分别接受
　　print(a) # hello 替换lex bcd 替换lex lge 替换lex 替换cd 19
　　print(b) # 4

　　到此这篇关于Python正则表达式模块的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持盛行IT软件开发工作室。