2024 Python3.10 系统入门+进阶（十六）：正则表达式

一、认识正则表达式
二、正则表达式基本语法
- 2.1 行界定符
- 2.2 单词定界符
- 2.3 字符类
- 2.4 选择符
- 2.5 范围符
- 2.6 排除符
- 2.7 限定符
- 2.8 任意字符
- 2.9 转义字符
- 2.10 反斜杠
- 2.11 小括号
- - 2.11.1 定义独立单元
  - 2.11.2 分组
- 2.12 反向引用
- 2.13 特殊构造
- 2.14 匹配模式
三、re模块
- 3.1 compile()方法——编译为正则表达式对象
- 3.2 escape()方法——转义特殊字符
- 3.3 f indall()方法——搜索所有符合正则表达式的字符串
- 3.4 f inditer()方法——找到所匹配的所有子串
- 3.5 fullmatch()方法——对整个字符串进行匹配
- 3.6 match()方法——从字符开始处进行匹配
- 3.7 search()方法——搜索第一个匹配位置
- 3.8 split()方法——根据正则表达式分割字符串
- 3.9 sub()方法——字符串替换
- 3.10 subn()方法——字符串替换（含替换次数）
- 3.11 Pattern的属性以及方法
- - 3.11.1 Pattern.flags属性——获取正则匹配标记
  - 3.11.2 Pattern.groups属性——捕获组合的数量
  - 3.11.3 Pattern.groupindex属性——获取分组名称与对应的分组编号
  - 3.11.4 Pattern.pattern属性——获取模式字符串
  - 3.11.5 Pattern.f indall()方法——搜索所有符合正则表达式的字符串
  - 3.11.6 Pattern.f inditer()方法——搜索所匹配的所有子串
  - 3.11.7 Pattern.fullmatch()方法——对整个字符串匹配
  - 3.11.8 Pattern.match()方法——从字符开始处匹配字符串的值
  - 3.11.9 Pattern.search()方法——搜索第一个匹配的位置
  - 3.11.10 Pattern.split()方法——同split()方法
  - 3.11.11 Pattern.sub()方法——字符串替换
  - 3.11.12 Pattern.subn()方法——字符串替换（含替换次数）
- 3.12 Match对象属性及方法
- - 3.12.1 Match.endpos属性——结束匹配的索引位置
  - 3.12.2 Match.pos属性——开始匹配的索引位置
  - 3.12.3 Match.lastindex属性——捕获组的最后一个匹配的索引值
  - 3.12.4 Match.lastgroup属性——获取最后一个匹配组的名称
  - 3.12.5 Match.re属性——返回正则表达式对象
  - 3.12.6 Match.string属性——获取需要匹配的字符串
  - 3.12.7 Match.`__getitem__()` 方法——返回一个匹配的分组信息
  - 3.12.8 Match.end()方法——返回分组匹配字符串对应的结束标记
  - 3.12.9 Match.expand()方法——对“\”进行转义替换并返回
  - 3.12.10 Match.groups()方法——以元组形式返回所有子组中内容
  - 3.12.11 Match.group()方法——返回一个或者多个匹配的子组
  - 3.12.12 Match.groupdict()方法——返回包含所有匹配值分组的字典
  - 3.12.13 Match.span()方法——返回包含开始和结束位置的二元组
  - 3.12.14 Match.start()方法——返回分组匹配字符串对应的开始标记

正则表达式是非常强大的字符串操作工具，其语法形式为一个特殊的字符序列，常用来对字符串进行匹配操作。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 特殊构造

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

使用下面语法可以设计小括号不分组，仅作为独立单元用于 '|' 或重复匹配。

(?:...)
# 例如，下面表达式仅用于界定逻辑作用范围，不用来分组
(?:\w)*  # 匹配0个或多个单词字符
(?:html|htm)  # 匹配html，或者匹配htm

定义匹配模式，使用下面语法可以定义表达式的匹配模式。

(?aiLmsux)正则表达式字符串
aiLmsux 中的每个字符代表一种匹配模式，具体说明参考 2.14 匹配模式 小节介绍
(?aiLmsux)只能够用在正则表达式的开头，可以多选。例如，下面表达式可以匹配a，也可以匹配A.
(?i)a

注释：使用下面语法可以在正则表达式中添加注释信息，"#" 后面的文本作为注释内容将被忽略掉。

(?#注释信息)
例如，在下面表达式中添加一句注释，以便表达式阅读和维护
a(?#匹配字符 abc)bc
上面表达式仅匹配字符串abc，小括号内的内容将被忽略

正前瞻，使用下面语法可以定义表达式后面必须满足特定的匹配条件。

(?=...)
# 例如，下面表达式仅匹配后面包含数字的字母a
a(?=\d)
# 后向匹配仅作为一个限定条件，其匹配的内容不作为表达式的匹配结果。

负前瞻：使用下面语法可以定义表达式后面必须不满足特定的匹配条件。

(?!...)
# 例如，下面表达式仅匹配后面不包含数字的字母a
a(?!\d)  # 后向不匹配仅作为一个限定条件，其匹配的内容不作为表达式的匹配结果。

正回顾：使用下面语法可以定义表达式前面必须满足特定的匹配条件。

(?<=...)
# 例如，下面表达式仅匹配前面包含数字的字母a
(?<=\d)a  # 前向匹配仅作为一个限定条件，其匹配的内容不作为表达式的匹配结果。

负回顾：使用下面语法可以定义表达式前面必须不满足特定的匹配条件。

(?<!...)
# 例如，下面表达式仅匹配前面不包含数字的字母a
(?<!\d)a  # 前向不匹配仅作为一个限定条件，其匹配的内容不作为表达式的匹配结果。

条件匹配：使用下面语法可以定义条件匹配表达式。

(?(id/name)yes-pattern|no-pattern)
id: 表示分组编号
name: 表示分组的别名，如果对应的分组匹配到字符，则选择 yes-pattern子表达式执行匹配
如果对应的分组没有匹配字符，则选择 no-pattern 子表达式执行匹配
|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/xw1680

import 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/xw1680


import 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/xw1680


import 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/xw1680


import 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/xw1680

import 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/xw1680

import 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/xw1680

import 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/xw1680


import 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/xw1680

import 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/xw1680


import 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/xw1680


import re  # 导入正则表达式re模块

# ('AA3456abcdef', 2)
print(re.subn('[1-2]', 'A', '123456abcdef'))  # 打印元组，包含新字符串与替换次数
# I have A, I have B ,I have C
print(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/xw1680


import 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/xw1680


import 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/xw1680


import 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/xw1680


import 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/xw1680


import 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/xw1680

import 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/xw1680

import 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/xw1680

import 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/xw1680

import 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/xw1680

import 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/xw1680

import 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/xw1680

import re  # 导入正则表达式re模块

pattern = re.compile('[1-2]')  # 数值替换表达式，替换字符串中的1-2
pattern2 = 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 C
print(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/xw1680

import 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/xw1680

import 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/xw1680

import 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/xw1680

import 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/xw1680

import 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/xw1680

import 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/xw1680


import 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_SHOP
print(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/xw1680

import 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 15
print(match.start(1), match.end(1))  # 打印编号1分组的匹配字符串对应的开始、结束标记 0 7
print(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/xw1680

import 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_SHOP
print(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/xw1680

import 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/xw1680

import 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_shop
print(match.group(1))  # 打印指定分组编号对应内容 MR_SHOP
print(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/xw1680


import 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/xw1680


import 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/xw1680


import 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 15
print(match.start(1), match.end(1))  # 打印编号1分组的匹配字符串对应的开始、结束标记 0 7
print(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/xw1680


import 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_shop
print(match)  # 打印需要移除的内容 <re.Match object; span=(3, 11), match='SHOP mr_'>
print(string[:match.start()] + string[match.end():])  # 打印移除后的内容 MR_shop