python正则表达式

re.match函数（从头开始匹配）

尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。

函数语法

re.match(pattern,string,flags)

pattern

匹配的正则表达式。

string

要匹配的字符串。

flags

标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
例：

import re 
str = "The following has nothing to do with the riddle itself."
print(re.match('The',str).span())
print(re.match('nothing',str)

结果为：

(0, 3)
None

可以使用group(num)或group()匹配对象函数看来获取匹配表达式
例：

str = "The following has nothing to do with the riddle itself."
matchstr = re.match(r'(.*?) following has (.*?) to do with the (.*?) .*', str, re.M | re.I)
print(matchstr.group())
print(matchstr.group(1))
print(matchstr.group(3))

结果为：

The following has nothing to do with the riddle itself.
The
riddle

修饰符	描述
re.M	多行匹配，影响 ^ 和 $
re.I	使匹配对大小写不敏感
re.L	做本地化识别（locale-aware）匹配
re.U	根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
re.	该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解

re.search函数（匹配整个字符串）

扫描整个字符串并返回第一个成功的匹配。

函数语法

re.search(pattern,string,flags)

例：

import re
str = "The following has nothing to do with the riddle itself."
print(re.search('following',str).span())
print(re.search('The',str).span())
print(re.search('the',str).span())

结果为：

(4, 13)
(0, 3)
(37, 40)

re.match与re.search的区别

re.match匹配字符串的开始，如果字符串开始不符合则匹配失败；
re.search匹配整个字符串，直到找到一个匹配。

正则表达式模式

模式	描述
^	匹配字符串的开头
$	匹配字符串的末尾
.	匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符
[…]	用来表示一组字符,单独列出：[amk] 匹配 ‘a’，'m’或’k
[^…]	不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。
re*	匹配0个或多个的表达式。
re+	匹配1个或多个的表达式。
re?	匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式
re{ n}	匹配n个前面表达式。例如，"o{2}“不能匹配"Bob"中的"o”，但是能匹配"food"中的两个o
re{ n,}	精确匹配n个前面表达式。例如，"o{2,}“不能匹配"Bob"中的"o”，但能匹配"foooood"中的所有o。"o{1,}“等价于"o+”。"o{0,}“则等价于"o*”。
re{ n, m}	匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
a| b	匹配a或b
(re)	匹配括号内的表达式，也表示一个组
(?imx)	正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。
(?-imx)	正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域
(?:re)	类似 (…), 但是不表示一个组
(?imx:re)	在括号中使用i, m, 或 x 可选标志
(?-imx:re)	在括号中不使用i, m, 或 x 可选标志
(?#…)	注释
(?=re)	前向肯定界定符。如果所含正则表达式，以 … 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边
(?! re)	前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功。
(?>re)	匹配的独立模式，省去回溯。
\w	匹配数字字母下划线
\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,等	匹配一个换行符。匹配一个制表符, 等
\1…\9	匹配第n个分组的内容。
\10	匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。

检索和替换

re.sub用于替换字符串中的匹配项。

函数语法

re.sub(pattern.repl,string,count=0,flags=0)

pattern

正则中的模式字符串

repl

替换的字符串，也可以为一个函数

string

要被查找替换的原始字符串

count

模式匹配后替换的最大次数，默认0表示替换所有匹配

flags

编译时用的匹配模式，数字形式

前三个是必要参数，后两个为可选参数。
例：

import re
str = "+86 18323321321 #手机号码"

# 删除注释
num = re.sub(r'#.*$','',str)
print(num)
print('--' * 30)

# 删除非数字
num = re.sub(r'\D','',str)
print(num)

结果为：

+86 18323321321 
------------------------------------------------------------
8618323321321

repl参数可以一个函数，例：

import re
# 将匹配的数字乘于 2
def double(matched):
  value = int(matched.group('value'))
  return str(value * 2)

s = 'A23G4HFD567'
print(re.sub('(?P<value>\d+)', double, s))

结果为：A46G8HFD1134

re.compile

compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用
语法：

re.compile(pattern[, flags])

pattern

一个字符串形式的正则表达式

flags

可选项，表示匹配模式
例：

import re
str = 'o12sdadw21s'
pattern = re.compile(r'\d+')
m = pattern.match(str)
print(m)
print('--' * 20)
n = pattern.match(str, 2, 10) # 从第2位开始匹配
print(n)
print('--' * 20)

结果为：

None
----------------------------------------
(2, 3)
----------------------------------------

group()

group([group1, …]) 方法用于获得一个或多个分组匹配的字符串，当要获得整个匹配的子串时，可直接使用 group() 或 group(0)

start()

start([group])方法用于获取分组匹配的子串在整个字符串中的起始位置（子串第一个字符的索引），参数默认值为 0；

end()

end([group]) 方法用于获取分组匹配的子串在整个字符串中的结束位置（子串最后一个字符的索引+1），参数默认值为 0；

span()

span([group]) 方法返回 (start(group), end(group))。

re.findall（匹配所有符合的字段）

在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。

函数语法

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

string

待匹配的字符串

pos

可选参数，指定字符串的起始位置，默认0

endpos

可选参数，指定字符串的结束位置，默认与字符串长度相同
例：

import re

str = 'sdh2hdi3fh333r9v94'
pattern = re.compile(r'\d+')  # 查询所有的数字
l = pattern.findall(str)
print(l)
print('--' * 20)
s = pattern.findall(str,5,11) #查询第5位到第11位的数字
print(s)

结果为：

['2', '3', '333', '9', '94']
----------------------------------------
['3', '3']

re.finditer

在字符串中找到正则表达式所匹配的所有子串。

函数语法

re.finditer(pattern, string, flags=0)

例：

import re

str = 'sdh2hdi3fh333r9v94'
iter = re.findall(r'\d+',str)
print(iter)

结果为：

['2', '3', '333', '9', '94']

re.split

split 方法按照能够匹配的子串将字符串分割后返回列表。

函数语法

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

pattern

匹配的正则表达式

string

要匹配的字符串

maxsplit

分隔次数，maxsplit=1分隔一次，默认为0，不限制次数

flags

标志位，用于控制正则表达式的匹配方式
例：

import re

s = re.split('\W+','python,pthron.python?')
print(s)
print('**' * 20)
r = re.split('(\W+)',' python, pthron. python?')
print(r)
print('**' * 20)
t  = re.split('\W+',' python,pthron.python?',1)
print(t)

结果为：

['python', 'pthron', 'python', '']
****************************************
['', ' ', 'python', ', ', 'pthron', '. ', 'python', '?', '']
****************************************
['', 'python,pthron.python?']

正则表达式对象

re.RegexObject

re.compile() 返回 RegexObject 对象。

re.MatchObject

group() 返回被 RE 匹配的字符串。

start()

返回匹配开始的位置

end()

返回匹配结束的位置

span()

返回一个元组包含匹配（开始，结束）的位置