正则常用用法总结(python风格)

2018-08-24

python正则剖析

基础知识

常用部分剖析

^ 匹配字符串的开头
$ 匹配字符串的末尾
. 匹配任意字符，除了换行符，当flag=re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。如:

s = '''aaa4a1234

5a2a22adsasd

zxc3
'''
print re.findall(r'^.*(\d+)$', s, flags=re.DOTALL)  
# 输出最后一行的['3']，说明该正则匹配过了整条字符串(包括换行)

#不加正则匹配选项(如re.S, re.DOTALL等)则默认是会被认为是多行， 

# 看了如下三个例子，会更深刻的理解一行和多行，^和$的关系
print re.findall(r'^.*(\d+).*$', s)  
# 输出[], 从^到$之间有多行，而^到$又只能是一行，所以匹配为空

print re.findall(r'^.*(\d+)', s)  
# 输出最后一行的['4']， 只能匹配到第一行(因为^表示第一行开头决定了只有第一行满足条件)

print re.findall(r'.*(\d+)', s)  
# 输出['4', '2', '3']， 因为有三行

[…] 用来表示一组字符,单独列出：[amk] 匹配 ‘a’，’m’或’k’

s = 'Abcde'
print re.findall(r'[ac]', s, flags=re.I)
#输出结果: ['A', 'c']    re.I代表不区分大小写

# 多看几个列子，做下对比来理解
number = 'abc123-4657890def'
print re.findall(r'[2-9]', number)  #-在中间表示范围2到9，包含2和9
print re.findall(r'[2\-9]', number) # -被转义，只表示符号-
print re.findall(r'[-09]', number) # -放前面，也只表示符合-， 相当于被转义
"""
输出结果
['2', '3', '4', '6', '5', '7', '8', '9']
['2', '-', '9']
['-', '9', '0']
"""

[^…] 不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符

1
2
3

s = 'Abcde'
print re.findall(r'[^ac]', s, flags=re.I)
#输出结果: ['b', 'd', 'e']    re.I代表不区分大小写

exp* 匹配0个或多个的表达式

s = 'A4d'
print re.findall(r'(\d*)', s)
#输出结果: ['', '4', '', ''], 
"""
因为*匹配0个或多个满足条件的表达式，我的理解对应关系如下:
A----''  # \d* 表示匹配 出现0个或多个数字，而A不是数字，所有这里匹配不到，用''填充
4----4
d----''
结束符---''
"""

exp+ 匹配1个或多个的表达式

1
2
3

s = 'A43d'
print re.findall(r'(\d+)', s)
# 输出 ['43']， \d+表示数字连续出现次数为1到正无穷的规则

exp? 匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式

例1:

1
2
3

s = 'A43d'
print re.findall(r'(4?\d+)', s)
# 输出 ['43']

例2:

s = 'A3d'
print re.findall(r'(4?\d+)', s)
# 输出 ['3'] 

# 总结: 说明4是可有可无的

exp{n} 精确匹配n个前面表达式
exp{n, } 匹配n到正无穷个exp表达式
exp{ n, m} 匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式

s = 'A4321d5'
print re.findall(r'(\d{2,3})', s)
# 输出 ['432']， \d{2,3} 表示匹配连续出现2-3次的数字，
# 4321中，多余出现的次数1，被剔除， 数字5只连续出现了一次，不满足条件

{n,m}? 启用非贪婪模式，即只匹配n次
a|b 匹配a或b，

1
2
3

s = 'A4321d5'
print re.findall(r'(21|3)', s)
#输出 ['3', '21']

常用或操作理解

# 或操作的常用方法，及再次对分组和小括号不表示分组的理解

demo_str = 'abcgraysgreyxz'
print re.findall(r'gr(a|e)(?#aasd)y', demo_str)
print re.findall(r'gr(?:a|e)(?#aasd)y', demo_str)
print re.findall(r'gr[ae]y', demo_str)
print re.findall(r'gray|grey', demo_str)
"""
输出：
['a', 'e']， 剖析: 因为 ()表示分组，表示从源字符串中截取一个子串
['gray', 'grey'] 剖析：(?:exp)不表示分组，这里的exp仅仅是a或e
['gray', 'grey'] 剖析： [exp]的简单用法
['gray', 'grey'] 剖析： |的简单用法
"""

(exp) 匹配exp,并捕获文本到自动命名的组里，主要是用于，从一个源字符串中，匹配出子串

s = 'A4321d5'
print re.findall(r'(21|3)', s)
# 输出 ['3', '21']

# 也可以不加
s = 'A4321d5'
print re.findall(r'21|3', s)
# 输出 ['3', '21']

分组的含义：
s = 'A4321d5 asd321'
print re.findall(r'(\d+).+?(\1)', s)
# 输出 [('321', '321')]  
# \1代表匹配条件是：字符串s中，\1的值必须和第1个()中的字符串值相等， 
# 1可以替换成其它数字，范围从1-99

分组指定别名及反向引用用法

例1
s = '1abc15abc5'
print re.findall(r'(\d+)abc\1', s)
print re.findall(r'(?P<id>\d+)abc(?P=id)', s)

输出
['1', '5']
['1', '5'] 
剖析：以上两行代码，功能是一样的，只是(?P<name>)的方式可以给分组指定易于理解的别名



例2
inputStr = "hello crifan, nihao crifan"
print re.sub(r"hello (\w+), nihao \1", "\g<1>", inputStr)
print re.sub(r"hello (?P<name>\w+), nihao (?P=name)", "\g<name>", inputStr)

# 输出 
crifan
crifan

(?:exp) 匹配exp,不捕获匹配的文本，也不给此分组分配组号

例1: 
s = 'A4321d5 asd321'
print re.findall(r'(?:\d+).+?(\1)', s)
#这样会报错， 因为(?:exp)不会给分组分配组号

例2
#要得出正确的答案，需要如下
s = 'A4321d5 asd321'
print re.findall(r'((?:\d+)).+?(\1)', s)
#输出: [('321', '321')]

(?#…) 注释.

1
2
3

s = 'A4321d5 asd321'
print re.findall(r'((?:\d+)).+?(\1)(?#注释)', s)
# 输出: [('321', '321')]

\w 匹配字母数字及下划线

s = 'A4321d5&as-d3_21'
print re.findall(r'(\w+)', s)
# 输出 ['A4321d5', 'as', 'd3_21']
# &和-符合都没有匹配到，所有匹配出了3个结果

不常用部分符合含义

\W 匹配非字母数字及下划线
\s 匹配任意空白字符，等价于 [\t\n\r\f].
\S 匹配任意非空字符
\d 匹配任意数字，等价于 [0-9]
\D 匹配任意非数字
\A 匹配字符串开始
\Z 匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串
\z 匹配字符串结束
\G 匹配最后匹配完成的位置
\b 匹配一个单词边界，也就是指单词和空格间的位置。例如， ‘er\b’ 可以匹配”never” 中的 ‘er’，但不能匹配 “verb” 中的 ‘er’
\B 匹配非单词边界。’er\B’ 能匹配 “verb” 中的 ‘er’，但不能匹配 “never” 中的 ‘er’。
\n, \t, 等. 匹配一个换行符。匹配一个制表符。等
常用匹配模式剖析
re.I 使匹配对大小写不敏感

1 2	s = 'Http://www.baidu.com' print re.findall(r'(httP)', s, flags=re.I) # 输出['Http']

re.M 多行匹配，影响 ^ 和 $

s = '''aaa4a1234a
123asdb
5a2a22adsasd

zxc3
'''
例1
print re.findall(r'^(\d+).+?$', s)
# 输出 [] 因为这里的字符串s，只有一个开头^(在第一行行首)
#和一个结尾$(在最后一行行尾)

例2
print re.findall(r'^(\d+).+?$', s, flags=re.M) 
# 输出 ['123', '5']， re.M影响到了^和$，导致每一行行首都有^，
#每一行行尾都有$，所以匹配除了第二行和第三行的开头数字

re.S 使 . 匹配包括换行在内的所有字符, 多行匹配(最为常用的一种模式)

s = '''aaa4a1234a

5a2a22adsasd

zxc3
'''
# 做个对比
例1
print re.findall(r'^.*(\d+)$', s) 
# 输出 [] ，

例2
print re.findall(r'^.*(\d+)$', s, flags=re.S) 
# 输出 ['3']，re.S 使.匹配了换行符，所以找到了字符串最后一个3

贪婪和懒惰的区别

懒惰和贪婪的区别，贪婪可以理解成在匹配一个字符串的时候，心很大，想尽可能多的往后匹配满足条件的字符串，而懒惰可以理解成，在从一个字符串中匹配一截字符串的时候，匹配到第一个满足条件的子串，就保留下结果，继续往后寻找其它满足条件的子串, 一般有?的都表示懒惰。

# 举例说明：
demo_str = 'I am Shirley Hilton. I am his wifeasd'
print re.findall(r'i.*e', demo_str)  #贪婪模式  
#输出 ['irley Hilton. I am his wife']， 
# 表示匹配第一个i开始，尽可能多的往后匹配e，直到找到最后一个满足条件的e

print re.findall(r'i.*?e', demo_str)  #懒惰模式 
# 输出 ['irle', 'ilton. I am his wife']，
# 从左到右匹配到i，然后往右扫描，发现有e结尾满足条件的子字符串，就将结果加入到结果集列表 

# 下面也是贪婪模式的一些规则
demo_str = 'asd123456fgh'
print re.findall(r'\d{1,}', demo_str)  #贪婪模式，输出 ['123456']
print re.findall(r'\d+', demo_str)  #贪婪模式，输出 ['123456']

两条懒惰模式语句剖析

1 2	print re.findall(r'\d.*?', demo_str) #懒惰模式，输出 ['1', '2', '3', '4', '5', '6'] print re.findall(r'\d.+?', demo_str) #懒惰模式，输出 ['12', '34', '56']

从以上输出结果，可以引申出 .+?和.*?的区别

.? 因为在这里表示前面的字符.重复0到n次，但是这里有？表示懒惰匹配，所以n的值要尽可能的小，所以以上例子输出结果为[‘12’, ‘34’, ‘56’]
.+? 因为+在这里表示前面的字符.重复1到n次，但是这里有？表示懒惰匹配，所以n的值要尽可能的小，这里n取1，所以以上例子输出结果为[‘12’, ‘34’, ‘56’]
常用python API
pattern

s = 'abc def ghi'
p = re.compile(r'(\w+) (\w+)(?P<sign>.*)', re.DOTALL)

print "p.pattern:", p.pattern 
print "p.flags:", p.flags
print "p.groups:", p.groups
print "p.groupindex:", p.groupindex
print p.findall(s)  # pattern的用法

输出结果如下：
p.pattern: (\w+) (\w+)(?P<sign> # 输出编译时的正则表达式字符串
p.flags: 16  # 匹配模式re.DOTALL， 经验证re.DOTALL == re.S == 16
p.groups: 3  # 分组个数
p.groupindex: {'sign': 3} # 以表达式中有别名的组的别名为键、以该组对应的编号为值的字典
[('abc', 'def', ' ghi')] # 返回查找结果

match，这个方法将从string的pos下标处起尝试匹配pattern；如果pattern结束时仍可匹配，则返回一个Match对象；如果匹配过程中pattern无法匹配，或者匹配未结束就已到达endpos，则返回None，多用于验证

line = "dogs Cats are smarter than dogs";
matchObj = re.match(r'dogs', line)
if matchObj:
    print "match --> matchObj.group() : ", matchObj.group()
else:
    print "No match!!"
# 输出： matchObj.group():  dogs
# 将line替换成 line = "Cats are smarter than dogs"; 返回No match!!
# 表明match是从字符串开头位置匹配，且从开头到pattern的末尾，字符串都必须得匹配，才返回匹配对象

search，用于在字符串中搜索子串，搜索到第一个就停止搜索，返回匹配的子串

line = "Cats are smarter than dogs";
obj = re.search('dogs', line)
if obj:
    print obj.group() # 输出 dogs

split，按照能够匹配的子串将string分割后返回列表

1
2
3

s = 'one1two2three3four4'
print re.split(r'\d+', s)
# 输出： ['one', 'two', 'three', 'four', '']

findall，查找源字符串中所有满足条件的子串

1
2
3

s = 'one1two2three3four4'
print re.findall(r'\d+', s)
# 返回 ['1', '2', '3', '4'] ，是最常用的一个api之一

sub，替换

使用repl替换string中每一个匹配的子串后返回替换后的字符串。

当repl是一个字符串时，可以使用\id或\g、\g引用分组，但不能使用编号0。

当repl是一个方法时，这个方法应当只接受一个参数（Match对象），并返回一个字符串用于替换（返回的字符串中不能再引用分组）。

count用于指定最多替换次数，不指定时全部替换。

# repl 为字符串
p = re.compile(r'(\w+) (\w+)')
s = 'i say, hello world!'

print p.sub(r'\2 \1', s)

def func(m):
    return m.group(1).title() + ' ' + m.group(2).title()

print p.sub(func, s)

# 输出 
say i, world hello!
I Say, Hello World!


# sub repl参数为函数:

def pythonReSubDemo():
    """
        demo Pyton re.sub
    """
    inputStr = "hello 123 world 456";

    def _add111(matched):
        intStr = matched.group("number");  # 123
        intValue = int(intStr);
        addedValue = intValue + 111;  # 234
        addedValueStr = str(addedValue);
        return addedValueStr;

    replacedStr = re.sub("(?P<number>\d+)", _add111, inputStr);
    print "replacedStr=", replacedStr;  # hello 234 world 567

pythonReSubDemo()  # 输出 replacedStr= hello 234 world 567

subn，返回 (sub(repl, string[, count]), 替换次数)。

p = re.compile(r'(\w+) (\w+)')
s = 'i say, hello world!'
print p.subn(r'\2 \1', s)

def func(m):
    return m.group(1).title() + ' ' + m.group(2).title()

print p.subn(func, s)

#返回 
('say i, world hello!', 2)
('I Say, Hello World!', 2)

零宽断言

断言用来声明一个应该为真的事实。正则表达式中只有当断言为真时才会继续进行匹配，只是匹配位置，并不消费字符

(?=exp) 匹配exp前面的位置

1
2
3

s = "I'm singing while you're dancing."
print re.findall(r'\b\w+(?=ing\b)', s)
# 输出：  ['sing', 'danc']

(?<=exp) 匹配exp后面的位置

s = "I'm reading a book."
print re.findall(r'(?<=\bre)\w+\b', s) # 匹配三位数字，而且这三位数字的后面不能是数字
# 输出 ['ading']

s = 'abcd 1234 abc 1 def 567c'
print re.findall(r'(?<=\s)\d+(?=\s)', s) # 匹配以空白符间隔的数字单词
# 输出  ['1234', '1']

(?!exp) 匹配后面跟的不是exp的字符串

s = 'abcd1234def567c'
print re.findall(r'\d{3}(?!\d)', s)
# 输出：['234', '567']

s = 'abcd 1234abc1 def 567c'
print re.findall(r'\b((?!abc)\w+)\b', s) #匹配不包含连续字符串abc的单词
# 输出 ['1234abc1', 'def', '567c']

#\b\w*q(?!u)\w*\b， 可以解决\b\w*q[^u]\w*\b中，q在末尾的情况，如
s = 'wqud wq' 
print re.findall(r'\b\w*q(?!u)\w*\b', s)
print re.findall(r'\b\w*q[^u]\w*\b', s)
# 输出
['wq']
[]

(?<!exp) 断言此位置的前面不能匹配表达式exp

1
2
3

s = 'a1234b567'
print re.findall(r'(?<![a-z])\d{3}', s) # 匹配前面不是小写字母的3位数字
# 输出 ['234']