也指出了某些特性是不支持的,电子工业出版社

作者: 前端  发布:2019-11-29

内容简介  · · · · · ·

《正则指引》针对作者在开发中遇到的实际问题,以及其他开发人员咨询的问题,总结出一套使用正则表达式解题的办法,并通过具体的例子指导读者拆解、分析问题。全书分为三大部分:第一部分主要讲解正则表达式的基础知识,涵盖了常见正则表达式中的各种功能和结构;第二部分主要讲解关于正则表达式的更深入的知识,详细探讨了编码问题、匹配原理、解题思路;第三部分将之前介绍的各种知识落实到6种常用语言.NET、Java、JavaScript、PHP、Python、Ruby中,不但详细介绍了语言中正则表达式的用法,更点明了版本之间的细微差异,既可以作为专门学习的教材,也可以作为有用的参考手册。

本书适合经常需要进行文本处理(比如日志分析或网络运维)的技术人员、熟悉常用开发语言的程序员,以及已经对正则表达式有一定了解的读者阅读。

第 三 部 分
第10章 .net 168
10.1 预备知识 168
10.2 正则功能详解 169
10.2.1 列表 169
10.2.2 字符组 170
10.2.3 unicode属性 170
10.2.4 字符组简记法 171
10.2.5 单词边界 171
10.2.6 行起始/结束位置 172
10.2.7 环视 173
10.2.8 匹配模式 173
10.2.9 捕获分组的引用 174
10.3 正则api简介 175
10.3.1 regex 175
10.3.2 match 179
10.4 常用操作示例 180
10.4.1 验证 180
10.4.2 提取 180
10.4.3 替换 181
10.4.4 切分 182
第11章 java 183
11.1 预备知识 183
11.2 正则功能详解 184
11.2.1 列表 184
11.2.2 字符组 184
11.2.3 unicode属性 186
11.2.4 字符组简记法 186
11.2.5 单词边界 186
11.2.6 行起始/结束位置 187
11.2.7 环视 188
11.2.8 匹配模式 188
11.2.9 纯文本模式 189
11.2.10 捕获分组的引用 189
11.3 正则api简介 189
11.3.1 pattern 190
11.3.2 matcher 192
11.3.3 string 194
11.4 常用操作示例 195
11.4.1 验证 195
11.4.2 提取 196
11.4.3 替换 196
11.4.4 切分 197
第12章 javascript 198
12.1 预备知识 198
12.2 正则功能详解 199
12.2.1 列表 199
12.2.2 字符组 199
12.2.3 字符组简记法 200
12.2.4 单词边界 200
12.2.5 行起始/结束位置 201
12.2.6 环视 201
12.2.7 匹配模式 202
12.2.8 捕获分组的引用 203
12.3 正则api简介 203
12.3.1 regexp 203
12.3.2 string 207
12.4 常用操作示例 210
12.4.1 验证 210
12.4.2 提取 210
12.4.3 替换 211
12.4.4 切分 211
12.5 关于actionscript 211
12.5.1 regexp 211
12.5.2 匹配规则 212
12.5.3 匹配模式 212
12.5.4 正则api 212
第13章 php 213
13.1 预备知识 213
13.2 正则功能详解 215
13.2.1 列表 215
13.2.2 字符组 216
13.2.3 unicode属性 217
13.2.4 字符组简记法 217
13.2.5 单词边界 217
13.2.6 行起始/结束位置 218
13.2.7 环视 219
13.2.8 匹配模式 219
13.2.9 纯文本模式 220
13.2.10 捕获分组的引用 220
13.3 正则api简介 221
13.3.1 preg 常量说明 221
13.3.2 preg_quote 222
13.3.3 preg_ grep 223
13.3.4 preg_match 223
13.3.5 preg_match_all 225
13.3.6 preg_ last_ error 227
13.3.7 preg_replace 227
13.3.8 preg_ replace_ callback 227
13.3.9 preg_ filter 228
13.3.10 preg_ split 229
13.4 常见的正则操作举例 230
13.4.1 验证 230
13.4.2 提取 230
13.4.3 替换 231
13.4.4 切分 232
第14章 python 233
14.1 预备知识 233
14.2 正则功能详解 234
14.2.1 列表 234
14.2.2 字符组 235
14.2.3 unicode属性 236
14.2.4 字符组简记法 236
14.2.5 单词边界 238
14.2.6 行起始/结束位置 239
14.2.7 环视 239
14.2.8 匹配模式 240
14.2.9 捕获分组的引用 240
14.3 正则api简介 241
14.3.1 regexobject 241
14.3.2 re.compile(regex[, flags]) 243
14.3.3 re.search(pattern, string[, flags]) 243
14.3.4 matchobject 243
14.3.5 re.match(pattern, string[, flags]) 244
14.3.6 re.findall(pattern, sting[, flags]) 245
14.3.7 re.finditer(pattern, string[, flags]) 245
14.3.8 re.split(pattern, string[, maxsplit=0, flags=0]) 246
14.3.9 re.sub(pattern, repl, string[, count, flags]) 247
14.4 常用操作示例 248
14.4.1 验证 248
14.4.2 提取 248
14.4.3 替换 249
14.4.4 切分 250
第15章 ruby 251
15.1 预备知识 251
15.2 正则功能详解 252
15.2.1 列表 252
15.2.2 字符组 252
15.2.3 unicode属性 253
15.2.4 字符组简记法 254
15.2.5 单词边界 254
15.2.6 行起始/结束位置 255
15.2.7 环视 256
15.2.8 匹配模式 256
15.2.9 捕获分组的引用 257
15.3 正则api简介 257
15.3.1 regexp 257
15.3.2 regexp.match(text) 259
15.3.3 regexp.quote(text)和regexp.escape(text) 260
15.3.4 string.index(regexp) 261
15.3.5 string.scan(regexp) 261
15.3.6 string.slice(regexp) 262
15.3.7 string.split(regexp) 262
15.3.8 string.sub(regexp, str) 263
15.3.9 string.gsub(regexp, string) 264
15.4 常用操作示例 264
15.4.1 验证 264
15.4.2 提取 265
15.4.3 替换 265
15.4.4 切分 265
15.5 ruby 1.9的新变化 266
第16章 linux/unix 268
16.1 posix 268
16.1.1 posix规范 268
16.1.2 posix字符组 269
16.2 vi 271
16.2.1 字符组及简记法 271
16.2.2 量词 272
16.2.3 多选结构和捕获分组 272
16.2.4 环视 273
16.2.5 锚点和单词边界 273
16.2.6 替换操作的特殊字符 274
16.2.7 replacement中的特殊变量 276
16.2.8 补充 276
16.3 grep 277
16.3.1 基本用法 277
16.3.2 字符组 277
16.3.3 锚点和单词边界 278
16.3.4 量词 278
16.3.5 多选结构和捕获分组 279
16.3.6 options 279
16.3.7 egrep和fgrep 280
16.3.8 补充 280
16.4 awk 281
16.4.1 基本用法 281
16.4.2 字符组及简记法 282
16.4.3 锚点和单词边界 283
16.4.4 量词 283
16.4.5 多选结构 284
9159.com,16.4.6 补充 284
16.5 sed 284
16.5.1 基本用法 284
16.5.2 字符组及简记法 285
16.5.3 锚点和单词边界 285
16.5.4 量词 286
16.5.5 多选结构和捕获分组 286
16.5.6 options 286
16.5.7 补充 287
16.6 总结 288
附录a 常用语言中正则特性一览 291
附录b 常用的正则表达式 293
附录c 常用的正则表达式工具及资源 309
本图书来源于:中国互动出版网

 

行起始/结束为位置

^匹配字符串开始的位置。

$匹配字符串结束的位置。

前面已经说了:多行模式影响的是^$的匹配规则。

在不指定多行模式的情况下:^匹配的是整个字符串的开始位置,$匹配的是整个字符串的结束位置。

当在多行模式下:^匹配的是字符串的起始位置以及换行之后行终止符之后的位置,如果字符串末尾出现了行终止符,则依旧匹配行终止符之后的那个位置;$匹配的是字符串的结束位置,但是这个位置是在字符结束之后行终止符之前的位置。

python中还有一个特殊标记Z,它和$类似,但是他不受多行模式的影响,Z不管行终止符,他匹配的是整个字符串的结束位置,在行终止符之后的位置。

^$的另一个特点是在进行正则表达式替换的时候并不会被替换。也就是说,在起始和结束位置进行替换,只会在起始和结束位置添加一些字符,位置本身依然存在。

短评  · · · · · ·  

  • ### Fenng 2012-05-17

    开发者必备技能,业余必修课程。其实不是开发者,比如会计师,比如经常做统计的,日常也用得上。

  • ### Sean  2012-11-28

    做文本挖掘很有用

  • ### 中途迷路Dante  2013-01-27

    Rush了一遍,前面的细则还是不是很清楚,我是那种准备到时候再查书的货,有有穷自动机讲得比较简单。不过也说到点上,说清楚了正则是怎样通过回溯来匹配的。按“必然出现”“可能出现”“不能出现”构造正则这个方法简单实用。嗯将来刷掌握正则表达式!

 

内容简介

书籍
计算机书籍
  《正则指引》针对作者在开发中遇到的实际问题,以及其他开发人员咨询的问题,总结出一套使用正则表达式解题的办法,并通过具体的例子指导读者拆解、分析问题。全书分为三大部分:第一部分主要讲解正则表达式的基础知识,涵盖了常见正则表达式中的各种功能和结构;第二部分主要讲解关于正则表达式的更深入的知识,详细探讨了编码问题、匹配原理、解题思路;第三部分将之前介绍的各种知识落实到6种常用语言.net、java、javascript、php、python、ruby中,不但详细介绍了语言中正则表达式的用法,更点明了版本之间的细微差异,既可以作为专门学习的教材,也可以作为有用的参考手册。
  《正则指引》适合经常需要进行文本处理(比如日志分析或网络运维)的技术人员、熟悉常用开发语言的程序员,以及已经对正则表达式有一定了解的读者阅读。

 

 

实践是检验真理的唯一标准。你以为的并不是你以为的,如有问题还是要写一个例子用多个工具验证下最好。

目录  · · · · · ·

第一部 分
第1章 字符组
1.1 普通字符组
1.2 关于Python的基础知识
1.3 普通字符组(续)
1.4 元字符与转义
1.5 排除型字符组
1.6 字符组简记法
1.7 字符组运算
1.8 POSIX字符组
第2章 量词
2.1 一般形式
2.2 常用量词
2.3 数据提取
2.4 点号
2.5 滥用点号的问题
2.6 忽略优先量词
2.7 转义
第3章 括号
3.1 分组
3.2 多选结构
3.3 引用分组
3.3.1 反向引用
3.3.2 各种引用的记法
3.3.3 命名分组
3.4 非捕获分组
3.5 补充
3.5.1 转义
3.5.2 URL Rewrite
3.5.3 一个例子
第4章 断言
4.1 单词边界
4.2 行起始/结束位置
4.3 环视
4.4 补充
4.4.1 环视的价值
4.4.2 环视与分组编号
4.4.3 环视的支持程度
4.4.4 环视的组合
4.4.5 断言和反向引用之间的关系
第5章 匹配模式
5.1 不区分大小写模式
5.1.1 模式的指定方式
5.2 单行模式
5.3 多行模式
5.4 注释模式
5.5 补充
5.5.1 更多的模式
5.5.2 修饰符的作用范围
5.5.3 失效修饰符
5.5.4 模式与反向引用
5.5.5 冲突策略
5.5.6 哪种方式更好
第6章 其他
6.1 转义
6.1.1 字符串转义与正则转义
6.1.2 元字符的转义
6.1.3 彻底消除元字符的特殊含义
6.1.4 字符组中的转义
6.2 正则表达式的处理形式
6.2.1 函数式处理
6.2.2 面向对象式处理
6.2.3 比较
6.2.4 线程安全性
6.3 表达式中的优先级
第二部 分
第7章 Unicode
7.1 关于编码
7.2 推荐使用Unicode编码
7.3 Unicode匹配规则
7.4 单词边界
7.5 码值
7.6 Unicode属性
7.6.1 Unicode Property
7.6.2 Unicode Block
7.6.3 Unicode Script
7.7 Unicode属性列表
7.7.1 Unicode Property
7.7.2 Unicode Block
7.7.3 Unicode Script
7.8 POSIX字符组
第8章 匹配原理
8.1 有穷自动机
8.2 正则表达式的匹配过程
8.3 回溯
8.4 NFA和DFA
第9章 常见问题的解决思路
9.1 关于元素的三种逻辑
9.1.1 必须出现
9.1.2 可能出现
9.1.3 不能出现
9.2 正则表达式的常见操作
9.2.1 提取
9.2.2 验证
9.2.3 替换
9.2.4 切分
9.3 正则表达式的优化建议
9.3.1 使用缓存
9.3.2 尽量准确地表达意图
9.3.3 避免重复匹配
9.3.4 独立出文本和锚点
9.4 别过分依赖正则表达式
9.4.1 彻底放弃字符串操作
9.4.2 思维定势
9.4.3 正则表达式可以匹配各种文本
第三部 分
第10章 .NET
10.1 预备知识
10.2 正则功能详解
10.2.1 列表
10.2.2 字符组
10.2.3 Unicode属性
10.2.4 字符组简记法
10.2.5 单词边界
10.2.6 行起始/结束位置
10.2.7 环视
10.2.8 匹配模式
10.2.9 捕获分组的引用
10.3 正则API简介
10.3.1 Regex
10.3.2 Match
10.4 常用操作示例
10.4.1 验证
10.4.2 提取
10.4.3 替换
10.4.4 切分
第11章 Java
11.1 预备知识
11.2 正则功能详解
11.2.1 列表
11.2.2 字符组
11.2.3 Unicode属性
11.2.4 字符组简记法
11.2.5 单词边界
11.2.6 行起始/结束位置
11.2.7 环视
11.2.8 匹配模式
11.2.9 纯文本模式
11.2.10 捕获分组的引用
11.3 正则API简介
11.3.1 Pattern
11.3.2 Matcher
11.3.3 String
11.4 常用操作示例
11.4.1 验证
11.4.2 提取
11.4.3 替换
11.4.4 切分
第12章 JavaScript
12.1 预备知识
12.2 正则功能详解
12.2.1 列表
12.2.2 字符组
12.2.3 字符组简记法
12.2.4 单词边界
12.2.5 行起始/结束位置
12.2.6 环视
12.2.7 匹配模式
12.2.8 捕获分组的引用
12.3 正则API简介
12.3.1 RegExp
12.3.2 String
12.4 常用操作示例
12.4.1 验证
12.4.2 提取
12.4.3 替换
12.4.4 切分
12.5 关于ActionScript
12.5.1 RegExp
12.5.2 匹配规则
12.5.3 匹配模式
12.5.4 正则API
第13章 PHP
13.1 预备知识
13.2 正则功能详解
13.2.1 列表
13.2.2 字符组
13.2.3 Unicode属性
13.2.4 字符组简记法
13.2.5 单词边界
13.2.6 行起始/结束位置
13.2.7 环视
13.2.8 匹配模式
13.2.9 纯文本模式
13.2.10 捕获分组的引用
13.3 正则API简介
13.3.1 PREG 常量说明
13.3.2 preg_quote
13.3.3 preg_ grep
13.3.4 preg_match
13.3.5 preg_match_all
13.3.6 preg_ last_ error
13.3.7 preg_replace
13.3.8 preg_ replace_ callback
13.3.9 preg_ filter
13.3.10 preg_ split
13.4 常见的正则操作举例
13.4.1 验证
13.4.2 提取
13.4.3 替换
13.4.4 切分
第14章 Python
14.1 预备知识
14.2 正则功能详解
14.2.1 列表
14.2.2 字符组
14.2.3 Unicode属性
14.2.4 字符组简记法
14.2.5 单词边界
14.2.6 行起始/结束位置
14.2.7 环视
14.2.8 匹配模式
14.2.9 捕获分组的引用
14.3 正则API简介
14.3.1 RegexObject
14.3.2 re.compile(regex[, flags])
14.3.3 re.search(pattern, string[, flags])
14.3.4 MatchObject
14.3.5 re.match(pattern, string[, flags])
14.3.6 re.findall(pattern, sting[, flags])
14.3.7 re.finditer(pattern, string[, flags])
14.3.8 re.split(pattern, string[, maxsplit=0, flags=0])
14.3.9 re.sub(pattern, repl, string[, count, flags])
14.4 常用操作示例
14.4.1 验证
14.4.2 提取
14.4.3 替换
14.4.4 切分
第15章 Ruby
15.1 预备知识
15.2 正则功能详解
15.2.1 列表
15.2.2 字符组
15.2.3 Unicode属性
15.2.4 字符组简记法
15.2.5 单词边界
15.2.6 行起始/结束位置
15.2.7 环视
15.2.8 匹配模式
15.2.9 捕获分组的引用
15.3 正则API简介
15.3.1 Regexp
15.3.2 Regexp.match(text)
15.3.3 Regexp.quote(text)和Regexp.escape(text)
15.3.4 String.index(Regexp)
15.3.5 String.scan(Regexp)
15.3.6 String.slice(Regexp)
15.3.7 String.split(Regexp)
15.3.8 String.sub(Regexp, Str)
15.3.9 String.gsub(Regexp, String)
15.4 常用操作示例
15.4.1 验证
15.4.2 提取
15.4.3 替换
15.4.4 切分
15.5 Ruby 1.9的新变化
第16章 Linux/UNIX
16.1 POSIX
16.1.1 POSIX规范
16.1.2 POSIX字符组
16.2 vi
16.2.1 字符组及简记法
16.2.2 量词
16.2.3 多选结构和捕获分组
16.2.4 环视
16.2.5 锚点和单词边界
16.2.6 替换操作的特殊字符
16.2.7 replacement中的特殊变量
16.2.8 补充
16.3 grep
16.3.1 基本用法
16.3.2 字符组
16.3.3 锚点和单词边界
16.3.4 量词
16.3.5 多选结构和捕获分组
16.3.6 options
16.3.7 egrep和fgrep
16.3.8 补充
16.4 awk
16.4.1 基本用法
16.4.2 字符组及简记法
16.4.3 锚点和单词边界
16.4.4 量词
16.4.5 多选结构
16.4.6 补充
16.5 sed
16.5.1 基本用法
16.5.2 字符组及简记法
16.5.3 锚点和单词边界
16.5.4 量词
16.5.5 多选结构和捕获分组
16.5.6 options
16.5.7 补充
16.6 总结
附录A 常用语言中正则特性一览
附录B 常用的正则表达式
附录C 常用的正则表达式工具及资源

.3.1 分组 33
3.2 多选结构 39
3.3 引用分组 44
3.3.1 反向引用 48
3.3.2 各种引用的记法 50
3.3.3 命名分组 53
3.4 非捕获分组 54
3.5 补充 55
3.5.1 转义 55
3.5.2 url rewrite 56
3.5.3 一个例子 58
第4章 断言 59
4.1 单词边界 59
4.2 行起始/结束位置 61
4.3 环视 68
4.4 补充 74
4.4.1 环视的价值 74
4.4.2 环视与分组编号 74
4.4.3 环视的支持程度 75
4.4.4 环视的组合 77
4.4.5 断言和反向引用之间的关系 79
第5章 匹配模式 81
5.1 不区分大小写模式 81
5.1.1 模式的指定方式 82
5.2 单行模式 84
5.3 多行模式 85
5.4 注释模式 87
5.5 补充 88
5.5.1 更多的模式 88
5.5.2 修饰符的作用范围 89
5.5.3 失效修饰符 90
5.5.4 模式与反向引用 90
5.5.5 冲突策略 91
5.5.6 哪种方式更好 92
第6章 其他 93
6.1 转义 93
6.1.1 字符串转义与正则转义 93
6.1.2 元字符的转义 97
6.1.3 彻底消除元字符的特殊含义 99
6.1.4 字符组中的转义 101
6.2 正则表达式的处理形式 101
6.2.1 函数式处理 102
6.2.2 面向对象式处理 102
6.2.3 比较 103
6.2.4 线程安全性 104
6.3 表达式中的优先级 106
第二部分
第7章 unicode 110
7.1 关于编码 110
7.2 推荐使用unicode编码 111
7.3 unicode匹配规则 115
7.4 单词边界 117
7.5 码值 119
7.6 unicode属性 121
7.6.1 unicode property 121
7.6.2 unicode block 122
7.6.3 unicode script 123
7.7 unicode属性列表 123
7.7.1 unicode property 123
7.7.2 unicode block 125
7.7.3 unicode script 128
7.8 posix字符组 129
第8章 匹配原理 130
8.1 有穷自动机 130
8.2 正则表达式的匹配过程 131
8.3 回溯 134
8.4 nfa和dfa 136
第9章 常见问题的解决思路 138
9.1 关于元素的三种逻辑 138
9.1.1 必须出现 139
9.1.2 可能出现 139
9.1.3 不能出现 140
9.2 正则表达式的常见操作 142
9.2.1 提取 142
9.2.2 验证 148
9.2.3 替换 152
9.2.4 切分 157
9.3 正则表达式的优化建议 159
9.3.1 使用缓存 159
9.3.2 尽量准确地表达意图 160
9.3.3 避免重复匹配 160
9.3.4 独立出文本和锚点 161
9.4 别过分依赖正则表达式 162
9.4.1 彻底放弃字符串操作 162
9.4.2 思维定势 163
9.4.3 正则表达式可以匹配各种文本 164

目录

《正则指引》
第一部分
第1章 字符组 2
1.1 普通字符组 2
1.2 关于python的基础知识 4
1.3 普通字符组(续) 6
1.4 元字符与转义 8
1.5 排除型字符组 10
1.6 字符组简记法 12
1.7 字符组运算 14
1.8 posix字符组 15
第2章 量词 17
2.1 一般形式 17
2.2 常用量词 18
2.3 数据提取 21
2.4 点号 23
2.5 滥用点号的问题 23
2.6 忽略优先量词 26
2.7 转义 31
第3章 括号 33

.3.1 分组 33
3.2 多选结构 39
3.3 引用分组 44
3.3.1 反向引用 48
3.3.2 各种引用的记法 50
3.3.3 命名分组 53
3.4 非捕获分组 54
3.5 补充 55
3.5.1 转义 55
3.5.2 url rewrite 56
3.5.3 一个例子 58
第4章 断言 59
4.1 单词边界 59
4.2 行起始/结束位置 61
4.3 环视 68
4.4 补充 74
4.4.1 环视的价值 74
4.4.2 环视与分组编号 74
4.4.3 环视的支持程度 75
4.4.4 环视的组合 77
4.4.5 断言和反向引用之间的关系 79
第5章 匹配模式 81
5.1 不区分大小写模式 81
5.1.1 模式的指定方式 82
5.2 单行模式 84
5.3 多行模式 85
5.4 注释模式 87
5.5 补充 88
5.5.1 更多的模式 88
5.5.2 修饰符的作用范围 89
5.5.3 失效修饰符 90
5.5.4 模式与反向引用 90
5.5.5 冲突策略 91
5.5.6 哪种方式更好 92
第6章 其他 93
6.1 转义 93
6.1.1 字符串转义与正则转义 93
6.1.2 元字符的转义 97
6.1.3 彻底消除元字符的特殊含义 99
6.1.4 字符组中的转义 101
6.2 正则表达式的处理形式 101
6.2.1 函数式处理 102
6.2.2 面向对象式处理 102
6.2.3 比较 103
6.2.4 线程安全性 104
6.3 表达式中的优先级 106
第二部分
第7章 unicode 110
7.1 关于编码 110
7.2 推荐使用unicode编码 111
7.3 unicode匹配规则 115
7.4 单词边界 117
7.5 码值 119
7.6 unicode属性 121
7.6.1 unicode property 121
7.6.2 unicode block 122
7.6.3 unicode script 123
7.7 unicode属性列表 123
7.7.1 unicode property 123
7.7.2 unicode block 125
7.7.3 unicode script 128
7.8 posix字符组 129
第8章 匹配原理 130
8.1 有穷自动机 130
8.2 正则表达式的匹配过程 131
8.3 回溯 134
8.4 nfa和dfa 136
第9章 常见问题的解决思路 138
9.1 关于元素的三种逻辑 138
9.1.1 必须出现 139
9.1.2 可能出现 139
9.1.3 不能出现 140
9.2 正则表达式的常见操作 142
9.2.1 提取 142
9.2.2 验证 148
9.2.3 替换 152
9.2.4 切分 157
9.3 正则表达式的优化建议 159
9.3.1 使用缓存 159
9.3.2 尽量准确地表达意图 160
9.3.3 避免重复匹配 160
9.3.4 独立出文本和锚点 161
9.4 别过分依赖正则表达式 162
9.4.1 彻底放弃字符串操作 162
9.4.2 思维定势 163
9.4.3 正则表达式可以匹配各种文本 164

第 三 部 分
第10章 .net 168
10.1 预备知识 168
10.2 正则功能详解 169
10.2.1 列表 169
10.2.2 字符组 170
10.2.3 unicode属性 170
10.2.4 字符组简记法 171
10.2.5 单词边界 171
10.2.6 行起始/结束位置 172
10.2.7 环视 173
10.2.8 匹配模式 173
10.2.9 捕获分组的引用 174
10.3 正则api简介 175
10.3.1 regex 175
10.3.2 match 179
10.4 常用操作示例 180
10.4.1 验证 180
10.4.2 提取 180
10.4.3 替换 181
10.4.4 切分 182
第11章 java 183
11.1 预备知识 183
11.2 正则功能详解 184
11.2.1 列表 184
11.2.2 字符组 184
11.2.3 unicode属性 186
11.2.4 字符组简记法 186
11.2.5 单词边界 186
11.2.6 行起始/结束位置 187
11.2.7 环视 188
11.2.8 匹配模式 188
11.2.9 纯文本模式 189
11.2.10 捕获分组的引用 189
11.3 正则api简介 189
11.3.1 pattern 190
11.3.2 matcher 192
11.3.3 string 194
11.4 常用操作示例 195
11.4.1 验证 195
11.4.2 提取 196
11.4.3 替换 196
11.4.4 切分 197
第12章 javascript 198
12.1 预备知识 198
12.2 正则功能详解 199
12.2.1 列表 199
12.2.2 字符组 199
12.2.3 字符组简记法 200
12.2.4 单词边界 200
12.2.5 行起始/结束位置 201
12.2.6 环视 201
12.2.7 匹配模式 202
12.2.8 捕获分组的引用 203
12.3 正则api简介 203
12.3.1 regexp 203
12.3.2 string 207
12.4 常用操作示例 210
12.4.1 验证 210
12.4.2 提取 210
12.4.3 替换 211
12.4.4 切分 211
12.5 关于actionscript 211
12.5.1 regexp 211
12.5.2 匹配规则 212
12.5.3 匹配模式 212
12.5.4 正则api 212
第13章 php 213
13.1 预备知识 213
13.2 正则功能详解 215
13.2.1 列表 215
13.2.2 字符组 216
13.2.3 unicode属性 217
13.2.4 字符组简记法 217
13.2.5 单词边界 217
13.2.6 行起始/结束位置 218
13.2.7 环视 219
13.2.8 匹配模式 219
13.2.9 纯文本模式 220
13.2.10 捕获分组的引用 220
13.3 正则api简介 221
13.3.1 preg 常量说明 221
13.3.2 preg_quote 222
13.3.3 preg_ grep 223
13.3.4 preg_match 223
13.3.5 preg_match_all 225
13.3.6 preg_ last_ error 227
13.3.7 preg_replace 227
13.3.8 preg_ replace_ callback 227
13.3.9 preg_ filter 228
13.3.10 preg_ split 229
13.4 常见的正则操作举例 230
13.4.1 验证 230
13.4.2 提取 230
13.4.3 替换 231
13.4.4 切分 232
第14章 python 233
14.1 预备知识 233
14.2 正则功能详解 234
14.2.1 列表 234
14.2.2 字符组 235
14.2.3 unicode属性 236
14.2.4 字符组简记法 236
14.2.5 单词边界 238
14.2.6 行起始/结束位置 239
14.2.7 环视 239
14.2.8 匹配模式 240
14.2.9 捕获分组的引用 240
14.3 正则api简介 241
14.3.1 regexobject 241
14.3.2 re.compile(regex[, flags]) 243
14.3.3 re.search(pattern, string[, flags]) 243
14.3.4 matchobject 243
14.3.5 re.match(pattern, string[, flags]) 244
14.3.6 re.findall(pattern, sting[, flags]) 245
14.3.7 re.finditer(pattern, string[, flags]) 245
14.3.8 re.split(pattern, string[, maxsplit=0, flags=0]) 246
14.3.9 re.sub(pattern, repl, string[, count, flags]) 247
14.4 常用操作示例 248
14.4.1 验证 248
14.4.2 提取 248
14.4.3 替换 249
14.4.4 切分 250
第15章 ruby 251
15.1 预备知识 251
15.2 正则功能详解 252
15.2.1 列表 252
15.2.2 字符组 252
15.2.3 unicode属性 253
15.2.4 字符组简记法 254
15.2.5 单词边界 254
15.2.6 行起始/结束位置 255
15.2.7 环视 256
15.2.8 匹配模式 256
15.2.9 捕获分组的引用 257
15.3 正则api简介 257
15.3.1 regexp 257
15.3.2 regexp.match(text) 259
15.3.3 regexp.quote(text)和regexp.escape(text) 260
15.3.4 string.index(regexp) 261
15.3.5 string.scan(regexp) 261
15.3.6 string.slice(regexp) 262
15.3.7 string.split(regexp) 262
15.3.8 string.sub(regexp, str) 263
15.3.9 string.gsub(regexp, string) 264
15.4 常用操作示例 264
15.4.1 验证 264
15.4.2 提取 265
15.4.3 替换 265
15.4.4 切分 265
15.5 ruby 1.9的新变化 266
第16章 linux/unix 268
16.1 posix 268
16.1.1 posix规范 268
16.1.2 posix字符组 269
16.2 vi 271
16.2.1 字符组及简记法 271
16.2.2 量词 272
16.2.3 多选结构和捕获分组 272
16.2.4 环视 273
16.2.5 锚点和单词边界 273
16.2.6 替换操作的特殊字符 274
16.2.7 replacement中的特殊变量 276
16.2.8 补充 276
16.3 grep 277
16.3.1 基本用法 277
16.3.2 字符组 277
16.3.3 锚点和单词边界 278
16.3.4 量词 278
16.3.5 多选结构和捕获分组 279
16.3.6 options 279
16.3.7 egrep和fgrep 280
16.3.8 补充 280
16.4 awk 281
16.4.1 基本用法 281
16.4.2 字符组及简记法 282
16.4.3 锚点和单词边界 283
16.4.4 量词 283
16.4.5 多选结构 284
16.4.6 补充 284
16.5 sed 284
16.5.1 基本用法 284
16.5.2 字符组及简记法 285
16.5.3 锚点和单词边界 285
16.5.4 量词 286
16.5.5 多选结构和捕获分组 286
16.5.6 options 286
16.5.7 补充 287
16.6 总结 288
附录a 常用语言中正则特性一览 291
附录b 常用的正则表达式 293
附录c 常用的正则表达式工具及资源 309

正则表达式有很多流派,也有很多的特性,不同的语言支持度也是不一样的。本篇文章是写Python中的正则表达式的用法的,介绍了一些可用特性,也指出了某些特性是不支持的。

需要学习的朋友可以通过网盘下载:

《正则指引》
基本信息
作者: 余晟 [作译者介绍]
出版社:电子工业出版社
ISBN:9787121165511
上架时间:2012-5-2
出版日期:2012 年5月
开本:16开
页码:315
版次:1-1
所属分类: 计算机 > 软件与程序设计 > 综合 > 综合

 

命名分组

鉴于数字编号不够直观,并且括号多了难免混淆,所以就有了命名分组的出现。Python中用(?P<name>...)来分组,其中name是分组的名称。

反向引用必须使用(?P=name)来引用;替换则需要写作g<name>;匹配结果中则使用group(name)

更多详情 》》》《正则指引》
内容简介
计算机书籍
   《正则指引》针对作者在开发中遇到的实际问题,以及其他开发人员咨询的问题,总结出一套使用正则表达式解题的办法,并通过具体的例子指导读者拆解、分析 问题。全书分为三大部分:第一部分主要讲解正则表达式的基础知识,涵盖了常见正则表达式中的各种功能和结构;第二部分主要讲解关于正则表达式的更深入的知 识,详细探讨了编码问题、匹配原理、解题思路;第三部分将之前介绍的各种知识落实到6种常用语言.net、java、javascript、php、 python、ruby中,不但详细介绍了语言中正则表达式的用法,更点明了版本之间的细微差异,既可以作为专门学习的教材,也可以作为有用的参考手册。
  《正则指引》适合经常需要进行文本处理(比如日志分析或网络运维)的技术人员、熟悉常用开发语言的程序员,以及已经对正则表达式有一定了解的读者阅读。
目录
《正则指引》
第一部分
第1章 字符组 2
1.1 普通字符组 2
1.2 关于python的基础知识 4
1.3 普通字符组(续) 6
1.4 元字符与转义 8
1.5 排除型字符组 10
1.6 字符组简记法 12
1.7 字符组运算 14
1.8 posix字符组 15
第2章 量词 17
2.1 一般形式 17
2.2 常用量词 18
2.3 数据提取 21
2.4 点号 23
2.5 滥用点号的问题 23
2.6 忽略优先量词 26
2.7 转义 31
第3章 括号 33

 

单行模式

修饰符是s (Single line)。

这种模式下所有的文本只在一行里,换行符只是其中一个普通字符。单行模式影响的是点号.的匹配规则。

前言

  提到正则表达式,许多人很有点不屑一顾:这东西,不登大雅之堂,再说也不是总要用到,何必专门花时间学习?
  没错,正则表达式并不“总要用到”,但到了需要的场合用不上,往往产生“一分钱难倒英雄汉”的尴尬。经常需要处理文本的程序员自然会知道正则表达式的价值,其他的程序员如果不会正则表达式,即便开发的领域与文本处理没什么关系,也难免“躺着中枪”的命运——前几天我遇到一个问题,将一行长长的地址拆分成多行,负责这部分的程序员的日常工作只是制作PDF而已,拆分地址是很“边缘”的功能,但不会正则表达式就无法准确折行(一般需要在标点符号出现的地方折行,而不能只在空白字符处折行,但是不同语言中的标点符号各有不同),结果一筹莫展;相反,计算机书籍如果了解正则表达式,就可以很容易地处理各种语言中的标点字符。
  以我的开发经验来看,专门花点时间掌握正则表达式,确实是非常有必要的。目前可以见到的关于正则表达式的书籍和资料有不少,但又各有不足。
  在互联网上,流传着一些编程语言的正则文档和《30分钟教会你正则表达式》之类的帖子。这类资料的好处是简单直接,查到了,如果有现成的例子,而且适用于自己的语言,则可以直接拿来用;然而,其坏处也是简单直接,因为缺乏背后原理的讲解,如果找不到现成的例子,或者找不到能在自己所使用语言中行得通的例子(需知道,同样的正则表达式并不能直接套用到不同的语言中),则束手无策。
  在正式的出版领域,已经有《精通正则表达式》、《正则表达式必知必会》之类的书籍出版,尤其是前者,堪称关于正则表达式的经典著作,如果想认真学习正则表达式,这类书籍是必须阅读的。但这类书籍也有一个弱点,即都是由英文版本翻译而来的,更多地侧重英文文本的处理,身为中文世界的开发人员,我们经常需要处理中文文本——对于处理英文之外的字符,正则表达式已经提供了足够丰富的功能,但如何用对、用好这些功能,资料却很匮乏。
  我经常需要给人讲解正则表达式的相关知识,时常惋惜的是,开发人员为这些问题所困扰;正因为如此,本书的写作动机便是着力弥补现有资料的缺陷。
  相对于正则文档和速成教学帖子,本书深入讲解了匹配背后的原理,往往会举一反三,告诉读者,这里为何这样写,如果改成其他形式,会造成什么结构;并且,集中讲解和比较了多种语言中正则表达式用法的异同,方便读者把现成的正则表达式“移植”到自己的工作环境中。

本书来源:互动出版网  http://www.china-pub.com/

9159.com 1

编辑推荐

  一部答疑释惑的正则表达式指引之书
  常用文本处理以及语言开发的技术开发人员必读!

 

 

 

 

本篇文章仅为学习笔记,不对正则表达式做深入研究,只想用最短的时间入门正则。

基本信息

  • 作者: 余晟 
  • 出版社:电子工业出版社
  • ISBN:9787121165511
  • 上架时间:2012-4-16
  • 出版日期:2012 年5月
  • 页码:336
  • 定价 :¥58.00
  • 普通会员 : ¥43.50(75折)
  • 1-3星会员: ¥42.34(73折)
  • 4-5星会员: ¥40.60(70折)
  • 校园优惠价 :¥42.34(73折)

9159.com 2

 

 

 

原子分组

另一种非捕获分组就是原子分组(?>...)。这种分组可以将回溯操作关闭,但它只针对原子分组内的部分,而不针对整个正则表达式。经过测试发现这个表达式?>是不识别的。但是一篇文章(英文原版)给出了一个等价方案:

可以通过使用零宽度先行assert((?= RE))来模拟它,它从当前点匹配相同的语义想要,将一个命名的组((?P RE))放在lookahead中,然后使用一个命名的反引用((?P = name)恰恰是零宽度断言匹配.组合在一起,这给了你相同的语义,代价是创建一个额外的匹配组和很多语法.

正则指引

环视

环视是对匹配字符周围字符的验证,他匹配的并不是字符,而是位置。

环视大致分为以下四种:

名称 又称 说明
肯定顺序环视 正前瞻 ...(?=...)
否定顺序环视 反前瞻 ...(?!...)
肯定逆序环视 正后顾 (?<=...)...
否定逆序环视 反后顾 (?<!...)...

肯定环视和否定环视的区别就是:肯定环视要想判断成功,字符串中必须有字符由环视结构中的表达式匹配;而否定环视要判断成功却有两种情况1.字符串的字符不能匹配2.根本就没有字符,这个位置可能是起始或结束位置。

环视的组合:

  1. 包含

    环视中包含环视,这个和环视的并列还不太一样,这个外层环视是限定的位置,但是这个内层环视是限定外层环视的。(?=...(?!...))

  2. 多环视并列

    环视的并列要求每一个环视对当前位置的匹配都必须成功,而各个环视之间是没有任何联系的,他们都将作用于该位置。

  3. 环视作为多选分支

    将若干个环视作为多选分支排列在多选结构中,只要有一个环视分支成立,整个多选就成立。

分组的编号只与捕获型括号相关,而不受其他任何括号类型的影响,所以环视结构的括号并不影响分组。但是环视结构中出现了捕获型括号,则会影响分组。

环视结构中的捕获型括号一旦匹配完成,就不能回溯。e.g.(?<=(d+))w+1无法在123a12中找到匹配。

Python支持顺序环视,但对于逆序环视,Python只支持匹配固定长度文本表达式。(?<=dogs?)(?<=(dog|cats))都是不合法的,遇到这样的可与选择多选结构来改造,但是如果出现*和+之类的量词,就不能用多选了。

至此,整个正则表达式部分就介绍完毕,以下部分Python正则API。


Python中的正则表达式模块是re模块,通过import re 导入re模块来使用正则表达式。

在正则表达式中,大多数的函数是类似re.search(pattern,string)的形式,其中pattern通常是正则表达式的字符串,这可以视为“静态方法”。其实也可以将RegexObject对象作为pattern参数传入,或者直接对RegexObject对象调用相同名字的成员方法,结果相同,但是后面这两个方法可以显示的缓存RegexObject对象。

除了正则表达式对象RegexObject,还有一个MatchObject对象,MatchObject对象提供了一些方法和属性,通过他们可以获取匹配的信息。

方法 描述 注释
start(n) 返回编号为n的捕获分组匹配的开始位置,如果对应分组不存在或者未匹配,则返回-1 如果没有设定n,则返回整个表达式匹配的开始位置,此时n等于0
pos 返回整个表达式匹配的开始位置
end(n) 返回编号为n的捕获分组匹配的结束位置,如果对应分组不存在或未匹配,则返回-1 如果没有设定n,则返回整个表达式匹配的结束位置,此时n等价于0
endpos 返回整个表达式匹配的结束位置 等价于end(0)
group(n) 返回编号为n的捕获分组匹配的文本 如果没有设定n,则返回整个表达式匹配的文本,此时n等价于0
groups() 返回各捕获分组匹配的文本构成的tuple 如果表达式中不存在捕获分组,则返回空tuple
span(n) 返回编号为n的捕获分组匹配的开始-结束位置 如果没有设定n,则返回整个表达式匹配的开始-结束位置,此时n等价于0
re 返回匹配时所使用的正则表达式对象
lastindex 返回匹配成功的编号最大的捕获分组的编号 如果没有,则返回None
string 返回用来尝试用正则表达式来匹配的字符串
expand(str) 返回一个字符串,可以在其中引用捕获分组匹配的文本
  • re.compile(regex [, flags])

    这个方法用于显示“编译”正则表达式对象。如果需要多次使用同一个正则表达式,那么每次使用编译好的正则表达式对象比每次临时编译表达式对象要快得多。另外compile()还有一个功能,那就是添加第二个参数re.DEBUG来观察整个正则表达式的详细信息。

  • re.search(pattern, string [, flags])

    这个方法用来测试正则表达式pattern能否在string中找到匹配,flags是可选参数是匹配模式(aiLmsux)的按位OR结果。如果能找到匹配,则返回MatchObject,否则返回None。

  • re.match(pattern, string [, flags])

    re.match()和re.search()非常相似,参数相同,返回值也行通,非常容易混淆,唯一的区别在于:如果re.match()匹配成功,那么pattern匹配的字符串必须开始于string的最左端。也就是说,re.match()只会在字符串的开始的位置尝试匹配,re.search()则没有这个限制。MULTILINE 多行模式下,match也只匹配string的开头部分。

  • re.findall(pattern, string [, flags])

    这个函数会一次性的找出正则表达式pattern在string中的所有匹配,返回一个list。

    如果pattern中存在捕获分组,则返回list的元素并非整个表达式所匹配的文本,而是各个捕获分组所匹配文本构成的tuple。返回的tuple中是没有默认的分组编号0所匹配的文本元素的,如果需要返回可以在整个正则表达式外再加一个括号。tuple中文本的顺序就是分组编号的顺序。

  • re.finditer(pattern, string [, flags])

    如果文本内容很多,使用re.findall()一次性找到所有匹配的成本可能很高,使用re.finditer()可以返回一个迭代器(iterator),他可以按照从左到右的顺序逐个遍历每次匹配的MatchObject对象,依次进行处理或检验。

  • re.split(pattern, string [, maxsplit=0, flags=0])

    这个函数用正则表达式pattern能够匹配的文本切分字符串string。如果正则表达式在开头或者结尾位置找到匹配,那么结果的开头或结尾会出现空字符串。也可以明确设定maxsplit。在Python中这个参数表示切分的次数。也就是说,返回数组一般会包含maxsplit+1个元素。如果maxsplit设定负数,则表示不做任何切分;若设定0,则等于没有设定;若设定的值为正数,且小于实际可切分的次数,则按设定的值进行切分,若大于实际可切分的次数,则以实际可切分的次数为准。

  • re.sub(patern ,repl, string [, count=0, flags=0])

    这个函数用来进行正则表达式替换,它将字符串string中的正则表达式pattern能够匹配的文本替换为repl指定的文本。如果要在replacement字符串中引用之前的某个捕获分组匹配的文本,则应该使用num。Python中也提供了跟清晰的方式在repl中引用分组,写作g<num>,这种记法也可以使用命名分组g<name>。repl也可以是一个函数,他接受一个MatchObject对象,返回一个String对象。也可以设定count参数,他指定替换操作最多能发生的次数。

  • re.subn(patern ,repl, string [, count=0, flags=0])

    与sub()相同,但返回一个元祖,其中包含新字符串和替换次数。

  • re.escape(string)

    返回一个字符串,其中所有的非字母数字字符都带有反斜杠。

不区分大小写模式

不区分大小写模式的修饰符是i (case Insensitive),则(?i)it可以匹配的有it It iT IT

注释模式

修饰符是x (eXtended mode 扩展模式)。

有时正则表达式可能非常复杂,不但难于编写和阅读,也难以维护。python中支持使用(?#comment)的记法添加注释;还有一种是使用注释模式,此时正则表达式对应的字符串可以跨越多行,注释则以#comment的形式添加在正则表达式内部,每一条注释从#开始,到行末结束,同时还可以使用缩进表示层级结构更加方便阅读和维护。

单词边界

单词边界记为b,他匹配的是“单词边界”位置,而不是字符。也就是说b能够匹配这样的位置:一边是单词字符,另一边不是单词字符(包括没有字符)。不同的模式下w不同,所以b也就不同。

另外还有B非单词边界。

分组 ( )

分组,顾名思义就是将某些东西分成一组,对外来看是一个整体。通过()将表达式括起来,此时表达式就是一个整体一个可整体操作的元素。括号内的表达式称之为“子表达式”。

匹配模式

所谓匹配模式,指的是匹配时使用的规则。设定特定的模式,可能会改变对正则表达式的识别,也可能会改变正则表达式中字符的匹配规定。常用的匹配模式一共有4种:不区分大小写模式单行模式多行模式注释模式。通常有两种指定方式:以模式修饰符指定(?modifier),或者以预定义的常量作为特殊参数传入来指定。

Python中模式修饰符只要出现,无论在什么位置,都对整个正则表达式生效。Python中不支持失效修饰符(?-modifier)

多行模式

修饰符是m (Multiline)。

多行模式影响的是^$的匹配规则。

非捕获分组

无论是否需要分组,只要出现了括号,正则表达式再匹配的时候就会把括号内的子表达式存储起来,提供引用。如果并不需要引用,保存这些信息无疑会影响正则表达式的性能。

正则表达式提供了非捕获分组(?:...),这样的括号叫做非捕获型括号,他只能限定量词的作用范围,不捕获任何文本。在引用分组时,分组的编号同样会按照开括号出现的顺序从左到右计数,非捕获分组会略过。

断言

常见的断言有三类:单词边界行起始/结束位置环视。断言并不真正的匹配文本,他匹配的是位置,他只负责判断在某个位置左/右侧的文本是否符合要求。

Manarola

字符组 [ ]

在同一位置可能出现的各种字符,也可以称之为字符集。

写法有很多种。有原始写法,然后是范围表示法,然后是排除型字符组,然后是字符组简记法,最后还有一个字符组运算(Python不支持)。

[3645970128]  -->  [0123456789]  -->  [0-9]  -->  d
[0-9A-Za-z_]  -->  [dA-Za-z_]  -->  w
"-"用来表示范围 范围的确定依靠码值来确定,一般据ASCⅡ表值。

排除型字符组由脱字符"^"来指定,"^"排在第一位,紧靠在"["之后,需要排除的按上面写法写在"^"之后。
[^0-9]    # 排除数字,也可以写成[^d]
如果需要排除"-",则必须将"-"写在开头"^"之后,如果一定要写在后面,则必须用""转义。
字符组简记 说明
d 数字(digit) [0-9]
w 单词(word) [0-9A-Za-z_] 字母数字下划线
s 空白(space) [ trnfv] 空格、制表符、回车、换行等显示空白字符

D 、W 、S是与之对应的排除型字符组简记。

以上说的d 、w 、s的匹配规则都是针对ASCⅡ编码规则而言的,也叫ASCⅡ匹配规则。在Unicode编码中,全角数字0、1、2之类的也算数字,也可以由d匹配;中文字符也可以算是单词字符,由w匹配;同样全角空格也由s匹配。

Python3默认采用Unicode匹配规则,但也可以显示指定采用ASCⅡ匹配规则(表达式最开始用(?a)指定ASCⅡ模式)。

另外还有一个POSIX字符组(POSIX Character Class)。POSIX(Portable Operating System Interface for uniX),它是含有正则表达式规范的一系列规范。这种字符组只在java、php、ruby中支持,经过测试以及查阅资料并没有显示Python是支持的,不过也有可能是POSIX字符组需要变化一下才能使用,就像其他语言那样。

多选结构

多选结构的形式是(···|···),在括号中以竖线|分隔开多个子表达式,这些子表达式也叫多选分支;在一个多选结构中,多选分支的数目没有限制。在匹配时,整个多选结构被视为单个元素,只要某个子表达式能够匹配,整个多选结构的匹配就成功。

一般而言ab|cd依旧是多选结构,等价于(ab|cd),建议使用后者,更加明确,也能够避免一些错误。例如^ab|cd$其实是(^ab|cd$)而不是^(ab|cd)$,因为竖线|的优先级很低。

多选结构的匹配顺序问题。比如表达式(aaa|aaabbb)去匹配aaabbb,匹配结果到底是aaa还是aaabbb呢?Python中多选结构都会优先选择最左侧的分支,所以匹配出来是aaa。不过在实际使用中请避免这种情况,分支中存在重复会大大增加回溯的计算量。

引用分组

分组之后,正则表达式会保存每一个分组真正匹配的文本(不是正则表达式可匹配的文本),匹配完成后,可通过编号进行引用当时捕获的内容。

如果出现多个嵌套括号,那编号的计数规则是怎样的呢?首先整个正则表达式默认存在一个的编号为0的分组,其他分组的编号是依据从左到右开括号出现的顺序决定的,第几个括号就是第几组。

  1. 反向引用

    在正则表达式内部引用之前的捕获分组匹配的文本,之前捕获分组中锚点表示的位置信息不会被保留下来。

    引用形式:num,其中num表示所引用分组的编号。

  2. sub替换中引用

    re.sub(pattern,replacement,string),在replacement中使用引用分组。引用形式同样是:num

  3. 匹配结果中group引用

    对匹配完成后,可对匹配结果对象调用group(num)获取分组中匹配的数据。

num引用的二义性问题:10是第10个引用还是第1个引用后再加一个0呢?

Python中将其解释为第10个引用,可通过g<num>,消除二义性。

注:反向引用只引用之前的捕获分组匹配的文本,之前捕获分组中的锚点表示的位置信息不会被保留下来。

量词

以上说的都是匹配单个字符,如果多了怎么办。所以就出现了量词。

量词限定之前的元素的出现,这个元素可能是一个字符,也可能是一个字符组,还可以是一个表达式。

一般形式量词 说明
{n} 之前的元素必须出现n次
{m,n} 之前的元素最少出现m次,最多出现n次
{m,} 之前的元素最少出现m次,最高没有限制
{0,n} 之前的元素可以不出现,也可以出现,最多出现n次
常用量词 等价形式 说明
* {0,} 可能出现,也可能不出现,出现次数没有上限
+ {1,} 至少出现1次,最多没有限制
? {0,1} 可以不出现,也可以就出现1次

所有的量词默认都是贪婪量词,能匹配的,绝不停止匹配。它会优先尝试匹配,并记下这个状态,以便将来反悔。这个返回的过程称之为回溯。

量词也可以变成懒惰的,称之为懒惰量词,能不匹配就不匹配,如果之后的表达式匹配失败,则会回溯进行匹配。变成懒惰量词是在现有量词后加上?

还有一种量词称之为占有量词。它和贪婪量词很像,但是占有量词不会进行回溯,优点是速度快,但是失败也会很快。变成占有量词是在现有量词后加上+

本文由9159.com发布于前端,转载请注明出处:也指出了某些特性是不支持的,电子工业出版社

关键词:

上一篇:没有了
下一篇:没有了