正则表达式（分组、零宽断言）

已于 2024-03-24 14:07:00 修改
阅读量1.8k 收藏 47
点赞数 47
分类专栏： Python数据分析 文章标签： 正则表达式 python
于 2024-03-21 20:55:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40214669/article/details/136911386
版权

目录

  • 正则表达式分组
    • 捕获组
      • 编号捕获组 (pattern)
      • 命名捕获组 (?\<name>pattern)
    • 非捕获组 (?:pattern)
  • 零宽断言
    • 先行断言
      • 零宽正向先行断言 (?=pattern1)pettern2
      • 零宽负向先行断言 (?!pattern1)pettern2
    • 后行断言
      • 零宽正向后行断言 (?<=pattern1)pettern2
      • 零宽负向后行断言 (?<!pattern1)pettern2

正则表达式分组

分组格式：一对小括号()表示。

  • 一个正则表达式中有几个()就表示有几个分组。
    ()：表示有1个分组，匹配空字符串。
    (\w)(\w)(\w)：表示有3个分组。
  • 分组（捕获组）索引以1开始，0表示整个正则表达式组。
    1表示你定义的第一个分组，以此类推。

分组类型：捕获组（Capturing Groups）与非捕获组Non-Capturing Groups。

分组目的：缓存捕获数据、反向引用、拆分匹配数据。

捕获组

我们通常所说的分组，默认就是指捕获组，用一对小括号(pattern)表示。
捕获组类型：

  • 编号捕获组Numbered Capturing Groups
  • 命名捕获组Named Capturing Groups

是否消耗原始字符串：是。

编号捕获组 (pattern)

  • 整体匹配（非分组模式，做对比展示）

    import re
# 原始字符串 = 产品名称_发布版本
raw_string = "CSDN_6.3.0"
pattern = "\w+_\d\.\d\.\d"
res = re.match(pattern,raw_string)
print(res)  # <re.Match object; span=(0, 10), match='CSDN_6.3.0'>
print(res.groups())  # ()          分组匹配为空
print(res.group(0))  # CSDN_6.3.0  整体匹配结果
# print(res.group(1))  # 无分组，会报错“IndexError: no such group”

  • 拆分并缓存捕获数据

    拆分匹配到的数据：

    • 将整体表达式 “\w+\d.\d.\d” ，拆分为 “(\w+)(\d.\d.\d)”，包含分组一(\w+) ，分组二(\d.\d.\d)

    缓存捕获数据：

    • 将分组中的正则表达式匹配到的内容，保存到该分组里面。
    import re
# 原始字符串 = 产品名称_发布版本
raw_string = "CSDN_6.3.0"
pattern = "(\w+)_(\d\.\d\.\d)"
res = re.match(pattern, raw_string)
print(res)  # <re.Match object; span=(0, 10), match='CSDN_6.3.0'>
print(res.groups())  # ('CSDN', '6.3.0') 两个分组
print(res.group(0))  # CSDN_6.3.0  整体匹配结果
print(res.group(1))  # CSDN        分组1匹配结果
print(res.group(2))  # 6.3.0       分组2匹配结果

  • 反向引用 \1

    引用格式：\number

    • number： 分组编号，从1开始，如：\1表示引用第一个分组的匹配结果

    作用：当原始字符串中出现不连续的相同子字符串时，可以通过分组引用的方式，简化匹配模式。

    特别注意：只引用匹配结果，而不是引用匹配模式。

    # 例1：CSDN_6.3.0_CSDN
import re
# 原始字符串 = 产品名称_发布版本
raw_string = "CSDN_6.3.0_CSDN"
pattern = r"(\w+)_(\d\.\d\.\d)_\1"
res = re.match(pattern, raw_string)
print(res)  # <re.Match object; span=(0, 15), match='CSDN_6.3.0_CSDN'>
print(res.groups())  # ('CSDN', '6.3.0') 两个分组
print(res.group(0))  # CSDN_6.3.0_CSDN   整体匹配结果
print(res.group(1))  # CSDN              分组1匹配结果
print(res.group(2))  # 6.3.0             分组2匹配结果
# print(res.group(3))                    报错，分组引用时，不会创建分组。\1引用的是匹配结果“CSDN”。

# 例2：<html>text</html>
import re
raw_string = "<html>testtext</html>"
pattern = r"<(\w+)>\w+</\1>"
res = re.match(pattern, raw_string)
print(res)  # <re.Match object; span=(0, 27), match='<html>thisistesttext</html>'>
print(res.groups())  # ('html',)                     两个分组
print(res.group(0))  # <html>thisistesttext</html>   整体匹配结果
print(res.group(1))  # html                          分组1匹配结果
# print(res.group(2))                                报错，分组引用时，不会创建分组。\1引用的是匹配结果“html”。

命名捕获组 (?<name>pattern)

语法：(?P<name>pattern)
优点：用命名捕获组会比较直观，可以用名称描述捕获到的内容的含义。

  • 基本使用

    import re
# 原始字符串 = 产品名称_发布版本
raw_string = "CSDN_6.3.0"
pattern = r"(?P<n1>\w+)_(?P<n2>\d\.\d\.\d)"
res = re.match(pattern,raw_string)
print(res)  # <re.Match object; span=(0, 10), match='CSDN_6.3.0'>
print(res.groups())     # ('CSDN', '6.3.0')
print(res.group(0))     # CSDN_6.3.0
print(res.group("n1"))  # CSDN
print(res.group("n2"))  # 6.3.0

  • 反向引用

    语法：

    • python：(?P=name)
    • 其他用法：\name、\k、\k’name’
    import re
# 原始字符串 = 产品名称_发布版本
raw_string = "CSDN_6.3.0_CSDN"
pattern = r"(?P<n1>\w+)_(?P<n2>\d\.\d\.\d)_(?P=n1)"
res = re.match(pattern,raw_string)
print(res)  # <re.Match object; span=(0, 15), match='CSDN_6.3.0_CSDN'>
print(res.groups())     # ('CSDN', '6.3.0')
print(res.group(0))     # CSDN_6.3.0_CSDN
print(res.group("n1"))  # CSDN
print(res.group("n2"))  # 6.3.0
# print(res.group(3))   # 报错，分组引用时，不会创建分组。(?P=n1)引用的是匹配结果“CSDN”。

非捕获组 (?:pattern)

在捕获组的基础上，在左括号的右侧加上?:，即：(?:pattern)。
不会把正则匹配到的内容保存到分组里面。提升效率。
是否消耗原始字符串：是。
是否保存匹配到的字符串到分组：否。

  • 基础用法

    import re
# 原始字符串 = 产品名称_发布版本
raw_string = "CSDN_6.3.0_CSDN"
pattern = r"(?P<n1>\w+)_(?:\d\.\d\.\d)_(?P=n1)"
res = re.match(pattern,raw_string)
print(res)  # <re.Match object; span=(0, 15), match='CSDN_6.3.0_CSDN'>
print(res.groups())     # ('CSDN', )  未保存第二个分组
print(res.group(0))     # CSDN_6.3.0_CSDN
print(res.group("n1"))  # CSDN
# print(res.group(1))   # 报错，非捕获分组不会保存匹配的数据，且分组引用时，也不会创建分组。(?P=n1)引用的是匹配结果“CSDN”。

  • 使用场景说明

    • 非捕获组和零宽断言的区别：
      • 非捕获组消耗原始字符串，零宽断言不消耗原始字符串。
    • 非捕获组和零宽断言的相同点：
      • 都不会创建分组，不会保存匹配结果到分组。

零宽断言

一种特殊形式的正则表达式，匹配时不消耗原始字符，只判断pattern1是否匹配成功，如同：^ $ \b等边界匹配一样。
然后根据pattern1匹配结果进行断言，断言结果为“成功”或者“失败”，作为是否进行下一步匹配的条件

  • 若断言“成功”，继续进行正则匹配，返回匹配结果。
  • 若断言“失败”，则终止匹配行为，返回为空。

4种场景：

  • 零宽正向先行断言
  • 零宽负向先行断言
  • 零宽正向后行断言
  • 零宽负向后行断言

零宽：表示不消耗原始字符串。去除pattern1后正则表达式依旧能够匹配到目标字符串。
断言：对pattern1匹配结果进行正/负向判断。
正向：表示pattern1匹配到字符串时，断言结果为true。
负向：与正向相反，表示pattern1匹配到字符串时，断言结果为false。

先行断言

断言先于匹配位置发生。相对于pattern1表达式后面的表达式（pattern2）而言。
pattern0捕获匹配 -> pattern1先行断言 -（先于pattern2判断）->pattern2捕获匹配->返回匹配结果。
即：
step1：先根据pattern0匹配原始字符串。
step2：用pattern1匹配pattern2左侧的字符串，然后对pettern1匹配结果进行断言，若断言失败，则返回：None。反之，则继续下一步pattern2的匹配。
step3：若pattern2匹配成功，则返回整合表达式的匹配结果，反之，返回结果为：None。

零宽正向先行断言 (?=pattern1)pettern2

满足pattern1匹配，为成功。
不满足pattern1匹配，为失败。

  • 示例
    import re
# 原始字符串 = 产品名称_发布版本
raw_string = "CSDN_6.3.0_CSDN"
# pattern0(?<=pattern1)pettern2
# 表达式技巧：去除零宽断言pattern1后，可以正常匹配字符串。
pattern = r"(\w+)_(?=\d\.\d\.\d)(.+)"
# 匹配逻辑：pattern0捕获匹配 -> pattern1先行断言 -（判断是否成功）->pattern2捕获匹配
res = re.match(pattern,raw_string)
print(res)  # <re.Match object; span=(0, 15), match='CSDN_6.3.0_CSDN'>
print(res.groups())     # ('CSDN', '6.3.0_CSDN') 未保存第二个分组
print(res.group(0))     # CSDN_6.3.0_CSDN
print(res.group(1))     # CSDN
print(res.group(2))     # 6.3.0_CSDN
# print(res.group(3))   # 报错，零宽断言不创建分组。

    匹配步骤：

    • step1：先根据pattern0匹配到第1个“CSDN”
    • step2：然后判断pattern1是否匹配成功CSDN_后面的字符串（匹配到“6.3.0”，成功）
    • step3：然后进行pattern2匹配（“.+”从“CSDN_”字符串开始匹配，匹配到“6.3.0_CSDN”）。

零宽负向先行断言 (?!pattern1)pettern2

满足pattern1匹配，为失败。
不满足pattern1匹配，为成功。
解释： pattern1匹配结果，进行“非”运算，结果与正向相反。

  • 示例1：断言成功
    import re
# 原始字符串 = 产品名称_发布版本
raw_string = "CSDN_6.3.0_CSDN"
# pattern0(?<=pattern1)pettern2
# 表达式技巧：去除零宽断言pattern1后，可以正常匹配字符串。
pattern = r"(\w+)_(?!AAA)(.+)"
# 匹配逻辑：pattern0捕获匹配 -> pattern1先行断言 -(先于pattern2判断)->pattern2捕获匹配
res = re.match(pattern,raw_string)
print(res)  # <re.Match object; span=(0, 15), match='CSDN_6.3.0_CSDN'>
print(res.groups())     # ('CSDN', '6.3.0_CSDN') 未保存第二个分组
print(res.group(0))     # CSDN_6.3.0_CSDN
print(res.group(1))     # CSDN
print(res.group(2))     # 6.3.0_CSDN
# print(res.group(3))   # 报错，零宽断言不创建分组。

    匹配步骤：

    • step1：先根据pattern0匹配到第1个“CSDN”
    • step2：然后判断pattern1是否匹配成功CSDN_后面的字符串（匹配不到“AAA”，成功）
    • step3：然后进行pattern2匹配（“.+”从“CSDN_”字符串开始匹配，匹配到“6.3.0_CSDN”）。
  • 示例2：断言失败
    import re
# 原始字符串 = 产品名称_发布版本
raw_string = "CSDN_6.3.0_CSDN"
# pattern0(?<=pattern1)pettern2
# 表达式技巧：去除零宽断言pattern1后，可以正常匹配字符串。
pattern = r"(\w+)_(?!\d\.\d\.\d)(.+)"
# 匹配逻辑：pattern0捕获匹配 -> pattern1先行断言 -(先于pattern2判断)-> pattern2捕获匹配
res = re.match(pattern,raw_string)
print(res)            # None
print(res.groups())   # 报错，res为None。

    匹配步骤：

    • step1：先根据pattern0匹配到第1个“CSDN”
    • step2：然后判断pattern1是否匹配成功CSDN_后面的字符串（匹配到“6.3.0”，成功）
    • step3：不会进行pattern2匹配，返回匹配结果为：None。

后行断言

断言晚于匹配位置发生。相对于pattern1表达式后面的表达式（pattern2）而言。
即：
step1：先根据正则表达式匹配到pattern2，若pattern2匹配失败，则返回：None。反之，则进行下一步pattern1匹配断言。
step2：用pattern1匹配pattern2左侧的字符串，然后对pettern1匹配结果进行断言。
step3：若断言成功，则返回整个表达式匹配结果。反之，断言失败，返回结果为：None。

零宽正向后行断言 (?<=pattern1)pettern2

  • 示例1：断言成功
    import re
# 原始字符串 = 产品名称_发布版本
raw_string = "CSDN_6.3.0_CSDN"
# pattern0(?<=pattern1)pettern2
# 表达式技巧：去除零宽断言pattern1后，可以正常匹配字符串。
pattern = r"(CSDN_\d\.\d\.\d)(?<=\d\.\d\.\d)_CSDN"
# 匹配逻辑：pattern0捕获匹配 -> pattern2捕获匹配 -> pattern1后行断言（晚于pattern2）
res = re.search(pattern,raw_string)
print(res)  # <re.Match object; span=(0, 15), match='CSDN_6.3.0_CSDN'>
print(res.groups())     # ('CSDN_6.3.0',) 
print(res.group(0))     # CSDN_6.3.0_CSDN   匹配结果
print(res.group(1))     # CSDN_6.3.0        分组值
print(res.group(2))     # 报错，零宽断言不创建分组。

    匹配步骤：

    • step1：先根据"CSDN_(\d.\d.\d)_CSDN进行匹配，匹配到“CSDN_6.3.0_CSDN”。
    • step2：断言：判断pattern1是否成功匹配“_CSDN”前字符串（匹配到“6.3.0”，成功）。
    • step3：返回step1匹配的结果。

零宽负向后行断言 (?<!pattern1)pettern2

  • 示例1：断言成功
    import re
# 原始字符串 = 产品名称_发布版本
raw_string = "CSDN_6.3.0_CSDN"
# pattern0(?<=pattern1)pettern2
# 表达式技巧：去除零宽断言pattern1后，可以正常匹配字符串。
pattern = r"(CSDN_\d\.\d\.\d)(?<!AAA)_CSDN"
# 匹配逻辑：pattern0捕获匹配 -> pattern2捕获匹配 -> pattern1后行断言（晚于pattern2）
res = re.search(pattern,raw_string)
print(res)  # <re.Match object; span=(0, 15), match='CSDN_6.3.0_CSDN'>
print(res.groups())     # ('CSDN_6.3.0',) 
print(res.group(0))     # CSDN_6.3.0_CSDN   匹配结果
print(res.group(1))     # CSDN_6.3.0        分组值
print(res.group(2))     # 报错，零宽断言不创建分组。

    匹配步骤：

    • step1：先根据"CSDN_(\d.\d.\d)_CSDN进行匹配，匹配到“CSDN_6.3.0_CSDN”。
    • step2：断言：判断pattern1是否成功匹配“_CSDN”前的字符串（未匹配到“AAA”，成功）。
    • step3：则返回step1匹配的结果。
  • 示例2：断言失败
    import re
# 原始字符串 = 产品名称_发布版本
raw_string = "CSDN_6.3.0_CSDN"
# pattern0(?<=pattern1)pettern2
# 表达式技巧：去除零宽断言pattern1后，可以正常匹配字符串。
pattern = r"(CSDN_\d\.\d\.\d)(?<!\d\.\d\.\d)_CSDN"
res = re.search(pattern,raw_string)
print(res)  # None

    匹配步骤：

    • step1：先根据"CSDN_(\d.\d.\d)_CSDN进行匹配，匹配到“CSDN_6.3.0_CSDN”。
    • step2：断言：判断pattern1是否成功匹配“_CSDN”前的字符串（匹配到“6.3.0”，失败）。
    • step3：返回结果为：None。
汝飞@大模型
关注
  • 47
    点赞
  • 踩
  • 47
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
正则表达式---零宽断言(五--正向零宽断言)
qq_40258437的博客
03-10 897
正向零宽断言： 1：(?=exp) 正向预测先行断言。匹配后面是exp的位置 2：(?&lt;=exp) 正向回顾后发断言。匹配前面是exp的位置 实例演示1： exp：&lt;div&gt;antzone； 正则：^(?=&lt;)&lt;[^&gt;]+&gt;\w+ 图示： 解释：^表示以位置0开始匹配（注意^是零宽符号，但不具备回溯），(?=&lt;)作为正向预...
[正则表达式] 匹配分组
柚子树's Blog
08-18 4268
1. 匹配分组相关正则表达式 代码 功能 | 匹配左右任意一个表达式 (ab) 将括号中字符作为一个分组 \num 引用分组num匹配到的字符串 (?P) 分组起别名 (?P=name) 引用别名为name分组匹配到的字符串 示例1：| 需求：在列表中[“apple”, “banana”, “orange”, “pear”]，匹配apple和pear import re # 水果列表 fruit_list = ["apple", "banana", "orange",
正则表达式高级用法: 分组
老王的专栏
02-13 9721
正则表达式高级用法: 分组分组的使用场景分组的使用方法捕获组分组的使用实例javascript 获取分组内容java 获取分组内容小结 分组的使用场景 在书写正则表达式时，通常情况下，我们有两种场景会使用到分组。 一是：对一个子表达式进行重复；二是：想要获取到子表达式匹配到的内容。 对子表达式进行重复 如果需要重复单个字符，直接在字符后面加上限定符即可，例如 a+ 表示匹配1个或一个以上的a，a?表示匹配0个或1个a。 但是我们如果要对多个字符进行重复的话，就需要用到 分组 。 比如：(ab){3} 表
正则表达之零宽断言（零宽度正预测先行断言）
weixin_30487701的博客
02-06 128
最近为了对html文件进行源码处理，需要进行正则查找并替换。于是借着这个机会把正则系统地学一下，虽然以前也用过正则，但每次都是临时学一下混过关的。在学习的过程中还是遇到不少问题的，特别是零宽断言（这里还要吐槽下，网上到处都是都复制粘贴的内容，遇到个问题查看了不少重复的东西，汗！！！），所以在这里把自己的理解写下来，方便以后查阅！ 零宽度正预测先行断言是什么呢，看...
正则表达式零宽断言详解
若末lan的博客
08-16 4811
在使用正则表达式时，有时我们需要捕获的内容前后必须是特定内容，但又不捕获这些特定内容的时候，零宽断言就起到作用了。 一.基本概念: 零宽断言正如它的名字一样，是一种零宽度的匹配，它匹配到的内容不会保存到匹配结果中去，最终匹配结果只是一个位置而已。 作用是给指定位置添加一个限定条件，用来规定此位置之前或者之后的字符必须满足限定条件才能使正则中的字表达式匹配成功。 注意:这里所说的子表达式并非...
正则表达式分组
m0_73357410的博客
05-03 193
在正则表达式中用（）进行分组如"(\\w|\\d){2,5}[2345]\\d+(\\w&&[^._])"而每一个分组都有自己的序号以左括号为标准第一个出现的为第一组其中（\\w|\\d）是第一组，(\\w&&[^._])是二组类似嵌套的正则(a*|(b+{9})其中该正则整体为第一组，(b+{9})为第二组。
正则表达式大全.docx
10-13
以上给出的正则表达式仅覆盖了一些基础用例，实际的正则表达式可以变得极其复杂，涉及更多的元字符和修饰符，如贪婪与非贪婪匹配、分组、零宽断言等。正则表达式的学习和掌握需要时间和实践，但一旦熟悉，它们将成为...
Python基础入门知识之正则表达式学习 正则表达式30分钟入门教程 共21页.pdf
06-04
零宽断言如`\b`表示单词边界，`\B`表示非单词边界，`(?=...)`和`(?!...)`是前瞻断言，`(?:...)`是无捕获分组。 十五、负向零宽断言 负向零宽断言如`(?<!...)`表示前面不匹配某个模式。 十六、注释 在正则表达式中...
Excel VBA 正则表达式视频教程
05-17
001_正则表达式初体验.wmv ...020_正则表达式非捕获分组之零宽断言.wmv 021_正则表达式非捕获分组之零宽断言2.wmv 022_正则表达式非捕获分组之负向零宽断言.wmv 023_正则表达式之贪婪与懒惰.wmv 024_正则表达式实例应用
正则表达式正则表达式.zip
12-15
10. 零宽断言：如"?"（向前看但不匹配）、"?"（向后看但不匹配），用于条件匹配，但不消耗字符。 正则表达式在不同的编程语言中可能有不同的实现和语法差异，例如Python的`re`模块、JavaScript的`RegExp`对象、Java...
正则表达式分组实例详解
12-13
正则表达式分组: 如果想匹配3个数字，正则表达式可以用如下写法: \d{3} 以上代码使用重复量词可以匹配3位数字。 但是在实际应用中，往往需要重复多个字符，例如我想重复ab两个字符，使用以下代码就不合适了，代码如下: ab{3} 以上正则表达式只能够重复3次b。 为了实现重复多个字符可以使用小括号来指定子表达式或者说分组来实现此功能，例如: (ab){3} 上面的正则就可以重复ab了。 所谓的分组就是使用小括号将一些项包括起来，使其成为独立的逻辑域，那么就可以像处理一个独立单元一样去处理小括号的内容。 下面看一段代码实例: (\d{1,3}\.){3}\d{1,3} 上面是一个简单的ip匹配
正则表达式30分钟入门教程.pdf
09-04
本教程涵盖了正则表达式的基本概念、元字符、字符转义、重复、字符类、分枝条件、反义、分组、后向引用、零宽断言、贪婪与懒惰、处理选项等知识点，旨在让读者在30分钟内明白正则表达式是什么，并对它有一些基本的...
正则表达式中的分组
Limerence的博客
08-13 889
正则表达式中的分组 正则表达式可以通过" () “来进行分组，更专业的表达就是捕获组，每个完整的” () “可以分为一组，同时，” () “中还可以嵌套” () "，即组之间还可以存在更小的组，以此类推。而编号为0的组，则是正则表达式匹配到的整体，这个规则只要支持正则表达式中捕获组的语言基本上都适用，下面举几个简单实用的小例子 public class Demo7_Regex { public ...
你必须掌握的常用正则表达式大全
JackChan
03-12 5805
你必须掌握的常用正则表达式大全
正则表达式——分组与捕获
尽力而为
06-20 1万+
因为在实际使用正则表达式的过程当中，碰到了对匹配结果进行一定的修改，而不是进行简单替换的使用场景。因此回过头来再仔细学习一下正则表达式中，分组与捕获的知识。
正则表达式详解
热门推荐
m0_56312312的博客
05-24 4万+
一、正则表达式概述 正则表达式是一组由字母和符号组成的特殊文本，它可以用来从文本中找出满足你想要的格式的句子。通俗的讲就是按照某种规则去匹配符合条件的字符串 一个正则表达式是一种从左到右匹配主体字符串的模式。 “Regular expression”这个词比较拗口，我们常使用缩写的术语“regex”或“regexp”。 正则表达式可以从一个基础字符串中根据一定的匹配模式替换文本中的字符串、...
最全常用正则表达式大全
forever
04-17 5032
18. 负浮点数：^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$ 或 ^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$17. 正浮点数：^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$ 或 ^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$
正则表达式（三）分组与引用
s31329的博客
07-01 1119
1.分组与编号 括号在正则中的功能就是用于分组， 被括号括起来的部分“子表达式”会被保存成一个子组。简单来理解就是，由多个元字符组成某个部分，应该被看成一个整体的时候，可以用括号括起来表示一个整体，这是括号的一个重要功能。其实用括号括起来还有另外一个作用，那就是“复用”。 1.1 编号如何算 从左往右，第几个左括号就是第几个分组。 1.2 不保存子组 在括号里面的会保存成子组，但有些情况下，你可能只想用括号将某些部分看成一个整体，后续不用再用它，类似这种情况，在实际使用时，是没必要保存子组的。这时我们可以在
正则表达式——捕获分组(capture group)(Java代码)
勤奋猫的博客
02-24 3907
正则大神主页：https://blog.csdn.net/lxcnn?t=1 正则表达式入门教程：https://deerchao.cn/tutorials/regex/regex.htm#top 上述两个博客的文章都是以C#为基础写作的，在普通捕获组与命名捕获组的混用上，与Java有所不同 正则运行测试网址：https://regex101.com/ 正则中，每个用于匹配字符的()都是一个子表达式，可以被捕获分组捕获到，从而在正则表达式内或表达式外进行引用。环视使用了()，但是它是用来匹配位置信息的，
正则表达式和扩展正则表达式的区别
最新发布
03-23
正则表达式（Regular Expression）是一种用于匹配、查找和替换文本的强大工具。它由一系列字符和特殊字符组成，可以用来描述字符串的模式。正则表达式在各种编程语言和文本编辑器中广泛使用。 扩展正则表达式（Extended Regular Expression）是正则表达式的一种扩展形式，它在基本正则表达式的基础上增加了一些功能和语法。扩展正则表达式通常用于更复杂的模式匹配和高级文本处理。 区别如下： 1. 语法：基本正则表达式使用简单的语法，包括字符、元字符和限定符等。而扩展正则表达式引入了更多的元字符和语法，如分组、反向引用、捕获组、零宽断言等。 2. 功能：扩展正则表达式提供了更多的功能，例如支持更复杂的模式匹配、更灵活的替换操作、更精确的字符类定义等。 3. 兼容性：基本正则表达式在不同的编程语言和工具中基本上是通用的，而扩展正则表达式可能会因为不同的实现而有所差异。 总结起来，扩展正则表达式相比基本正则表达式更强大、更灵活，但也更复杂。在实际使用中，可以根据具体需求选择使用基本正则表达式还是扩展正则表达式。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值