ToB企服应用市场:ToB评测及商务社交产业平台

标题: 2024 Python3.10 系统入门+进阶（十六）：正则表达式 [打印本页]

作者: 我可以不吃啊 时间: 2024-9-30 17:36
标题: 2024 Python3.10 系统入门+进阶（十六）：正则表达式
正则表达式黑白常强盛的字符串操作工具，其语法形式为一个特别的字符序列，常用来对字符串举行匹配操作。Python 从 1.5 版本开始新增 re 模块，提供 Perl 风格的正则表达式支持。本文将详细介绍正则表达式的根本语法，以及 Python 正则表达式尺度库的根本用法。
【学习重点】

了解正则表达式的相关概念。
掌握正则表达式的根本语法。
熟悉 Python 的 re 模块。
能够使用正则表达式办理实际标题。

一、熟悉正则表达式

正则表达式又称规则表达式（Regular Expression），在代码中简写为 regex、regexp 或 RE，通常被用来匹配符合指定模式（规则）的文本。当代盘算机编程语言都支持利用正则表达式举行字符串操作。实际上，正则表达式就是一种逻辑模板，是用事先定义好的一组特定字符，以及这些特定字符的任意组合，组成一个 "正则表达式字符串"， 这个 "正则表达式字符串" 用来表达对字符串的一种过滤逻辑。
给定一个正则表达式和一个被操作的字符串，可以到达以下目的：

验证被操作字符串是否符合正则表达式的匹配逻辑。
通过正则表达式，从被操作字符串中获取特定的信息，或者修改字符串。

Python 支持 Perl 风格的正则表达式语法。下面先了解与正则表达式相关的几个概念：

grep：grep 是一种强盛的文本搜刮工具，它能使用特定模式匹配（包括正则表达式）搜刮文本，并默认输出匹配行。
egrep：由于 grep 更新的速度无法与技术更新的速度同步。为此，贝尔实行室推出了 egrep，即扩展的 grep，这大大增强了正则表达式的能力。
POSIX：在 grep 发展的同时，其他一些开发人员也根据自己的喜欢开发出了具有独特风格的版本。但标题也随之而来，有的步伐支持某个元字符，而有的步伐则不支持，因此就有了 POSIX。POSIX 是一系列尺度，确保了操作系统之间的可移植性。但 POSIX 和 SQL 一样没有成为最终的尺度，而只能作为一个参考。
Perl: 1987年，Larry Wall 发布了 Perl 编程语言，它汲取了多种语言英华，并内部集成了正则表达式的功能，以及巨大的第三方代码库 CPAN。Perl 履历了从 Perl 1 到现在 Perl 6 的发展最终成了 POSIX 之后的另一个尺度。
PCRE：1997 年，Philip Hazel 开发了 PCRE 库，它是能够兼容 Perl 正则表达式的一套正则引擎，其他开发人员可以将 PCRE 整合到自己的语言中，为用户提供丰富的正则功能。

参考：https://www.w3cschool.cn/regex_rmjc/
分类：

1.BRE。基本正则表达式，grep、sed、vi等软件支持。vim有扩展。
2.ERE。扩展正则表达式，egrep（grep -E）、sed -r等。
3.PCRE。几乎所有高级语言都是PCRE的方言或者变种。Python从1.6开始使用SRE正则表达式引擎，可以认为是PCRE的子集，见模块re。

复制代码

二、正则表达式根本语法

在形式语言理论中，正则表达式被称为 "规则语言"，而不是编程语言。在 Python 中，"正则表达式" 这个概念包含两层含义：一个是正则表达式字符串；另一个是正则表达式对象。正则表达式字符串是正则表达式的文本表示，它经过编译后就成为正则表达式对象。正则表达式对象具有匹配功能。正则表达式字符串由两部分构成：元字符宁静凡字符。元字符是具有特别含义的字符，如 "." 和 "?"，平凡字符是仅指代自身的平凡字符，如数字、字母等。本小节将详细介绍各种元字符的含义和用法。
由于在这里我们还没有学习 re 模块，我们通过一个工具来学习正则表达式的根本语法，如下图所示：

软件下载地点：

通过网盘分享的文件：正则表达式
链接: https://pan.baidu.com/s/1TeYRnx1QkgHY6rfxlSQ9Jw?pwd=1946 提取码: 1946
--来自百度网盘超级会员v9的分享
网盘中带有一些正则表达式的文档资料，不需要可以直接下载正则表达式编写及调试工具.msi 软件

复制代码

2.1 行界定符

行界定符描述一行字符串的边界，具体说明如下：

^: 表示行的开始
$: 表示行的结尾
在多行匹配模式中，行定界符能够匹配每一行的行首和行尾位置。
① 单行模式: .可以匹配所有字符，包括换行符，^ 表示整个字符串的开头，$整个字符串的结尾
② 多行模式: .可以匹配除了换行符之外的字符，多行不影响.点号。^ 表示行首，$行尾，只不过这里的行是每一个行 ⇒ re.MULTILINE
③ 默认模式: 可以看做待匹配的文本是一行，不能看做多行，.点号不能匹配换行符，^和$表示行首和行尾，
而行首行尾就是整个字符串的开头和结尾
④ 单行模式: 基本和默认模式一样，只是.点号终于可以匹配任意一个字符包括换行符，这时所有文本就是一个长长的只有一行的字符串。
^就是这一行字符串的行首，$就是这一行的行尾。
⑤ 多行模式: 重新定义了行的概念，但不影响.点号的行为，^和$还是行首行尾的意思，只不过因为多行模式可以识别换行符了。
"开始"指的是\n后紧接着下一个字符；"结束"指的是\n前的字符，注意最后一行结尾可以没有\n
简单讲，单行模式只影响.点号行为，多行模式重新定义行影响了^和$
注意: 注意字符串中看不见的换行符,\r\n会影响e$的测试，e$只能匹配e\n

复制代码

示例1：.$ 指的是此行的结尾，而默认模式和单行模式都是一行，指的是这个大字符串的最后一个字符，就是 key 的 y。如下图所示：

示例2：上面第一行 happy 之后，有可能是 \r\n 结尾。y$ 单行匹配 key 的 y，多行匹配 happy 和 key 的 y。如下图所示：

留意： 都是选择 全部匹配 举行测试。假如选择匹配，则默认只匹配一次，即使是多行模式，也只会匹配上一个 y。如下图所示：

2.2 单词定界符

单词定界符描述一个单词的边界，具体说明如下：

\b: 表示单词边界
\B: 表示非单词边界
ps: 在正则表达式中，单词是由26个字母(含大小写)和10个数字组成的任意长度且连续的字符串。
单词与非单词类字符相邻的位置称为单词边界。

复制代码

示例1：使用 \b 定界符匹配一个完整的 "htm" 单词。如下图所示：

2.3 字符类

字符类也称为字符集，就是一个字符列表，表示匹配字符列表中的任意一个字符。使用方括号（[…]）可以定义字符类。例如，[abc]，可以匹配 a、b、c 中的任意一个字母。
示例1：下面正则表达式定义了匹配 html、HTML、Html、hTml 或 HTml 的字符类。

全部的特别字符在字符会集都失去了其原有的特别含义，仅表示字符自己。在字符会集假如要使用 [、]、- 或 ^，可以在 [、]、- 或 ^ 字符前面加上反斜杠，或者把 [、] 和 - 放在字符会集第 1 个字符位置，把 ^ 放在非第 1 个字符位置。下图正则表达式可以匹配一些特别字符：

2.4 选择符

选择符类似字符类，可以实现选择性匹配。使用 "|" 可以定义选择匹配模式，类似 Python 运算中的逻辑或。"|" 代表左右表达式任意匹配一个，它总是先实验匹配左侧的表达式，一旦乐成匹配，则跳出匹配右边的表达式。假如 "|" 没有被包括在小括号中，则它的匹配范围是整个正则表达式。
示例1：下面字符模式可以匹配 html，也可以匹配 Html。

加小括号，如下图所示：

2.5 范围符

使用字符类须要罗列全部可选字符，当可选字符比力多时就比力贫苦。不过，在字符类中可以使用连字符 "-" 定义字符范围。连字符左侧字符为范围起始点，右侧字符为范围终止点。字符范围都是根据字符编码表的位置关系来确定的。示例：

'[a-z]' # 匹配任意一个小写字母
'[A-Z]' # 匹配任意一个大写字母
'[0-9]' # 匹配任意一个数字
'[\u4e00-\u9fa5]' # 匹配中文字符
'[\x00-\xff]' # 匹配单字节字符
'[a-zA-Z0-9\u4e00-\u9fa5\x00-\xff]' # 也可以连着写

复制代码

2.6 扫除符

在字符类中，除了范围符外，尚有一个元字符：扫除符 (^)。将 '^' 放到方括号内最左侧，表示扫除字符列表，也就是将反转该集合的意义。类似 Python 运算中的逻辑非。示例：

'[^0-9]' # 匹配任意一个非数字
'[^\x00-\xff]' # 匹配非单字节字符

复制代码

2.7 限定符

限定符也称为数目词，用来指定正则表达式的一个给定字符、字符类或子表达式必须要出现多少次才气满足匹配。具体说明如下表所示：

2.8 任意字符

点号（"."）能够匹配除换行符 "\n" 之外的任何单字符。假如要匹配点号（"."）自己，须要使用 "\" 举行转义。留意： 在 re.DOTALL 模式下也能够匹配换行符。
示例：使用点号元字符匹配字符串 "gooooooogle" 中前面 6 个字符。

2.9 转义字符

转义字符 "\" 能够将特别字符变为平凡字符，如 "./*/^/$" 等，其功能与 Python 字符串中的转义字符类似。假如把特别字符放在中括号内定义字符集，也能够把特别字符变成平凡字符，如

等效于 \*，都可以用来匹配字符 *。
2.10 反斜杠

反斜杠字符 "\" 除了能够转义之外，还具有其他功能，具体说明如下：

定义非打印字符，具体说明如下表所示：
预定义字符集，具体说明如下表所示：
定义断言的限定符，具体说明如下表所示：

2.11 小括号

在正则表达式中，小括号有两个作用，简单说明如下。
2.11.1 定义独立单元

小括号可以改变选择符和限定符的作用范围。示例：

'(h|H)html'
'(goo){1,3}'

复制代码

在上面代码中，第 1 行正则表达式定义选择符范围为两个字符，而不是整个正则表达式；第 2 行正则表达式定义限定符限定的是 3 个字符，而不仅仅是左侧的第一个字符。
2.11.2 分组

小括号的第 2 个作用就是分组，即定义子表达式，子表达式相称于一个独立的正则表达式，后面要学到的反向引用与子表达式有直接的关系。子表达式能够临时存储其匹配的字符，然后可以在后面举行引用。正则表达式允许多次分组、嵌套分组，从表达式左边开始，第一个左括号 "(" 的编号为1，然后每遇到一个分组的左括号 "("，编号就加1。例如：

'(a(b(c)))'

复制代码

上面表达式中，编号1的子表达式为abc，编号2的子表达式为bc，编号3的子表达式为c。除了默认的编号外，也可以为分组定义一个别名。语法格式如下：

(?P<name>...)
# 例如下面的表达式可以匹配字符串 abcabcabc
(?P<id>abc){3}

复制代码

2.12 反向引用

在正则表达式，假如遇到分组，将导致子表达式匹配的字符被存储到一个临时缓冲区中，所捕获的每个子匹配都按照正则表达式中从左至右的顺序举行编号，从 1 开始，连续编号直至最大 99 个子表达式。每个缓冲区都可以使用 "\n" 访问，此中 n 为一个标识特定缓冲区的编号。示例：

对于正则表达式 "([ab])\1"，子表达式 "[ab]"，虽然可以匹配 'a' 或者 'b'，但是捕获组一旦匹配乐成，反向引用的内容也就确定了。假如捕获组匹配到 'a'，那么反向引用也只能匹配 'a'，同理，假如捕获组匹配到 'b'，那么反向引用也只能匹配 'b'。由于后面反向引用 '\1' 的限制，要求必须是两个相同的字符，在这里也就是 'aa' 或者 'bb' 才气匹配乐成。
2.13 特别构造

小括号不仅可以分组，也可以构造特别的结构，具体说明如下：

使用下面语法可以设计小括号不分组，仅作为独立单元用于 '|' 或重复匹配。
1. (?:...)
2. # 例如，下面表达式仅用于界定逻辑作用范围，不用来分组
3. (?:\w)* # 匹配0个或多个单词字符
4. (?:html|htm) # 匹配html，或者匹配htm
复制代码
定义匹配模式，使用下面语法可以定义表达式的匹配模式。
1. (?aiLmsux)正则表达式字符串
2. aiLmsux 中的每个字符代表一种匹配模式，具体说明参考 2.14 匹配模式小节介绍
3. (?aiLmsux)只能够用在正则表达式的开头，可以多选。例如，下面表达式可以匹配a，也可以匹配A.
4. (?i)a
复制代码
解释：使用下面语法可以在正则表达式中添加解释信息，"#" 后面的文本作为解释内容将被忽略掉。
1. (?#注释信息)
2. 例如，在下面表达式中添加一句注释，以便表达式阅读和维护
3. a(?#匹配字符 abc)bc
4. 上面表达式仅匹配字符串abc，小括号内的内容将被忽略
复制代码
正前瞻，使用下面语法可以定义表达式后面必须满足特定的匹配条件。
1. (?=...)
2. # 例如，下面表达式仅匹配后面包含数字的字母a
3. a(?=\d)
4. # 后向匹配仅作为一个限定条件，其匹配的内容不作为表达式的匹配结果。
复制代码
负前瞻：使用下面语法可以定义表达式后面必须不满足特定的匹配条件。
1. (?!...)
2. # 例如，下面表达式仅匹配后面不包含数字的字母a
3. a(?!\d) # 后向不匹配仅作为一个限定条件，其匹配的内容不作为表达式的匹配结果。
复制代码
正回顾：使用下面语法可以定义表达式前面必须满足特定的匹配条件。
1. (?<=...)
2. # 例如，下面表达式仅匹配前面包含数字的字母a
3. (?<=\d)a # 前向匹配仅作为一个限定条件，其匹配的内容不作为表达式的匹配结果。
复制代码
负回顾：使用下面语法可以定义表达式前面必须不满足特定的匹配条件。
1. (?<!...)
2. # 例如，下面表达式仅匹配前面不包含数字的字母a
3. (?<!\d)a # 前向不匹配仅作为一个限定条件，其匹配的内容不作为表达式的匹配结果。
复制代码
条件匹配：使用下面语法可以定义条件匹配表达式。
1. (?(id/name)yes-pattern|no-pattern)
2. id: 表示分组编号
3. name: 表示分组的别名，如果对应的分组匹配到字符，则选择 yes-pattern子表达式执行匹配
4. 如果对应的分组没有匹配字符，则选择 no-pattern 子表达式执行匹配
5. |no-pattern: 可以省略，直接写成语法: (?(id/name)yes-pattern)
复制代码

2.14 匹配模式

正则表达式可以包含一些可选的标志修饰符，用来控制匹配的模式。修饰符重要用来调解正则表达式的解释，扩展正则表达式在匹配、更换等操作时的某些功能，增强了正则表达式的能力。差别的语言都有自己的模式设置，Python 中的重要模式修饰符说明如下表所示：

这些标志修饰符重要用在正则表达式处置惩罚函数的 flag 参数中，为可选参数。多个标志可以通过按位 OR(|) 来指定，如 re.I|re.M，被设置成 I 和 M 标志。
三、re模块

Python 提供了 re 模块用于实现正则表达式的操作。在实现时，可以使用 re 模块提供的方法，如 search()、match()、findall() 等，举行字符串处置惩罚，也可以先使用 re 模块的 compile() 方法将模式字符串转换为正则表达式对象，然后再使用该正则表达式对象的相关方法来操作字符串。re 模块在使用时，须要先用 import 语句引入，具体代码如下：

import re

复制代码

3.1 compile()方法——编译为正则表达式对象

compile() 方法用于编译正则表达式模式，返回一个对象的模式。然后可以通过 RegexObject 对象调用 match() 和 search() 等方法。语法格式如下：

In [7]: re.compile?
Signature: re.compile(pattern, flags=0)
Docstring: Compile a regular expression pattern, returning a Pattern object.
File: f:\dev_tools\python\python310\lib\re.py
Type: function
参数说明:
1.pattern: 编译时用的表达式字符串。
2.flags: 编译标志位，用于修改正则表达式的匹配方式，如是否区分大小写、多行匹配等。
3.返回值: 返回一个正则表达式对象。

复制代码

示例:查找包含指定字母的单词。使用compile()方法创建一个可以查找包含指定字母对应单词的正则表达式对象,并输出符合条件的英文单词,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块# 须要匹配的字符串string = "Tina is a good girl, she is cool, clever, and so on..."match = re.compile(r'\w*oo\w*') # 创建正则表达式对象print(match.findall(string)) # 打印全部包含"oo"的单词

复制代码

3.2 escape()方法——转义特别字符

escape() 方法用于对字符串中的非字母数字举行转义。语法格式如下：

In [8]: re.escape?
Signature: re.escape(pattern)
Docstring: Escape special characters in a string.
File: f:\dev_tools\python\python310\lib\re.py
Type: function
参数说明:
1.pattern: 表示模式字符串，由要匹配的正则表达式转换而来。
2.返回值: 返回转义后的字符串。

复制代码

示例:对字符串中的非字母数字举行转义。使用escape()方法实现对字符串中的非字母数字举行转义,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块# 须要转义的字符串string = 'abcdefghijklmnopqrstuvwxyz0123456789!#$%&*+-.^_`|~'# abcdefghijklmnopqrstuvwxyz0123456789!\#\$%\&\*\+\-\.\^_`\|\~print(re.escape(string)) # 打印转义后的字符串

复制代码

3.3 f indall()方法——搜刮全部符合正则表达式的字符串

findall() 方法用于在整个字符串中搜刮全部符合正则表达式的字符串，并以列表的形式返回。假如匹配乐成，则返回包含匹配结构的列表，否则返回空列表。语法格式如下：

In [9]: re.findall?
Signature: re.findall(pattern, string, flags=0)
Docstring:
Return a list of all non-overlapping matches in the string.
If one or more capturing groups are present in the pattern, return
a list of groups; this will be a list of tuples if the pattern
has more than one group.
Empty matches are included in the result.
File: f:\dev_tools\python\python310\lib\re.py
Type: function
参数说明:
1.pattern: 表示模式字符串，由要匹配的正则表达式转换而来。
2.string: 表示要匹配的字符串。
3.flags: 可选参数，表示标志位，用于控制匹配方式，如是否区分字母大小写。
4.返回值: 返回一个符合表达式匹配结果的列表。

复制代码

示例:搜刮以“mr_”开头的字符串。使用findall()方法搜刮以“mr_”开头的字符串,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = r'mr_\w+' # 模式字符串string = 'MR_SHOP mr_shop' # 要匹配的字符串match = re.findall(pattern, string, re.I) # 搜刮字符串，不区分大小写print(match) # 打印匹配效果 ['MR_SHOP', 'mr_shop']string = '项目名称MR_SHOP mr_shop'match = re.findall(pattern, string) # 搜刮字符串，区分大小写print(match) # 打印匹配效果 ['mr_shop']

复制代码

3.4 f inditer()方法——找到所匹配的全部子串

finditer() 方法和 findall() 方法类似，它的功能为在字符串中找到正则表达式所匹配的全部子串，但是把它们作为一个迭代器返回。语法格式如下：

In [10]: re.finditer?
Signature: re.finditer(pattern, string, flags=0)
Docstring:
Return an iterator over all non-overlapping matches in the
string. For each match, the iterator returns a Match object.
Empty matches are included in the result.
File: f:\dev_tools\python\python310\lib\re.py
Type: function
参数说明:
1.pattern: 表示匹配的正则表达式。
2.string: 表示要匹配的字符串。
3.flags: 表示标志位，用户控制正则表达式的匹配方式，如是否区分大小写、多行匹配等。
4.返回值: 返回一个符合表达式匹配结果的迭代器。

复制代码

示例:获取字符串中的数字。使用finditer()方法获取字符串中的全部数值,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块# 获取字符串中的数字it = re.finditer(r"\d+", "12a32bc43jf3")# 便利获取后的迭代对象for match in it: print(type(match), match) # <class 're.Match'> <re.Match object; span=(3, 5), match='32'> print(match.group()) # 打印数字 12 32 43 3

复制代码

3.5 fullmatch()方法——对整个字符串举行匹配

fullmatch() 方法用于对整个字符串举行匹配，假如整个字符串匹配到正则表达式样式，就返回一个相应的匹配对象，否则就返回一个 None。语法格式如下：

In [11]: re.fullmatch?
Signature: re.fullmatch(pattern, string, flags=0)
Docstring:
Try to apply the pattern to all of the string, returning
a Match object, or None if no match was found.
File: f:\dev_tools\python\python310\lib\re.py
Type: function
参数说明:
1.pattern: 表示模式字符串，由要匹配的正则表达式转换而来。
2.string: 表示要匹配的字符串。
3.flags: 可选参数，表示标志位，用于控制匹配方式，如是否区分字母大小写。
4.返回值: 如果整个 string 匹配到正则表达式样式，就返回一个相应的 Match 对象。

复制代码

示例:匹配整个字符串。使用fullmatch()方法实现匹配整个字符串,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块string1 = "mr00soft" # 须要匹配的字符串# 匹配包括下划线在内的任何字符，并匹配前面的子表达式一次或多次match1 = re.fullmatch('\w+', string1)# 单个字符匹配任意次，贪婪匹配match2 = re.fullmatch('.*', string1)# 匹配多个数字match3 = re.fullmatch('\d+', string1)print(match1) # <re.Match object; span=(0, 8), match='mr00soft'>print(match2) # <re.Match object; span=(0, 8), match='mr00soft'>print(match3) # None

复制代码

3.6 match()方法——从字符开始处举行匹配

match() 方法用于从字符串的开始处举行匹配，假如在起始位置匹配乐成，则返回 Match 对象，否则返回 None。语法格式如下：

In [12]: re.match?
Signature: re.match(pattern, string, flags=0)
Docstring:
Try to apply the pattern at the start of the string, returning
a Match object, or None if no match was found.
File: f:\dev_tools\python\python310\lib\re.py
Type: function
参数说明:
1.pattern: 表示模式字符串，由要匹配的正则表达式转换而来。
2.string: 表示要匹配的字符串。
3.flags: 可选参数，表示标志位，用于控制匹配方式，如是否区分字母大小写。
4.返回值: 如果 string 的开始处有 0 或多个字符匹配到了正则表达式样式，就返回一个相应的Match 对象。

复制代码

示例:判断匹配字符串是否以“mr_”开头。使用match()方法判断匹配字符串是否以“mr_”开头,不区分字母大小写,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = r'mr_\w+' # 模式字符串string = 'MR_SHOP mr_shop' # 要匹配的字符串match = re.match(pattern, string, re.I) # 匹配字符串，不区分大小写print(match) # 打印匹配效果 <re.Match object; span=(0, 7), match='MR_SHOP'>string = '项目名称MR_SHOP mr_shop'match = re.match(pattern, string, re.I) # 匹配字符串，不区分大小写print(match) # 打印匹配效果 None

复制代码

3.7 search()方法——搜刮第一个匹配位置

search() 方法用于在整个字符串中搜刮第一个匹配的值，假如匹配乐成，则返回 Match 对象，否则返回 None。语法格式如下：

In [13]: re.search?
Signature: re.search(pattern, string, flags=0)
Docstring:
Scan through string looking for a match to the pattern, returning
a Match object, or None if no match was found.
File: f:\dev_tools\python\python310\lib\re.py
Type: function
参数说明:
1.pattern: 表示模式字符串，由要匹配的正则表达式转换而来。
2.string: 表示要匹配的字符串。
3.flags: 可选参数，表示标志位，用于控制匹配方式，如是否区分字母大小写。
4.返回值: 扫描整个字符串找到匹配样式的第一个位置，并返回一个相应的匹配对象。如果没有匹配，就返回一个 None。
注意，这和找到一个零长度匹配是不同的。

复制代码

示例:搜刮第一个以“mr_”开头的字符串,使用search()方法搜刮第一个以“mr_”开头的字符串,不区分字母大小写,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = r'mr_\w+' # 模式字符串string = 'MR_SHOP mr_shop' # 要匹配的字符串match = re.search(pattern, string, re.I) # 搜刮字符串，不区分大小写print(match) # 打印匹配效果 <re.Match object; span=(0, 7), match='MR_SHOP'>string = '项目名称MR_SHOP mr_shop'match = re.search(pattern, string, re.I) # 搜刮字符串，不区分大小写print(match) # 打印匹配效果 <re.Match object; span=(4, 11), match='MR_SHOP'>

复制代码

3.8 split()方法——根据正则表达式分割字符串

split() 方法用于实现根据正则表达式分割字符串，并以列表的形式返回。其作用同字符串对象的 split() 方法类似，所差别的就是分割字符由模式字符串指定。语法格式如下：

In [14]: re.split?
Signature: re.split(pattern, string, maxsplit=0, flags=0)
Docstring:
Split the source string by the occurrences of the pattern,
returning a list containing the resulting substrings. If
capturing parentheses are used in pattern, then the text of all
groups in the pattern are also returned as part of the resulting
list. If maxsplit is nonzero, at most maxsplit splits occur,
and the remainder of the string is returned as the final element
of the list.
File: f:\dev_tools\python\python310\lib\re.py
Type: function
参数说明:
1.pattern: 表示模式字符串，由要匹配的正则表达式转换而来。
2.string: 表示要匹配的字符串。
3.maxsplit: 可选参数，表示最大的拆分次数。
4.flags: 可选参数，表示标志位，用于控制匹配方式，如是否区分字母大小写。
5.返回值: 返回一个分割后的字符串列表。

复制代码

示例:从给定的 URL 地点中提取出哀求地点和各个参数。使用split()方法实现从给定的URL地点中提取出哀求地点和各个参数的功能,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = r'[?|&]' # 定义分割符url = 'http://www.mingrisoft.com/login.jsp?username="mr"&pwd="mrsoft"'result = re.split(pattern, url) # 分割字符串print(result) # ['http://www.mingrisoft.com/login.jsp', 'username="mr"', 'pwd="mrsoft"']

复制代码

3.9 sub()方法——字符串更换

sub() 方法用于实现字符串更换。语法格式如下：

In [15]: re.sub?
Signature: re.sub(pattern, repl, string, count=0, flags=0)
Docstring:
Return the string obtained by replacing the leftmost
non-overlapping occurrences of the pattern in string by the
replacement repl. repl can be either a string or a callable;
if a string, backslash escapes in it are processed. If it is
a callable, it's passed the Match object and must return
a replacement string to be used.
File: f:\dev_tools\python\python310\lib\re.py
Type: function
参数说明:
1.pattern: 表示模式字符串，由要匹配的正则表达式转换而来。
2.repl: 表示替换的字符串。
3.string: 表示要被查找替换的原始字符串。
4.count: 可选参数，表示模式匹配后替换的最大次数，默认值为 0，表示替换所有的匹配。
5.flags: 可选参数，表示标志位，用于控制匹配方式，如是否区分字母大小写。
6.返回值: 返回替换后的字符串。

复制代码

示例1:隐藏中奖信息中的手机号码。使用sub()方法实现隐藏中奖信息中的手机号码的功能,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = r'1[34578]\d{9}' # 定义要更换的模式字符串string = '中奖号码为：84978981 接洽电话为：13611111111'result = re.sub(pattern, '1XXXXXXXXXX', string) # 更换字符串print(result) # 中奖号码为：84978981 接洽电话为：1XXXXXXXXXX

复制代码

示例2:扫除字符串中的汉字、字母与数字。使用sub()方法扫除字符串中的汉字、字母与数字,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 定义须要筛选的字符串string = 'abcdefghijklmnopqrstuvwxyz我爱Python0123456789!#$%&*+-.^_`|~'result = re.sub("[A-Za-z0-9\u4e00-\u9fa5]", "", string) # 更换字符串print(result) # 打印更换效果 !#$%&*+-.^_`|~

复制代码

3.10 subn()方法——字符串更换（含更换次数）

subn() 方法与 sub() 方法相同，都是用于实现字符串的更换。但 subn() 方法返回一个元组，此中包含新字符串和更换次数。语法格式如下：

In [16]: re.subn?
Signature: re.subn(pattern, repl, string, count=0, flags=0)
Docstring:
Return a 2-tuple containing (new_string, number).
new_string is the string obtained by replacing the leftmost
non-overlapping occurrences of the pattern in the source
string by the replacement repl. number is the number of
substitutions that were made. repl can be either a string or a
callable; if a string, backslash escapes in it are processed.
If it is a callable, it's passed the Match object and must
return a replacement string to be used.
File: f:\dev_tools\python\python310\lib\re.py
Type: function
参数说明:
1.pattern: 表示模式字符串，由要匹配的正则表达式转换而来。
2.repl: 表示替换的字符串。
3.string: 表示要被查找替换的原始字符串。
4.count: 可选参数，表示模式匹配后替换的最大次数，默认值为 0，表示替换所有的匹配。
5.flags: 可选参数，表示标志位，用于控制匹配方式，如是否区分字母大小写。
6.返回值: 返回一个包含替换后字符串与替换次数的元组。

复制代码

示例:更换字符串中的指定内容。使用subn()方法实现更换字符串中的指定内容的功能,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块# ('AA3456abcdef', 2)print(re.subn('[1-2]', 'A', '123456abcdef')) # 打印元组，包含新字符串与更换次数# I have A, I have B ,I have Cprint(re.sub('g.t', 'have', 'I get A, I got B ,I gut C')) # 打印新字符串# ('I have A, I have B ,I have C', 3)print(re.subn('g.t', 'have', 'I get A, I got B ,I gut C')) # 打印元组，包含新字符串与更换次数

复制代码

3.11 Pattern的属性以及方法

3.11.1 Pattern.flags
属性——获取正则匹配标志

Pattern.flags
属性用于获取正则表达式中匹配模式对应的标志。语法格式如下：

Pattern.flags

复制代码

示例:获取常见匹配模式对应的标志。使用Pattern.flags
属性获取常见匹配模式对应的标志,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern_I = re.compile('\w+', flags=re.I) # 匹配模式，忽略大小写pattern_M = re.compile('\w+', flags=re.M) # 匹配模式，多行pattern_S = re.compile('\w+', flags=re.S) # 匹配模式，使用"."字符匹配全部字符，包括换行符pattern_X = re.compile('\w+', flags=re.X) # 匹配模式，忽略模式字符串中未转义的空格和解释print('匹配模式I的标志为：', pattern_I.flags)print('匹配模式M的标志为：', pattern_M.flags)print('匹配模式S的标志为：', pattern_S.flags)print('匹配模式X的标志为：', pattern_X.flags)

复制代码

3.11.2 Pattern.groups
属性——捕获组合的数目

Pattern.groups
属性用于获取正则表达式中组合的数目。语法格式如下：

Pattern.groups

复制代码

示例: 获取正则表达式中组合的数目。使用Pattern.groups
属性获取正则表达式中组合的数目,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = re.compile('(\w+) (\w+)') # 组合表达式print('组合数目为：', pattern.groups)

复制代码

3.11.3 Pattern.groupindex
属性——获取分组名称与对应的分组编号

Pattern.groupindex
属性用于获取正则表达式中分组名称与对应的分组编号。语法格式如下：

Pattern.groupindex

复制代码

示例:获取表达式中分组名称与对应的分组编号。使用Pattern.groupindex
属性获取表达式中分组名称与对应的分组编号,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = re.compile('(?P<group_1>\w+) (?P<group_2>\w+)') # 分组表达式# 分组名称与对应的编号为： {'group_1': 1, 'group_2': 2}print('分组名称与对应的编号为：', pattern.groupindex)

复制代码

3.11.4 Pattern.pattern
属性——获取模式字符串

Pattern.pattern
属性用于获取正则表达式中的模式字符串。语法格式如下：

Pattern.pattern

复制代码

示例:获取表达式中的模式字符串。使用Pattern.pattern
属性获取表达式中的模式字符串,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = re.compile('(?P<group_1>\w+) (?P<group_2>\w+)') # 分组表达式print(pattern.pattern) # (?P<group_1>\w+) (?P<group_2>\w+)

复制代码

3.11.5 Pattern.f indall()方法——搜刮全部符合正则表达式的字符串

Pattern.findall() 方法用于在整个字符串中搜刮全部符合正则表达式的字符串，并以列表的形式返回。假如匹配乐成，则返回包含匹配结构的列表，否则返回空列表。该方法可以指定匹配字符串的范围。语法格式如下：

In [21]: pattern.findall?
Signature: pattern.findall(string, pos=0, endpos=9223372036854775807)
Docstring: Return a list of all non-overlapping matches of pattern in string.
Type: builtin_function_or_method
参数说明:
1.string: 表示需要匹配的字符串。
2.pos: 表示匹配的起始位置，该参数为可选参数，默认值为 0。
3.endpos: 表示匹配的结束位置，该参数为可选参数，默认为需要匹配字符串的长度，所以只有从 pos 到 endpos-1 的字符会被匹配。
4.返回值: 返回一个符合表达式匹配结果的列表。

复制代码

示例:搜刮字符串中以“mr_”开头的字符串。使用Pattern.findall()方法搜刮字符串中以“mr_”开头的字符串,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = re.compile('mr_\w+') # 正则表达式对象string = 'mr_SHOP mr_shop' # 要匹配的字符串match = pattern.findall(string) # 搜刮字符串print(match) # 打印匹配效果 ['mr_SHOP', 'mr_shop']print(pattern.findall(string, 0, 5)) # 打印下标0~5的效果 ['mr_SH']

复制代码

3.11.6 Pattern.f inditer()方法——搜刮所匹配的全部子串

Pattern.finditer() 方法用于在字符串中找到正则表达式所匹配的全部子串，把它们作为一个迭代器返回。该方法可以指定匹配字符串的范围。语法格式如下：

In [28]: pattern.finditer?
Signature: pattern.finditer(string, pos=0, endpos=9223372036854775807)
Docstring:
Return an iterator over all non-overlapping matches for the RE pattern in string.
For each match, the iterator returns a match object.
Type: builtin_method
参数说明:
1.string: 表示需要匹配的字符串。
2.pos: 表示匹配的起始位置，该参数为可选参数，默认值为 0。
3.endpos: 表示匹配的结束位置，该参数为可选参数，默认为需要匹配字符串的长度，所以只有从 pos 到 endpos-1 的字符会被匹配。
4.返回值: 返回一个符合表达式匹配结果的迭代器。

复制代码

示例:获取字符串中指定范围的全部数字。使用Pattern.finditer()方法获取字符串中指定范围的全部数字,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = re.compile('\d+') # 正则表达式对象string = '12a32bc43jf3' # 要匹配的字符串it = pattern.finditer(string, 2, 8)# 遍历获取后的迭代对象for match in it: print(match.group()) # 打印数字

复制代码

3.11.7 Pattern.fullmatch()方法——对整个字符串匹配

Pattern.fullmatch() 方法用于对整个字符串匹配。从 pos 下标位置开始逐个对字符串举行匹配直到 endpos 下标位置，假如匹配乐成则返回匹配乐成的 Match 对象；假如没有匹配乐成，就返回None。语法格式如下：

In [27]: pattern.fullmatch?
Signature: pattern.fullmatch(string, pos=0, endpos=9223372036854775807)
Docstring: Matches against all of the string.
Type: builtin_method
参数说明:
1.string: 表示需要匹配的字符串。
2.pos: 表示匹配的起始位置，该参数为可选参数，默认值为 0。
3.endpos: 表示匹配的结束位置，该参数为可选参数，默认为需要匹配字符串的长度，所以只有从 pos 到 endpos-1 的字符会被匹配。
4.返回值: 如果整个 string 匹配到正则表达式样式，就返回一个相应的 Match 对象。

复制代码

示例:获取字符串中开始处符合表达式的值。使用Pattern.fullmatch()方法获取字符串中开始处符合表达式的值,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = re.compile('[a-z]+') # 定义匹配字母的表达式string = 'abcskd123jaw123' # 须要匹配的字符串print(pattern.fullmatch(string, 0, 5)) # 打印匹配效果，匹配范围0~5

复制代码

3.11.8 Pattern.match()方法——从字符开始处匹配字符串的值

Pattern.match() 方法用于从字符开始处匹配字符串的值，从 pos 下标位置开始逐个对字符串举行匹配直到 endpos 下标位置，假如匹配乐成则返回匹配乐成的 Match 对象；假如没有匹配乐成，就返回 None。语法格式如下：

In [26]: pattern.match?
Signature: pattern.match(string, pos=0, endpos=9223372036854775807)
Docstring: Matches zero or more characters at the beginning of the string.
Type: builtin_method
参数说明:
1.string: 表示需要匹配的字符串。
2.pos: 表示匹配的起始位置，该参数为可选参数，默认值为 0。
3.endpos: 表示匹配的结束位置，该参数为可选参数，默认为需要匹配字符串的长度，所以只有从 pos 到 endpos-1 的字符会被匹配。
4.返回值: 如果 string 开始的位置可以匹配到正则表达式样式，就返回一个相应的 Match 对象。

复制代码

示例:获取字符串中开始处符合表达式的值。使用Pattern.match()方法获取字符串中开始处符合表达式的值,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = re.compile('[a-z]+') # 定义匹配字母的表达式string = '12312abc1234546lskdj' # 须要匹配的字符串# <re.Match object; span=(5, 8), match='abc'>print(pattern.match(string, 5, 10)) # 打印匹配效果，匹配范围5~10

复制代码

3.11.9 Pattern.search()方法——搜刮第一个匹配的位置

Pattern.search() 方法用于搜刮第一个匹配的位置，从 pos 下标位置开始逐个对字符串举行匹配直到 endpos 下标位置，假如匹配乐成，则返回匹配乐成的 Match 对象，否则返回 None。语法格式如下：

In [25]: pattern.search?
Signature: pattern.search(string, pos=0, endpos=9223372036854775807)
Docstring:
Scan through string looking for a match, and return a corresponding match object instance.
Return None if no position in the string matches.
Type: builtin_method
参数说明:
1.string: 表示需要匹配的字符串。
2.pos: 表示匹配的起始位置，该参数为可选参数，默认值为 0。
3.endpos: 表示匹配的结束位置，该参数为可选参数，默认为需要匹配字符串的长度，所以只有从 pos 到 endpos-1 的字符会被匹配。
4.返回值: 扫描整个字符串找到匹配样式的第一个位置，并返回一个相应的匹配对象。

复制代码

示例:获取字符串中第一个匹配值与位置。使用Pattern.search()方法获取字符串中第一个匹配值与位置,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = re.compile('[0-9]+') # 定义匹配数字的表达式string = '12312abc1234546lskdj' # 须要匹配的字符串print(pattern.search(string, 0, 10)) # 打印匹配效果，匹配范围0~10

复制代码

3.11.10 Pattern.split()方法——同split()方法

Pattern.split() 方法与 re.split() 方法相同，用于实现根据正则表达式分割字符串，并以列表的形式返回。其作用同字符串对象的 split() 方法类似，所差别的是分割字符由模式字符串指定。语法格式如下：

In [24]: pattern.split?
Signature: pattern.split(string, maxsplit=0)
Docstring: Split string by the occurrences of pattern.
Type: builtin_function_or_method
参数说明:
1.string: 表示需要匹配的字符串。
2.maxsplit: 可选参数，表示最大的拆分次数。
3.返回值: 返回一个分割后的字符串列表。

复制代码

示例:从给定的 URL 地点中提取出哀求地点和各个参数。使用Pattern.split()方法实现从给定的URL地点中提取出哀求地点和各个参数,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = re.compile('[?|&]') # 定义分割符url = 'http://www.mingrisoft.com/login.jsp?username="mr"&pwd="mrsoft"'# ['http://www.mingrisoft.com/login.jsp', 'username="mr"', 'pwd="mrsoft"']result = pattern.split(url) # 分割字符串print(result)

复制代码

3.11.11 Pattern.sub()方法——字符串更换

Pattern.sub() 方法与 re.sub() 方法相同，用于实现字符串更换。语法格式如下：

In [23]: pattern.sub?
Signature: pattern.sub(repl, string, count=0)
Docstring: Return the string obtained by replacing the leftmost non-overlapping
occurrences of pattern in string by the replacement repl.
Type: builtin_method
参数说明:
1.repl: 表示替换的字符串。
2.string: 表示要被查找替换的原始字符串。
3.count: 可选参数，表示模式匹配后替换的最大次数，默认值为 0，表示替换所有的匹配。
4.返回值: 返回替换后的字符串。

复制代码

示例:隐藏中奖信息中的手机号码。使用Pattern.sub()方法实现隐藏中奖信息中的手机号码的功能,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = re.compile('1[34578]\d{9}') # 定义要更换的模式字符串string = '中奖号码为：84978981 接洽电话为：13611111111'result = pattern.sub('1XXXXXXXXXX', string) # 更换字符串print(result) # 中奖号码为：84978981 接洽电话为：1XXXXXXXXXX

复制代码

3.11.12 Pattern.subn()方法——字符串更换（含更换次数）

Pattern.subn() 方法与 re.subn() 方法相同，都是用于实现字符串的更换并返回一个元组，此中包含新字符串和更换次数。语法格式如下：

In [22]: pattern.subn?
Signature: pattern.subn(repl, string, count=0)
Docstring: Return the tuple (new_string, number_of_subs_made) found by replacing the leftmost
non-overlapping occurrences of pattern with the replacement repl.
Type: builtin_method
参数说明:
1.repl: 表示替换的字符串。
2.string: 表示要被查找替换的原始字符串。
3.count: 可选参数，表示模式匹配后替换的最大次数，默认值为 0，表示替换所有的匹配。
4.返回值: 返回一个包含替换后字符串与替换次数的元组。

复制代码

示例:更换字符串中的指定内容。使用Pattern.subn()方法实现更换字符串中的指定内容的功能,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = re.compile('[1-2]') # 数值更换表达式，更换字符串中的1-2pattern2 = re.compile('g.t') # 字幕更换表达式，更换字符串中的get、got、gut# 须要匹配的字符串string = '123456abcdef'string2 = 'I get A, I got B ,I gut C'print(pattern.subn('A', string)) # 打印元组，包含新字符串与更换次数 ('AA3456abcdef', 2)print(pattern2.sub('have', string2)) # 打印新字符串 I have A, I have B ,I have Cprint(pattern2.subn('have', string2)) # 打印元组，包含新字符串与更换次数 ('I have A, I have B ,I have C', 3)

复制代码

3.12 Match对象属性及方法

3.12.1 Match.endpos
属性——竣事匹配的索引位置

Match.endpos
属性用于获取正则表达式在字符串竣事匹配的索引位置。语法格式如下：

Match.endpos

复制代码

示例:获取正则表达式在字符串竣事匹配的索引位置。使用Match.endpos
属性获取正则表达式在字符串竣事匹配的索引位置,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = re.compile('mr_\w+') # 分组表达式string = 'MR_SHOP mr_shop' # 要匹配的字符串match = re.search(pattern, string) # 匹配效果Match对象print(match) # 打印匹配的Match对象 <re.Match object; span=(8, 15), match='mr_shop'>print(match.endpos) # 打印匹配的竣事位置 15

复制代码

3.12.2 Match.pos
属性——开始匹配的索引位置

Match.pos
属性用于获取正则表达式在字符串开始匹配的索引位置。语法格式如下：

Match.pos

复制代码

示例:获取正则表达式在字符串开始匹配的索引位置。使用Match.pos
属性获取正则表达式在字符串开始匹配的索引位置,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = re.compile('mr_\w+') # 分组表达式string = 'MR_SHOP mr_shop' # 要匹配的字符串match = re.search(pattern, string) # 匹配效果Match对象print(match) # 打印匹配的Match对象print(match.pos) # 打印匹配的起始位置

复制代码

3.12.3 Match.lastindex
属性——捕获组的最后一个匹配的索引值

Match.lastindex
属性用于捕获组的最后一个匹配的索引值。语法格式如下：

Match.lastindex

复制代码

示例:获取最后一个匹配到的组所对应的索引值。使用Match.lastindex
属性获取最后一个匹配到的组所对应的索引值,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = re.compile('(?P<group_1>\w+) (?P<group_2>\w+)', re.I) # 分组表达式string = 'MR_SHOP mr_shop' # 要匹配的字符串match = re.match(pattern, string) # 匹配效果Match对象print(match.lastindex) # 打印最后一个匹配到的组所对应的索引值 2

复制代码

3.12.4 Match.lastgroup属性——获取最后一个匹配组的名称

Match.lastgroup 属性用于获取最后一个匹配组的名称，假如匹配的组没著名字或者没有产生匹配的情况下，则返回 None。语法格式如下：

In [44]: match.lastgroup?
Type: NoneType
String form: None
Docstring: <no docstring>

复制代码

示例:获取最后一个匹配组的名称。使用Match.lastgroup属性获取最后一个匹配组的名称,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = re.compile('(?P<group_1>\w+) (?P<group_2>\w+)', re.I) # 分组表达式string = 'MR_SHOP mr_shop' # 要匹配的字符串match = re.match(pattern, string) # 匹配效果Match对象print(match.lastgroup) # 打印最后一个匹配组的名称

复制代码

3.12.5 Match.re属性——返回正则表达式对象

Match.re 属性用于获取产生 Match 实例的正则表达式对象。语法格式如下：

In [43]: match.re?
Type: Pattern
String form: re.compile('\\d')
File: f:\dev_tools\python\python310\lib\re.py
Docstring: Compiled regular expression object.

复制代码

示例:获取产生Match实例的正则表达式对象。使用Match.re属性获取产生Match实例的正则表达式对象,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = re.compile('(?P<group_1>\w+) (?P<group_2>\w+)', re.I) # 分组表达式string = 'MR_SHOP mr_shop' # 要匹配的字符串match = re.match(pattern, string) # 匹配效果Match对象print(match.re) # 打印获取的表达式对象

复制代码

3.12.6 Match.string属性——获取须要匹配的字符串

Match.string 属性用于获取 Match 对象中须要匹配的字符串。语法格式如下：

In [42]: match.string?
Type: str
String form: 123456
Length: 6
Docstring:
str(object='') -> str
str(bytes_or_buffer[, encoding[, errors]]) -> str
Create a new string object from the given object. If encoding or
errors is specified, then the object must expose a data buffer
that will be decoded using the given encoding and error handler.
Otherwise, returns the result of object.__str__() (if defined)
or repr(object).
encoding defaults to sys.getdefaultencoding().
errors defaults to 'strict'.

复制代码

示例:获取Match对象中须要匹配的字符串。使用Match.string属性获取Match对象中须要匹配的字符串,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = re.compile('(?P<group_1>\w+) (?P<group_2>\w+)', re.I) # 分组表达式string = 'MR_SHOP mr_shop' # 要匹配的字符串match = re.match(pattern, string) # 匹配效果Match对象print(match.string) # 打印Match对象中须要匹配的字符串 MR_SHOP mr_shop

复制代码

3.12.7 Match.__getitem__() 方法——返回一个匹配的分组信息

Match.__getitem__() 方法与 Match.group() 方法相似，只是 __getitem__() 方法每次只能获取一个分组的信息。语法格式如下：

In [41]: match.__getitem__?
Signature: match.__getitem__(key, /)
Call signature: match.__getitem__(*args, **kwargs)
Type: method-wrapper
String form: <method-wrapper '__getitem__' of re.Match object at 0x000001BEA4520240>
Docstring: Return self[key].
参数说明:
1.g: 表示分组对应的编号或分组名称。
2.返回值: 返回一个匹配的分组信息。

复制代码

示例:获取指定分组对应的信息。使用Match.__getitem__()方法获取指定分组对应的信息,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = re.compile('(?P<group_1>\w+) (?P<group_2>\w+)', re.I) # 分组表达式string = 'MR_SHOP mr_shop' # 要匹配的字符串match = re.match(pattern, string) # 匹配效果Match对象print(match.__getitem__(1)) # 打印指定分组编号对应内容 MR_SHOPprint(match.__getitem__('group_2')) # 打印指定分组名对应内容mr_shop

复制代码

3.12.8 Match.end()方法——返回分组匹配字符串对应的竣事标志

Match.end() 方法用于获取分组匹配字符串对应的竣事标志。语法格式如下：

In [40]: match.end?
Signature: match.end(group=0, /)
Docstring: Return index of the end of the substring matched by group.
Type: builtin_function_or_method
参数说明:
1.group: 表示分组名或者分组名对应的编号。
2.返回值: 返回分组匹配字符串对应的结束标记。

复制代码

示例:获取分组匹配字符串对应的开始、竣事标志。使用Match.start()方法与Match.end()方法获取分组匹配字符串对应的开始、竣事标志,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = re.compile('(?P<group_1>\w+) (?P<group_2>\w+)', re.I) # 分组表达式string = 'MR_SHOP mr_shop' # 要匹配的字符串match = re.match(pattern, string) # 匹配效果Match对象print(match.start(), match.end()) # 打印全部分组的匹配字符串对应的开始、竣事标志 0 15print(match.start(1), match.end(1)) # 打印编号1分组的匹配字符串对应的开始、竣事标志 0 7print(match.start(2), match.end(2)) # 打印编号2分组的匹配字符串对应的开始、竣事标志 8 15# 打印分组名的匹配字符串对应的开始、竣事标志print(match.start('group_1'), match.end('group_2')) # 0 15

复制代码

3.12.9 Match.expand()方法——对“\”举行转义更换并返回

Match.expand() 方法用于实现把字符串中用反斜杠 "\" 表示的数字或组名更换为相应分组中的值的功能。语法格式如下：

In [39]: match.expand?
Signature: match.expand(template)
Docstring: Return the string obtained by doing backslash substitution on the string template,
as done by the sub() method.
Type: builtin_function_or_method
参数说明:
1.template: 表示需要替换的字符串。
2.返回值: 返回对""进行转义替换的结果。

复制代码

示例:在字符串中指定位置更换对应分组中的值。使用Match.expand()方法,在字符串中指定位置更换对应分组中的值,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = re.compile('(?P<group_1>\w+) (?P<group_2>\w+)', re.I) # 分组表达式string = 'MR_SHOP mr_shop' # 要匹配的字符串match = re.match(pattern, string) # 匹配效果Match对象print(match[1]) # 打印分组1内容 MR_SHOPprint(match[2]) # 打印分组2内容 mr_shop# 第一种更换方式，\1、\2更换分组1和2的内容print(match.expand(r'first_ \1 \2')) # first_ MR_SHOP mr_shop# 第二种更换方式，\g<1>、\g<2>更换分组1和2的内容print(match.expand('second_ \g<1> \g<2>')) # second_ MR_SHOP mr_shop# 第三种更换方式，\g<group_1>、\g<group_2>更换分组1和2的内容print(match.expand('third_ \g<group_1> \g<group_2>')) # third_ MR_SHOP mr_shop

复制代码

3.12.10 Match.groups()方法——以元组形式返回全部子组中内容

Match.groups() 方法用于获取以元组形式返回全部子组中内容。语法格式如下：

In [38]: match.groups?
Signature: match.groups(default=None)
Docstring:
Return a tuple containing all the subgroups of the match, from 1.
default
Is used for groups that did not participate in the match.
Type: builtin_function_or_method
参数说明:
1.default: 用于不参与匹配的情况，默认为 None。
2.返回值: 以元组形式返回所有子组中内容。

复制代码

示例:获取全部分组对应的内容。使用Match.groups()方法获取全部分组对应的内容,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = re.compile('(?P<group_1>\w+) (?P<group_2>\w+)', re.I) # 分组表达式string = 'MR_SHOP mr_shop' # 要匹配的字符串match = re.match(pattern, string) # 匹配效果Match对象print(match.groups()) # 打印全部分组对应的内容 ('MR_SHOP', 'mr_shop')

复制代码

3.12.11 Match.group()方法——返回一个或者多个匹配的子组

Match.group() 方法用于获取 Match 对象中一个或多个匹配的子组。假如只有一个（0~99）参数，效果就是一个字符串；假如有多个参数，效果就是一个元组（每个参数对应一个项）；假如没有参数，组 1 默认到 0（整个匹配都被返回）。假如一个组 N 参数值为 0，相应的返回值就是整个匹配字符串；假如一个组号是负数或超出组的最大长度，则给出越界错误；假如正则表达式中的一个组匹配了多个值，则相应的组只生存最后匹配的值。语法格式如下：

In [37]: match.group?
Docstring:
group([group1, ...]) -> str or tuple.
Return subgroup(s) of the match by indices or names.
For 0 returns the entire match.
Type: builtin_function_or_method
参数说明:
1.group1: 表示分组对应的编号或分组名称。
2.返回值: 返回一个或者多个匹配的子组。

复制代码

示例:获取指定分组对应的信息。使用Match.group()方法获取指定分组对应的信息,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = re.compile('(?P<group_1>\w+) (?P<group_2>\w+)', re.I) # 分组表达式string = 'MR_SHOP mr_shop' # 要匹配的字符串match = re.match(pattern, string) # 匹配效果Match对象print(match.group()) # 无参数打印全部内容 MR_SHOP mr_shopprint(match.group(1)) # 打印指定分组编号对应内容 MR_SHOPprint(match.group('group_2')) # 打印指定分组名对应内容 mr_shop

复制代码

3.12.12 Match.groupdict()方法——返回包含全部匹配值分组的字典

Match.groupdict() 方法用于获取以字典形式返回包含全部匹配值分组的信息，此中 key 就是组名，value 就是分组匹配的信息内容。语法格式如下：

In [36]: match.groupdict?
Signature: match.groupdict(default=None)
Docstring:
Return a dictionary containing all the named subgroups of the match, keyed by the subgroup name.
default
Is used for groups that did not participate in the match.
Type: builtin_function_or_method
参数说明:
1.default: 用于不参与匹配的情况，默认为 None。
2.返回值: 以字典形式返回包含所有匹配值分组的信息。

复制代码

示例:获取字典形式的分组信息。使用Match.groupdict()方法获取字典形式的分组信息,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = re.compile('(?P<group_1>\w+) (?P<group_2>\w+)', re.I) # 分组表达式string = 'MR_SHOP mr_shop' # 要匹配的字符串match = re.match(pattern, string) # 匹配效果Match对象# {'group_1': 'MR_SHOP', 'group_2': 'mr_shop'}print(match.groupdict()) # 打印字典形式的分组信息

复制代码

3.12.13 Match.span()方法——返回包含开始和竣事位置的二元组

Match.span() 方法用于获取指定分组匹配字符串的开始和竣事位置。语法格式如下：

In [35]: match.span?
Signature: match.span(group=0, /)
Docstring: For match object m, return the 2-tuple (m.start(group), m.end(group)).
Type: builtin_function_or_method
参数说明:
1.group: 表示分组名或者分组名对应的编号。
2.返回值: 返回一个包含开始和结束位置的二元组。

复制代码

示例:获取指定分组匹配字符串的开始和竣事位置。使用Match.span()方法获取指定分组匹配字符串的开始和竣事位置,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = re.compile('(?P<group_1>\w+) (?P<group_2>\w+)', re.I) # 分组表达式string = 'MR_SHOP mr_shop' # 要匹配的字符串match = re.match(pattern, string) # 匹配效果Match对象print(match.span(1)) # 打印分组编号1匹配字符串对应的开始、竣事标志 (0, 7)print(match.span('group_2')) # 打印分组名group_2匹配字符串对应的开始、竣事标志 (8, 15)

复制代码

3.12.14 Match.start()方法——返回分组匹配字符串对应的开始标志

Match.start() 方法用于获取分组匹配字符串对应的开始标志。语法格式如下：

In [34]: match.start?
Signature: match.start(group=0, /)
Docstring: Return index of the start of the substring matched by group.
Type: builtin_function_or_method
参数说明:
1.group: 表示分组名或者分组名对应的编号。
2.返回值: 返回分组匹配字符串对应的开始标记。

复制代码

示例1:获取分组匹配字符串对应的开始、竣事标志。使用Match.start()方法与Match.end()方法获取分组匹配字符串对应的开始、竣事标志,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = re.compile('(?P<group_1>\w+) (?P<group_2>\w+)', re.I) # 分组表达式string = 'MR_SHOP mr_shop' # 要匹配的字符串match = re.match(pattern, string) # 匹配效果Match对象print(match.start(), match.end()) # 打印全部分组的匹配字符串对应的开始、竣事标志 0 15print(match.start(1), match.end(1)) # 打印编号1分组的匹配字符串对应的开始、竣事标志 0 7print(match.start(2), match.end(2)) # 打印编号2分组的匹配字符串对应的开始、竣事标志 8 15# 打印分组名的匹配字符串对应的开始、竣事标志print(match.start('group_1'), match.end('group_2')) # 0 15

复制代码

示例2:移除表达式搜刮的内容。通过Match.start()方法与Match.end()方法移除指定内容,代码如下:

# -*- coding: utf-8 -*-# @Time : 2024-09-25 9:50# @Author : AmoXiang# @File: re_demo.py# @Software: PyCharm# @Blog: https://blog.csdn.net/xw1680import re
# 导入正则表达式re模块pattern = re.compile('(?P<group_1>\w+) (?P<group_2>\w+)', re.I) # 分组表达式string = 'MR_SHOP mr_shop' # 要匹配的字符串match = re.search('SHOP mr_', string) # 匹配效果Match对象print(string) # 打印原字符串 MR_SHOP mr_shopprint(match) # 打印须要移除的内容 <re.Match object; span=(3, 11), match='SHOP mr_'>print(string[:match.start()] + string[match.end():]) # 打印移除后的内容 MR_shop

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)