python-正则表达式regex_python 字符串正则regexp

参考博客：
https://www.cnblogs.com/gengyi/p/8922653.html
https://www.cnblogs.com/jinbuqi/p/11136864.html

1. 概述

1.1 定义

本质是由一系列字符和特殊符号组成的字串，用来表示一定规则的某一类字符串。

1.2 特点

正则表达式是一个独立的技术，其在多种编程语言中使用。

在python语言中的正则表达式模块为 re 模块

1.3 正则表达式函数

re模块提供了一组函数，用于搜索匹配的字符串:

1.4 元字符

元字符是具有特殊意义的字符:

1.5 特殊转义字符

特殊转义字符是 \ 后面跟着下面列表中的某个字符，有特殊的含义:

1.6 集合

2 正则表达式

2.1 元字符

首先引入re模块，python中自带re

xinhuatedu:~$ python3
In [1]: import re
1
2

单个字符

匹配规则：匹配相应的字符
例如 a 匹配 a ab 匹配 ab

In [2]: re.findall('ab','abc')
Out[2]: ['ab']
1
2

匹配单个字符

元字符： .

匹配规则：匹配除 ‘\n’ 外的任意一个字符

In [4]: re.findall('a.b','acbadbab')
Out[4]: ['acb', 'adb']
1
2

匹配字符串的开头位置

元字符 ： ^

匹配规则 ： ^ 位置必须为字符串的开始位置才可，通常和其他元字符同用

In [6]: re.findall('^ab','abb')
Out[6]: ['ab']
1
2

匹配字符串的结尾位置

元字符： $

匹配规则 ： 匹配字符串的结尾位置

In [8]: re.findall('ab$','aab')
Out[8]: ['ab']
1
2

匹配重复

方式 1 ：
元字符 ： *

匹配规则 ：匹配前面出现的正则表达式0次或多次
ab* -> a (b出现0次)，ab (b出现1次) …

In [10]: re.findall('ab*','aabbabbb')
Out[10]: ['a', 'abb', 'abbb']
1
2

方式 2 ：
元字符 ： +

匹配规则 ： 匹配前面出现的正则表达式1次或多次

In [11]: re.findall('ab+','aabbabbb')
Out[11]: ['abb', 'abbb']
1
2

方式 3 ：
元字符 ： ？
匹配规则： 匹配前面出现的正则表达式0次或1次

In [13]: re.findall('ab?','aababb')
Out[13]: ['a', 'ab', 'ab']
1
2

方式 4：

元字符 ： {n}

匹配规则： 匹配指定重复的次数

In [14]: re.findall('ab{2}','aababbabbb')
Out[14]: ['abb', 'abb']
1
2

方式 4：
元字符 ： {m,n}
匹配规则 ： 匹配重复m次到n次

In [16]: re.findall('ab{1,2}','aababbabbbabbbb')
Out[16]: ['ab', 'abb', 'abb', 'abb']

In [17]: re.findall('ab{1,3}','aababbabbbabbbb')
Out[17]: ['ab', 'abb', 'abbb', 'abbb']

In [18]: re.findall('ab{2,3}','aababbabbbabbbb')
Out[18]: ['abb', 'abbb', 'abbb']
1
2
3
4
5
6
7
8

字符集匹配

元字符 ： [‘abc…’]
匹配规则 ： 匹配字符集中任意一个字符

In [19]: re.findall('[abcd]','Today is February 26th, the gem index fell 2.10%')
Out[19]: ['d', 'a', 'b', 'a', 'd']
1
2

匹配字符区间

元字符 ： [0-9] [a-z] [A-Z]

匹配规则 ： 匹配区间内任意一个字符，不同区间可以写在一起，同时还能添加其他的字符集（一般将其写在字符区间前面）

In [23]: re.findall('[a-z]+','Today is February 26th, the gem index fell 2.10%')
Out[23]: ['oday', 'is', 'ebruary', 'th', 'the', 'gem', 'index', 'fell']

In [24]: re.findall('[_0-3a-z]+','Today is February 26th, the gem_index fell 2.10%')
Out[24]: ['oday', 'is', 'ebruary', '2', 'th', 'the', 'gem_index', 'fell', '2', '10']
1
2
3
4
5

不添加加号+ 的话，会输出在范围内的单个字母。
集合取反

元字符：[ ^ …]
匹配规则 ：匹配任意一个不再集合中的字符

In [26]: re.findall(’[^a-z]+’,‘Today is February 26th, the gem index fell 2.10%’)
Out[26]: [‘T’, ’ ‘, ’ F’, ’ 26’, ', ', ’ ', ’ ', ’ ‘, ’ 2.10%’]

（非）数字字符

元字符（匹配规则）：\d（任意一个数字字符）；\D（任意一个非数字字符）

In [27]: re.findall('\d+','a0123456789b')
Out[27]: ['0123456789']

In [28]: re.findall('\D+','a0123456789b')
Out[28]: ['a', 'b']
1
2
3
4
5

（非）数字字母下划线

元字符（匹配规则）：
\w（任意一个数字字母下划线，等价于[_0-9a-zA-Z]）
\W（任意一个特殊字符，等价于非[^_0-9a-zA-Z]）

In [29]: re.findall('\w+','1_!_2_@_3_#_4_$')
Out[29]: ['1_', '_2_', '_3_', '_4_']

In [30]: re.findall('\W+','1_!_2_@_3_#_4_$')
Out[30]: ['!', '@', '#', '$']
1
2
3
4
5

（非）空字符

元字符（匹配规则）：
\s（任意空字符，等价于[ \n \r \t \0 ]）
\S（任意非空字符）

In [33]: re.findall('\S+','Today is February 26th, the gem index fell 2.10%')
Out[33]: ['Today', 'is', 'February', '26th,', 'the', 'gem', 'index', 'fell', '2.10%']

In [34]: re.findall('\s+','Today is February 26th, the gem index fell 2.10%')
Out[34]: [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ']
1
2
3
4
5

开头 / 结尾位置

元字符（匹配规则）：
\A（匹配字符串的开头位置，等价于 ^ ）
\Z（匹配字符串的结尾位置，等价于 $ ）

In [35]: re.findall('\Aab\Z','aabb')
Out[35]: []

In [36]: re.findall('\Aab\Z','ab')
Out[36]: ['ab']
1
2
3
4
5

（非）边界位置

元字符（匹配规则）：
\b（匹配单词边界位置）
\B（匹配非单词边界位置）

单词边界(注) ： 数字字母下划线和其他字符交界的位置认为是单词边界

In [5]: re.findall(r'ab\b','ab aab')
Out[5]: ['ab', 'ab']

In [6]: re.findall(r'ab\b','ab abb')
Out[6]: ['ab']

另

In [18]: re.findall(r'ab\B','aab aabb')
Out[18]: ['ab']

In [19]: re.findall(r'ab\B','abb aabb')
Out[19]: ['ab', 'ab']
1
2
3
4
5
6
7
8
9
10
11
12
13

或关系

元字符 ： |

匹配规则 : 连接多个正则表达式 形成或关系

In [22]: re.findall('abc|bcd','abcde bcdef')
Out[22]: ['abc', 'bcd']
1
2

总结：

1 匹配单个字符：普通字符串 . \d \D \w \W \s \S [ … ] [ ^… ]

2 匹配位置：^ $ \A \Z \b \B

3 匹配重复次数：* + ？ { n } { m , n }

4 其他：|

2.2 转义字符

1 正则表达式中有很多特殊字符为元字符 （如* $ ? + \d \s），如果在设定匹配时需要匹配到特殊字符则用转义

2 当使用某个编程语言时，正则表达式往往要以字符串的形式传入，而编程语言的字符串又有转义性质

2.3 贪婪和非贪婪

贪婪模式：当重复次数不确定时，正则表达式总是尽可能多的向后匹配

常见的贪婪模式的元字符有：* + ? { m , n }

非贪婪模式：再具有重复的元字符后加？

示例：

In [23]: re.findall('ab*','abbba')
Out[23]: ['abbb', 'a']

In [24]: re.findall('ab*?','abbba')
Out[24]: ['a', 'a']

In [25]: re.findall('ab?','abbba')
Out[25]: ['ab', 'a']

In [26]: re.findall('ab??','abbba')
Out[26]: ['a', 'a']

In [27]: re.findall('ab+','abbba')
Out[27]: ['abbb']

In [28]: re.findall('ab+?','abbba')
Out[28]: ['ab']
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2.4 子组

正则表达式子组：在整段正则表达式中用（）截取一部分作为正则表达式的一个子组。

一个正则表达式中原则上可有多个子组，但子组间不能出现交叉

一般而言，从外到内，从左到右，依次称为第一子组、第二子组。。。

In [29]: re.findall('a(bc)','abbcabc')
Out[29]: ['bc']
1
2

子组的作用：

（1）子组作为一个整体，可改变重复元字符的作用范围

（2）很多编程语言函数可单独提取子组的内容

（3）在使用和调用上更加方便

子组的命名和调用：

子组的命名：（？Pabcd）

子组的调用：（？P=name）

（?Pab）cdef(?P=dog)

2.5 模块 re

re模块中的方法及属性

 compile(pattern, flags=0)  
1

功能：生成正则表达式对象

参数：pattern：正则表达式；flags：扩展标志位（默认为0，表示不进行任何扩展）

返回值：正则表达式对象

obj = re.compile(‘abc’)

以下函数既能在re模块中直接调用，也可用compile对象直接调用

对比如下图所示：

 re.findall(pattern, string, flags=0) 
1

功能：根据正则表达式匹配目标字符串

参数：

pattern：正则表达式

string：目标字符串

flags：正则扩展标志位

返回值：匹配到的所有内容以列表返回，若有分组则只返回子组能匹配到的内容

 obj.findall(string=None, pos=0, endpos=2^63-1) 
1

功能：根据正则表达式匹配目标字符串

参数：

string：目标字符串

pos：匹配目标字符串的起始位置

endpos：匹配目标字符串的结束位置，默认值为2^63-1

返回值：匹配到的所有内容以列表返回，如果有分组则只返回子组能匹配到的内容

 finditer() 
1

功能：同findall

参数：同findall

返回值：返回一个迭代对象，迭代获取的每个值为match obj

 match 对象：finditer   match   fullmatch   search
1

这些函数将正则匹配到的结果以match对象的形式给出，方便进行具体操作

fullmatch()
1

功能：用正则表达式完全匹配某个字符串

参数：目标字符串

返回值：返回匹配到的match对象，如果没有匹配到返回None

match()
1

功能：匹配字符串的开头

参数：目标字符串

返回值：若匹配到内容返回match object，否则返回None

search()
1

功能：匹配第一处符合正则的字串

参数：目标字串

返回值：如果匹配到内容则返回match object，否则返回None

split()
1

功能：按照正则表达式切割字符串

参数：目标字符串

返回值：将切割后的字符串放入列表

sub(re_str, string, max)
1

功能：用指定字符串替换正则表达式匹配到的部分

参数：

re_str：待替换的字符串

string：目标字符串

max：最多替换几处

返回值：替换后的字符串

subn(re_str, string, max)
1

功能：用指定字符串替换正则表达式匹配到的部分

参数：

re_str：待替换的字符串

string：目标字符串

max：最多替换几处

返回值：返回值为二元元组，第一项为替换后的字符串，第二项为实际替换几处

compile返回对象的属性

flags：正则表达式表示位（用整型表示）

pattern：正则表达式

groupindex：返回以捕获的名称为键，第几组为值的字典

groups：正在表达式中一共有多少个子组

match search fullmatch finditer

match对象属性和方法

属性：

pos：匹配目标字符串的开始位置

endpos：匹配目标字符串的结束位置

lastgroup：获取最后一个子组的名称，如果没名字则为None

lastindex：获取最后一个子组是第几组

re：match匹配所用的正则表达式

regs：正则表达式整体及每个子组所匹配的部分

string：match匹配的目标字符串

方法：

start()：得到匹配内容在字符串中的开始位置

end()：得到匹配内容在字符串中的结束位置（结束字符下标的下一个）

span()：得到匹配到的内容在字符串中的起止位置

group(n)：

功能：获取match对象匹配到的内容

参数：n(默认为0)表示整个正则匹配到的内容，当给n赋一个正整数时则表示要获取第n个子组匹配内容

返回值：返回匹配到的字符串

groups()：获取所有子组匹配到的内容

groupdict()：将捕获组的名称和匹配的内容形成键值对关系

re.compile re.findall re.match re.search……中的flags

‘A’,‘ASCII’,

‘S’,‘DOTALL’, 让 . 可以匹配换行

‘I’, ‘IGNORECASE’ 忽略大小写

‘L’,‘LOCALE’,

‘M’, ‘MULTILINE’ 作用于 ^ $ 使其能匹配每行的开头结尾

‘T’,‘TEMPLATE’,

‘U’,‘UNICODE’

‘X’,‘VERBOSE’, 让你的正则可以添加以#开头的注释

当多个flag同时使用时 中间用竖线分割
例如：re.I | re.S

回到顶部(go to top)

3 实例

3.1 简单示例

匹配长度为8-10位的密码，必须以字母开头，数字字母下划线组成

In [2]: re.findall(r'^[a-zA-Z]\w{7,9}$','abc123_a')
Out[2]: ['abc123_a']
1
2

匹配身份证号

In [6]: re.search(r'\d{17}(\d|x)','123123123123123123').group()
Out[6]: '123123123123123123'
1
2

匹配一段文字中以大写字母开头的单词

In [14]: re.findall(r'\b[A-Z]\w*\b',data)
Out[14]: ['Python', 'Hello', 'World']
1
2

3.2 综合应用

import re

obj = re.compile(r'hello',re.I|re.S)

print(obj.findall('hello world Hello Kitty'))
# ['hello', 'Hello']
print('*****')

s = '''hello world
nihao china
'''
print(re.search('.*',s,re.S).group())
# hello world
# nihao china
# (注,可以匹配换行)

print('*****')

print(re.search('world$',s,re.M).group())
# world

print('*****')

print(re.search(
    '''hello#注释１
    \s#注释２
    \w+#注释３
    ''',s,re.X).group())
# hello world
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

import re

re_obj = re.compile(r'(?P<dog>ab)c(de)')

match_obj = re_obj.search('abcdefg')

print(match_obj)
# <_sre.SRE_Match object; span=(0, 5), match='abcde'>

# print(dir(match_obj))
#属性
print(match_obj.pos) #0
print(match_obj.endpos) #7
print(match_obj.lastgroup) # None
print(match_obj.lastindex) #2
print(match_obj.re) #re.compile('(?P<dog>ab)c(de)')
print(match_obj.regs) #((0, 5), (0, 2), (3, 5))
print(match_obj.string) #abcdefg
print("************************")
#函数
print(match_obj.start()) #0
print(match_obj.end()) #5
print(match_obj.span()) #(0,5)
print(match_obj.group(0)) #abcde
print(match_obj.group(1)) #ab
print(match_obj.group(2)) #de
print(match_obj.groups()) #('ab', 'de')
print(match_obj.groupdict()) #{'dog': 'ab'}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import re

obj = re.compile(r'(?P<dog>ab)cd(ef)')

result = obj.findall('abcdeabcfg')
result = obj.finditer('abcdefgabch')
result = obj.fullmatch('abcdef#%')
result = obj.match('abcd')
result = obj.search('abcdefcdg')
result = obj.split('hello world  nihao china@Beijing')
result = obj.sub('##',\
    'hello world  nihao china@Beijing',3)
result = obj.subn('##',\
    'hello world  nihao china@Beijing',6)

if result != None:
    print(result)
else:
    print("match nothing")
# for i in result:
#     print(i.group())

print(obj.flags)
print(obj.pattern)
print(obj.groups)
print(obj.groupindex)
# print(obj.scanner('abcdef'))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27