脚本之家，脚本语言编程技术及教程分享平台！
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|shell|

服务器之家 - 脚本之家 - Python - Python中的re正则表达式模块

Python中的re正则表达式模块

2023-02-21 12:52springsnow Python

这篇文章介绍了Python中的re正则表达式模块，文中通过示例代码介绍的非常详细。对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下

一、re模块的基本使用

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

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

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

?
1
2
3
4
import re  # 第一步，要引入re模块
a = re.findall("匹配规则", "这个字符串是否有匹配规则的字符")  # 第二步，调用模块函数
print(a)  # 以列表形式返回匹配到的字符串
# ['匹配规则']

2、常见元字符

  • ^元字符:匹配字符串开头。
  • $元字符:匹配字符串末尾。
  • *元字符:匹配前一个字符0或多次
  • +元字符:匹配前一个字符1次或无限次
  • ?元字符(防止贪婪匹配):匹配一个字符0次或1次:还有一个功能是在量词后面加上？号防止贪婪匹配 。
  • {}元字符(范围):自定义字符数{m}匹配前一个字符m次，
    {m,n}匹配前一个字符m至n次，若省略n，则匹配m至无限次
    {0,}匹配前一个字符0或多次,等同于*元字符
    {+,}匹配前一个字符1次或无限次,等同于+元字符
    {0,1}匹配前一个字符0次或1次,等同于?元字符
  • []元字符(字符集):[]里的任意一个字符就匹配字符集。字符集中的字符可以逐个列出，也可以给出范围，如[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)* 那么*控制的前导字符就是()里的整体内容，不再是前导一个字符。
  • |元字符(或):就是前后其中一个符合就匹配

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

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

1、一种是直接在函数里书写规则，推荐使用

?
1
2
3
4
import re
 
a = re.findall("匹配规则", "这个字符串是否有匹配规则的字符")
print(a)  # ['匹配规则']

2、另一种是先将正则表达式的字符串形式编译为Pattern实例，然后使用Pattern实例处理文本并获得匹配结果（一个Match实例），最后使用Match实例获得信息，进行其他的操作。

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

这个方法是Pattern类的工厂方法。 第二个参数flag是匹配模式，取值可以使用按位或运算符'|'表示同时生效，比如re.I | re.M。

另外，你也可以直接在pattern字符串中指定模式，比如re.compile('pattern', re.I | re.M)与re.compile('(?im)pattern')是等价的。

?
1
2
3
4
5
6
7
8
9
10
11
import re
 
# 将正则表达式编译成Pattern对象
pattern = re.compile(r'hello')
 
# 使用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”。看如下代码：

?
1
2
3
4
5
6
7
8
9
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：不区分大小写

?
1
2
3
4
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()是在字符串全局匹配第一个符合规则的字符串

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
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()是在字符串全局匹配第一个符合规则的字符串

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
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、无分组：匹配所有合规则的字符串，匹配到的字符串放到一个列表中

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

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

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

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

?
1
2
3
4
5
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内容（即是空白），所以尽量避免使用，否则会有可能匹配出空字符串

?
1
2
3
4
5
import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.findall("(a)*", origin)
print(r)
# ['', '', '', '', '', '', 'a', '', '', '', '', '', '', '', '', 'a', '', '', '', '', '', '', '', '', 'a', '', '', '', '', 'a', '', '', '', '', '', '']

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

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

?
1
2
3
4
5
6
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、分组中有分组：只将匹配到的字符串里组的部分放到一个元组中，先将包含有组的组，看作一个整体也就是一个组，把这个整体组放入一个元组里，然后在把组里的组放入一个元组，最后将所有组放入一个列表返回

?
1
2
3
4
5
6
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()

?
1
2
3
4
5
6
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 ： 匹配模式

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

?
1
2
3
4
5
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']

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

?
1
2
3
4
5
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 ： 匹配模式
?
1
2
3
4
5
6
7
8
9
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 ： 匹配模式
?
1
2
3
4
5
6
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正则表达式模块的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持服务器之家。

原文链接：https://www.cnblogs.com/springsnow/p/11972921.html

  • Python
  • 正则表达式
  • re

    • 延伸 · 阅读

    精彩推荐
    • Python浅谈python新式类和旧式类区别

      浅谈python新式类和旧式类区别

      python的新式类是2.2版本引进来的，我们可以将之前的类叫做经典类或者旧式类。这篇文章主要介绍了浅谈python新式类和旧式类区别，具有一定的参考价值，...

      pythontab10242021-06-20
    • PythonPython可视化库之HoloViews的使用教程

      Python可视化库之HoloViews的使用教程

      本文主要为大家介绍了Python中一个优秀的可视化库—HoloViews，不仅能实现一些常见的统计图表绘制，而且其还拥有Matplotlib、Seaborn等库所不具备的交互效果...

      Python学习与数据挖掘6492022-10-11
    • PythonPython实现批量梯度下降法(BGD)拟合曲线

      Python实现批量梯度下降法(BGD)拟合曲线

      这篇文章主要介绍了Python实现批量梯度下降法(BGD)拟合曲线，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的...

      古明地板砖7402021-09-30
    • Python举例详解Python中threading模块的几个常用方法

      举例详解Python中threading模块的几个常用方法

      这篇文章主要介绍了举例详解Python中threading模块的几个常用方法,threading模块用来创建和操作线程,是Python学习当中的重要知识,需要的朋友可以参考下...

      Darkbull2522020-07-16
    • PythonPython机器学习从ResNet到DenseNet示例详解

      Python机器学习从ResNet到DenseNet示例详解

      ResNet极大地改变了如何参数化深层网络中函数的观点。稠密连接网络（DenseNet）在某种程度上是ResNet的逻辑扩展。让我们先从数学上了解下...

      Supre_yuan3822022-01-21
    • Pythonpython中leastsq函数的使用方法

      python中leastsq函数的使用方法

      这篇文章主要介绍了python中leastsq函数的使用方法，leastsq作用是最小化一组方程的平方和，下面文章举例说明详细内容，具有一的参考价值，需要的小伙伴...

      开始King4842022-11-03
    • Python深入理解Python中装饰器的用法

      深入理解Python中装饰器的用法

      装饰器的使用是Python的高级技巧之一,通过Decorator装饰器能够带来函数式编程中所需的很多特性,这里我们就来跟随文章一同深入理解Python中装饰器的用法,需...

      weakish3542020-08-30
    • Python对python插入数据库和生成插入sql的示例讲解

      对python插入数据库和生成插入sql的示例讲解

      今天小编就为大家分享一篇对python插入数据库和生成插入sql的示例讲解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      yan456jie7472021-04-19
    最近更新
    编辑推荐
    阅读排行
    热门标签
    2048 　 6006 　 6174 　 SLOTS 　 MELIAE 　 FEEDPARSER 　 暂存 　 持久性管理 　 pickle模块 　 THREADING 　 reduce 　 nignx 　 装饰器 　 函数式编程 　 兔子毒药 　 contextlib 　 监控文件 　 流量监控 　 Web框架 　 PIL库 　 高斯模糊 　 wxPython 　 调换 　 自定义模块 　 Python开发 　 元类 　 metaclass 　 魔术方法 　 DNSPod 　 动态解析域名 　
    © 2019-2023 脚本之家 | 服务器之家(www.tuohang.net)旗下站点 版权所有关于我们联系我们版权申明网站地图