正则表达式(regular expression)描述了一种字符串匹配的模式（pattern），可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。
在各大编程语言中都能发挥出很大的作用。每种语言也都有关于正则表达式模块的实现。
本文以Python举例说明。
Regular Expression
匹配单个字符
匹配纯文本
匹配纯文本其实我们一般不用正则表达式就可以，使用正则表达式只是能说明这个问题
#待匹配的文本
s = 'hello my name is ben'
print(re.findall('ben', s))
#待匹配的文本
s = 'hello my name is ben and my friend name is ben'
print('只返回第一个匹配结果为{}'.format(re.search('ben', s).span()))
print('返回所有匹配结果{}'.format(re.findall('ben', s)))
结果为:
['ben']
只返回第一个匹配结果为(17, 20)
返回所有匹配结果['ben', 'ben']
匹配任意字符
使用.匹配任意一个字符
.字符可以匹配任何单个的字符、字母、数字或者.本身
#待匹配的文本
s = 'sales1.txt' \
'sales2.txt' \
'salese.txt' \
'nae.txt' \
'sns.txt' \
'sn.txt'
print('使用sale.匹配的所有结果为{}'.format(re.findall(r'sales.', s)))
print('使用.a.匹配的所有结果为{}'.format(re.findall(r'.a.', s)))
print('使用\转义匹配含有.的结果{}'.format(re.findall(r'.a.\.', s)))
结果为:
使用sale.匹配的所有结果为['sales1', 'sales2', 'salese']
使用.a.匹配的所有结果为['sal', 'sal', 'sal', 'nae']
使用\转义匹配含有.的结果['nae.']
匹配一组字符
匹配多个字符中的某一个
使用[ab]确定可选的字符
使用[0-9]确定可选的字符范围
s = 'na.txt' \
'na2.txt' \
'sa1.txt' \
'ca1.txt' \
'nam.txt'
print('匹配na或sa.txt的结果为{}'.format(re.findall(r'[ns]a.\.txt', s)))
print('限制a后面字符仅为数字的结果为{}'.format(re.findall(r'[ns]a[0-9]\.txt',s)))
结果为:
匹配na或sa.txt的结果为['na2.txt', 'sa1.txt', 'nam.txt']
限制a后面字符仅为数字的结果为['na2.txt', 'sa1.txt']
- 注: 在同一个字符集合里页可以给出多个字符区间，会匹配到多个区间中的任何一个字符
取非匹配
我们使用正则表达式也不是都需要匹配集合其中的字符，有时也需要匹配非集合中的字符，在正则表达式中，我们可以使用^字符对集合进行取非操作
s = 'na.txt' \
'na2.txt' \
'sa1.txt' \
'ca1.txt' \
'nam.txt'
print('限制a后面字符不为数字的结果为{}'.format(re.findall(r'[ns]a[^0-9]\.txt', s)))
结果为:
限制a后面字符不为数字的结果为['nam.txt']
使用元字符
对特殊字符进行转义
使用\对元字符进行转义
s = 'list[0] list[1] list[2]'
print('使用\对中括号进行转义使其匹配{}'.format(re.findall(r'list\[[0-9]\]', s)))
path = '\home\\ben\sales'
print('将\替换成/为{}'.format(re.compile(r'\\').subn('/', path)))
结果为:
使用\对中括号进行转义使其匹配['list[0]', 'list[1]', 'list[2]']
将\替换成/为('/home/ben/sales', 3)
匹配特定的字符类别
空白元字符表
| 元字符 | 说明 |
|---|---|
| [\b] | 回退符 |
| \f | 换页符 |
| \n | 换行符 |
| \r | 回车符 |
| \t | 制表符 |
| \v | 垂直制表符 |
数字元字符
| 元字符 | 说明 |
|---|---|
| \d | 任何一个数字 (等价于[0-9]) |
| \D | 任何一个非数字(等价于[^0-9]) |
字母数字元字符
| 元字符 | 说明 |
|---|---|
| \w | 任何一个字母数字字符(大小写均可)或下划线字符 (等价于[a-zA-Z0-9_]) |
| \W | 任何一个非字母数字字符(等价于[^a-zA-Z0-9_]) |
空白字符元字符
| 元字符 | 说明 |
|---|---|
| \s | 任何一个空白字符 (等价于[\f\n\r\t\v]) |
| \S | 任何一个非空白字符(等价于[^\f\n\r\t\v]) |
重复匹配
匹配一个或多个字符
匹配同一个字符或(字符集合)的多次重复，只要在其后面加上一个+即可。
+匹配一个或多个字符(至少一个，不包含0个)
s = '1234545@qq.com fdfsd@163.com test.sddf@163.com.cn'
print('匹配邮箱{}'.format(re.findall(r'[\w.]+@[\w.]+\.\w+', s)))
结果为；
匹配邮箱['1234545@qq.com', 'fdfsd@163.com']
匹配零个或多个字符
* 和+类似，只是可以允许匹配0个或多个的情况
匹配零个或一个字符
？只能匹配一个字符(或字符集合)的零次或一次出现，最多不能超过一次。
匹配的重复次数
- 使用{}将数值写在其中来表示重复次数
s = '123abc 45abc'
print('匹配三个数字{}'.format(re.findall(r'\d{3}\w{3}', s)))
结果为:
匹配三个数字['123abc']
- 为重复匹配次数设定一个区间
使用{a,b}的形式来确定区间，a为最少重复次数，b为最多重复次数
s = '4/8/03 ' \
'10-6-2004 ' \
'2/2/2 ' \
'01-01-01 '
print('匹配所有格式的日期{}'.format(re.findall(r'\d{1,2}[-\/]\d{1,2}[-\/]\d{2,4}', s)))
结果为：
匹配所有格式的日期['4/8/03', '10-6-2004', '01-01-01']
匹配至少重复多少次
使用{a,}的形式的形式来确定最少重复的次数防止过度匹配
*和+都是贪婪形元字符，使用他们在进行匹配时，会进可能的匹配而不是适可而止。他们会从一段文本的开头一直匹配到文本的末尾。在这种情况可能导致原本我们需要匹配多个结果，最后变成了一个结果,例如:
<B>TEST</B>AND <B>TEST1</B>
会被正则表达式<[Bb]>.*</[Bb]>匹配为一个整体的结果
此时应该使用懒惰型版本
常用的贪婪性元字符和它们的懒惰型版本
| 贪婪型元字符 | 懒惰型元字符 |
|---|---|
| * | *? |
| + | +? |
| {n,} | {n,}? |
用懒惰型元字符时的正则表达式应是<[Bb]>.*?</[Bb]>
位置匹配
单词边界
使用\b限定单词边界，用来匹配一个单词的开始或结尾
使用\B限定一个前后都不是单词边界的单词
s = 'the cat scattered his food all over the room color - red'
print('匹配单词边界{}'.format(re.findall(r'\bcat\b', s)))
print('不匹配单词边界{}'.format(re.findall(r'\-\B', s)))
结果为:
匹配单词边界['cat']
不匹配单词边界['-']
字符串边界
^限定字符串开头，$限定字符串的结尾
使用子表达式
用()来将需要的子表达式划分出来，子表达式可以嵌套
用|表示或，例如19|20表示为(19|20)匹配19或20
s = 'hello the world'
print('匹配两个 的结果为{}'.format(re.findall(r'( ){2,}', s)))
s = 'ping 12.159.46.200'
p = re.compile(r'(\d{1,3}\.){3}\d{1,3}')
print('使用子表达式匹配ip地址为{}'.format(p.findall(s)))
s = '1997 2005'
print('{}'.format(re.findall(r'(19|20)\d{2}', s)))
结果为:
匹配两个 的结果为[' ']
使用子表达式匹配ip地址为['12.159.46.200']
['19', '20']
回溯引用，前后一致
使用\n代表模式里的第几个子表达式
s = 'this is and and or or not not'
print('{}'.format(re.findall(r'[ ]+(\w+)[ ]+\1', s)))
结果为:
['and', 'or', 'not']
注:
- 回溯引用只能用来引用模式里的子表达式(用()括起来的正则表达式片段)
- 回溯引用匹配通常用1开始技术(\1 \2等)。在许多实现里，第0个匹配(\0)可以用来代表整个正则表达式
前后查找
这种模式，包含的匹配本身并不返回，而是用于确定正确的匹配位置，它并不是匹配结果的一部分。
前后查找分为向前查找和向后查找，但常见的正则表达式实现都支持向前查找。所以只说明前者
向前查找
向前查找指定了一个必须匹配但不在结果中返回的模式。向前查找实际就是一个子表达式。
从语法上看，一个向前查找模式就是一个以?=开头的子表达式，需要匹配的文本跟在=的后面。
s = 'http://www.baidu.com \n' \
'https://www.baidu.com \n' \
'ftp://ftp.baidu.com \n'
print('向前查找url中的协议名为{}'.format(re.findall(r'.{3,6}(?=:)', s)))
结果:
向前查找url中的协议名为['http', 'https', 'ftp']
向后查找
与向前查找相类似，查找出现在被匹配文本之前的字符（但不消费它）,向后查找的操作符使?<=
嵌入条件
正则表达式里的条件要用?来定义
- ?匹配前一个字符或表达式，如果它存在的话
- ?= 和?<=匹配前面或后面的文本，如果它存在的话
- 根据一个回溯引用来进行条件处理
- 根据一个前后查找来进行条件处理
注：
- 上述环境在ubuntu16.04 lts Python3.5中测试成功
- 上述文字皆为个人看法，如有错误或建议请及时联系我
