Python 正则表达式学习摘要及资料

来源：Michael_翔_

摘要

• 在正则表达式中，如果直接给出字符，就是精确匹配。

• {m,n}? 对于前一个字符重复 m 到 n 次，并且取尽可能少的情况 在字符串'aaaaaa'中，a{2,4} 会匹配 4 个 a，但 a{2,4}? 只匹配 2 个 a。

^表示行的开头，^\d表示必须以数字开头。

$表示行的结束，\d$表示必须以数字结束。

你可能注意到了，py也可以匹配'python'–>py;

但是加上^py$就变成了整行匹配，就只能匹配’py’了,匹配'python'时，就什么也得不到。

参考表

正则表达式特殊序列

^  匹配开始
$  匹配行尾
， 匹配出换行符以外的任何单个字符，使用-m选项允许其匹配换行符也是如此
[...] 匹配括号内任何当个字符（也有或的意思）
[^...] 匹配单个字符或多个字符不在括号内
*  匹配0个或多个匹配前面的表达式
+  匹配1个或多个前面出现的表达式
？ 匹配0次或1次前面出现的表达式
{n} 精确匹配前面出现的表达式的数量
{n,m} 匹配至少n次到m次
a | b 匹配a或b
*？，+？，??,{m,n}? 这样在*，+，？，{m,n} 变成非贪婪模式
(re) 组正则表达式并及时匹配的文本
（？imx） 暂时切换上i,m或x震泽表达式的选项，如果括号中，仅该地区受到影响
(?: re) 组正则表达式而匹配的记住文字
(?#....) 注释
(?=re) 指定使用的模式位置，没有一个范围
(?!re) 使用指定模式取反位置，没有一个范围
(?<n1>..) 用列表的方式匹配  

\d  数字[0-9] digit
\D  非数字 == [^0-9] or [^\d]
\s  空白字符
\S  非空白字符
\w  字母数字下划线 word
\W   非字母数字下划线

re模块

re.compile(pattern[, flags])

把正则表达式的模式和标识转化成正则表达式对象，供 match() 和 search() 这两个函数使用。

re 所定义的 flag 包括：

re.I 忽略大小写

re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境

re.M 多行模式

re.S 即为’ . ’并且包括换行符在内的任意字符（’ . ’不包括换行符）

re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库

re.X 为了增加可读性，忽略空格和’ # ’后面的注释

以下两种用法结果相同：

(A)

compiled_pattern = re.compile(pattern)

result = compiled_pattern.match(string)

(B)

result = re.match(pattern, string)

s = 'ABC\\-001' # Python的字符串

#对应的正则表达式字符串变成：

#'ABC\-001'

因此我们强烈建议使用Python的r前缀，就不用考虑转义的问题了

s = r'ABC\-001' # Python的字符串

# 对应的正则表达式字符串不变：

# 'ABC\-001'

search

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

在字符串中查找匹配正则表达式模式的位置，返回 MatchObject 的实例，如果没有找到匹配的位置，则返回 None。

对于已编译的正则表达式对象来说（re.RegexObject），有以下 search 的方法：

search (string[, pos[, endpos]])

若 regex 是已编译好的正则表达式对象，regex.search(string, 0, 50) 等同于 regex.search(string[:50], 0)。

>>> pattern = re.compile("a")

>>> pattern.search("abcde") # Match at index 0

>>> pattern.search("abcde", 1) # No match;

match

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

判断 pattern 是否在字符串开头位置匹配。对于 RegexObject，有：

match(string[, pos[, endpos]])

match() 函数只在字符串的开始位置尝试匹配正则表达式，也就是只报告从位置 0 开始的匹配情况，而 search() 函数是扫描整个字符串来查找匹配。如果想要搜索整个字符串来寻找匹配，应当用 search()。

>>> pattern.match('bca',2).group()

'a'

虽然，match默认是从开头匹配，但是，如果指定位置，仍然能成功；但是！match也是从指定位置开始匹配，不匹配仍然会失败，这一点就和search有区别啦。

match()方法判断是否匹配，如果匹配成功，返回一个Match对象，否则返回None。

test = '用户输入的字符串'

if re.match(r'正则表达式', test):

print('ok')

else:

print('failed')

split

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

此功能很常用，可以将将字符串匹配正则表达式的部分割开并返回一个列表。对 RegexObject，有函数：

split(string[, maxsplit=0])

对于一个找不到匹配的字符串而言，split 不会对其作出分割

>>> 'a b   c'.split(' ')

['a', 'b', '', '', 'c']

这里用字符串自带的split方法就很不灵活。

>>> re.split(r'\s+', 'a b   c')

['a', 'b', 'c']

看出差别了吧，很强大！

再来一个终极的：

>>> re.split(r'[\s\,\;]+', 'a,b;; c  d')

['a', 'b', 'c', 'd']

r'[\s\,\;]+'的正则表达式意思为：空格或者,或者;出现1次或1次以上都是满足条件的分割符号！所以，最后结果还是很干净。

findall

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

在字符串中找到正则表达式所匹配的所有子串，并组成一个列表返回。同样 RegexObject 有：

findall(string[, pos[, endpos]])

#get all content enclosed with [], and return a list

>>> pattern=re.compile(r'hh')

>>> pattern.findall('hhmichaelhh')

['hh', 'hh']

finditer

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

和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并组成一个迭代器返回。同样 RegexObject 有：

finditer(string[, pos[, endpos]])

sub

re.sub(pattern, repl, string[, count, flags])

在字符串 string 中找到匹配正则表达式pattern 的所有子串，用另一个字符串 repl 进行替换。如果没有找到匹配 pattern 的串，则返回未被修改的 string。Repl 既可以是字符串也可以是一个函数。

返回值是替换后的新字符串。

对于 RegexObject 有：

sub(repl, string[, count=0])

>>> pattern=re.compile(r'\d')

>>> pattern.sub('no','12hh34hh')

'nonohhnonohh'

>>> pattern.sub('no','12hh34hh',0)

'nonohhnonohh'

>>> pattern.sub('no','12hh34hh',count=0)

'nonohhnonohh'

>>> pattern.sub('no','12hh34hh',1)

'no2hh34hh'

通过上面的例子，可以看出,count是可以缺省的，同时，默认值是0，表示全部替换；否则，就是指定替换几个。

subn

re.subn(pattern, repl, string[, count, flags])

该函数的功能和 sub() 相同，但它还返回新的字符串以及替换的次数。同样 RegexObject 有：

subn(repl, string[, count=0])

>>> pattern.subn('no','12hh34hh',count=0)

('nonohhnonohh', 4)

分组

除了简单地判断是否匹配之外，正则表达式还有提取子串的强大功能。用()表示的就是要提取的分组（Group）。比如：

^(\d{3})-(\d{3,8})$分别定义了两个组，可以直接从匹配的字符串中提取出区号和本地号码：

>>> m = re.match(r'^(\d{3})-(\d{3,8})$', '010-12345')

>>> m

<_sre.SRE_Match object; span=(0, 9), match='010-12345'>

>>> m.group(0)

'010-12345'

>>> m.group(1)

'010'

>>> m.group(2)

'12345'

>>> m.groups()

('010', '12345')

通过实验，如果不用括号，得到的Match对象课可以使用例如a.group(0)或者a.group()但是，使用a.group(1)就会报错的。

贪婪匹配

正则匹配默认是贪婪匹配，也就是匹配尽可能多的字符。举例如下，匹配出数字后面的0：

>>> re.match(r'^(\d+)(0*)$', '102300').groups()

('102300', '')

由于\d+采用贪婪匹配，直接把后面的0全部匹配了，结果0*只能匹配空字符串了。

必须让\d+采用非贪婪匹配（也就是尽可能少匹配），才能把后面的0匹配出来，加个?就可以让d+采用非贪婪匹配：

>>> re.match(r'^(\d+?)(0*)$', '102300').groups()

('1023', '00')

Python正则表达式学习资源