标签：
就其本质而言，正则表达式（或 RE）是一种小型的、高度专业化的编程语言，
（在Python中）它内嵌在Python中，并通过 re 模块实现。
正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行
| 元字符 | 说明 | 表达式示例 | 匹配后的字符串 |
| . | 匹配任意除还行符‘\n‘外的字符。 | a.c | abc |
| ^ |
匹配字符串开头； 在多行模式中匹配每一行开头。 |
^abc | abc |
| $ |
匹配字符串末尾； 在多行模式中匹配每一行末尾。 |
abc$ | abc |
| * | 匹配前一个字符0或无限次。 | abc* |
ab abccc |
| + | 匹配前一个字符1或无限次。 | abc+ |
abc abcccc |
| ? | 匹配前一个字符0或1次。 | abc? |
ab abc |
|
{m}
|
匹配前一个字符m次。 | ab{2}c | abbc |
| {m，n} |
匹配前一个字符m至n次。 m和n可以省略：若省略m,则匹配0至n次； 若省略你，则匹配m至无限次。 |
ab{1,2}c |
abc abbc |
| | |
|代表左右表达式任意匹配一个 它总是先尝试匹配左边表达式，一旦成功则跳过匹配右边的表达式 如果|没有被包括在()中，则它的范围是整个表达式。 |
abc|def |
abc def |
|
()
|
被括起来的表达式将作为分组，从表达左边开始每遇到一个分组的左括号“（”，编号+1。 | (abc){2} | abcabc |
|
\
|
转义字符，使后一个字符改变原来的意思。 | a\.c | a.c |
| [] | 字符集。对应的位置可以是字符集中的任意字符。[a-c]就是给出范围 | a[bcd]e |
abe ace ade |
\:反斜杠后边跟元字符去除特殊功能
反斜杠后边跟普通字符实现特殊功能。
引用序号对应的字组所匹配的字符串
| \d | 匹配任何十进制数；它相当于类 [0-9] |
a\dc |
a1c |
| \D | 匹配任何非数字字符；它相当于类 [^0-9] | a\Dc | abc |
| \s | 匹配任何空白字符；它相当于类 [ \t\n\r\f\v] | a\sc | a c |
| \S | 匹配任何非空白字符；它相当于类 [^ \t\n\r\f\v] | a\Sc | abc |
| \w | 匹配任何字母数字字符；它相当于类 [a-zA-Z0-9_] | a\wc | abc |
| \W | 匹配任何非字母数字字符；它相当于类 [^a-zA-Z0-9_] | a\Wc | a c |
| \b | 匹配一个单词边界，也就是指单词和空格间的位置 |
注释：\b例如：
‘er/b‘ 可以匹配"never" 中的 ‘er‘，但不能匹配 "verb" 中的 ‘er‘。
\b只是匹配字符串开头结尾及空格回车等的位置, 不会匹配空格符本身
import re m = re.findall(‘\babc\b‘,‘abc sdsadasabcasdsadasdabcasdsa‘) print(m) 输出结果： [] import re m = re.findall(r‘\babc\b‘,‘abc sdsadasabcasdsadasdabcasdsa‘) print(m) 输出结果： [‘abc‘]
\b 就是用在你匹配整个单词的时候。 如果不是整个单词就不匹配。 你想匹
配 I 的话，你知道，很多单词里都有I的，但我只想匹配I，就是“我”，这个时
候用 \bI\b
与大多数编程语言相同，正则表达式里使用"\"作为转义字符，这就可能造成反斜杠困扰。
假如你需要匹配文本中的字符"\"，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\\\\"：
前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。
Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式可以使用r"\\"表示。
同样，匹配一个数字的"\\d"可以写成r"\d"。有了原生字符串，你再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。
示例：
import re m = re.findall(‘\babc\b‘,‘abc sdsadasabcasdsadasdabcasdsa‘) print(m) 运算结果： [] import re m = re.findall(r‘\babc\b‘,‘abc sdsadasabcasdsadasdabcasdsa‘) print(m) 运算结果： [‘abc‘]
*?,+?,??,{m,n}? 前面的*,+,?等都是贪婪匹配，也就是尽可能匹配，后面加?号使其变成惰性匹配
从前面的描述可以看到‘*‘，‘+‘和‘?‘都是贪婪的，但这也许并不是我们说要的，
所以，可以在后面加个问号，将策略改为非贪婪，只匹配尽量少的RE
示例：
import re m = re.findall(r‘a(\d+?)‘,‘a23b‘) print(m) 输出结果： [‘2‘] import re i = re.findall(r‘a(\d+)‘,‘a23b‘) print(i) 输出结果： [‘23‘]
python通过re模块提供对正则表达式的支持。
例一：
import re # 将正则表达式编译成Pattern对象 pattern = re.compile(r‘hello‘) # 使用Pattern匹配文本，获得匹配结果，无法匹配时将返回None match = pattern.match(‘hello world!‘) if match: # 使用Match获得分组信息 print match.group() 输出结果： hello
例二：
import re
a = "123abc456"
i = re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(0) #group(0) 列出整体
k = re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(1) #group(1) 列出第一个括号匹配部分
h = re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(2) #group(2) 列出第二个括号匹配部分
n = re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(3) #group(3) 列出第三个括号匹配部分
print(i)
print(k)
print(h)
print(n)
运算结果：
123abc456
123
abc
456
1，match
match：re.match(pattern, string, flags=0)
Pattern对象是一个编译好的正则表达式
string: 匹配时使用的文本
flags: 编译时用的匹配模式。数字形式
示例：
import re m = re.match(r‘hello‘, ‘hello world!‘) print(m.group()) 输出结果： hello import re m = re.search(‘alex‘,‘alexdj‘) print(m.group()) 输出结果： alex
2,search
查找字符串中可以匹配成功的子串
import re # 将正则表达式编译成Pattern对象 pattern = re.compile(r‘you‘) # 使用search()查找匹配的子串，不存在能匹配的子串时将返回None # 这个例子中使用match()无法成功匹配 match = pattern.search(‘fork you!‘) if match: # 使用Match获得分组信息 print(match.group())
输出结果：
you
注意：
re.match(‘com‘, ‘comwww.runcomoob‘)
re.search(‘\dcom‘, ‘www.4comrunoob.5com‘)
一旦匹配成功，就是一个match object 对象，而match object 对象拥有以下方法：
group() 返回被 RE 匹配的字符串 ；获得一个或多个分组截获的字符串；指定多个参数时将以元组形式返回。group1可以使用编号也可以使用别名；编号0代表整个匹配的子
串；不填写参数时，返回group(0)；没有截获字符串的组返回None；截获了多次的组返回最后一次截获的子串
group() 返回re整体匹配的字符串，可以一次输入多个组号，对应组号匹配的字符串。
1). group（）返回re整体匹配的字符串，
2). group (n,m) 返回组号为n，m所匹配的字符串，如果组号不存在，则返回indexError异常
3).groups（）groups() 方法返回一个包含正则表达式中所有小组字符串的元组，从 1 到
所含的小组号，通常groups（）不需要参数，返回一个元组，元组中的元就是正则表达式中定义的组。
start() 返回匹配开始的位置 ；group默认值为0
end() 返回匹配结束的位置；group默认值为0
span() 返回一个元组包含匹配 (开始,结束) 的位置；返回(start(group), end(group))
示例：
import re m = re.match(r‘(\w+) (\w+)(?P<sign>.*)‘, ‘hello world!‘) print ("m.group(1,2):", m.group(1, 2)) print ("m.groups():", m.groups()) print ("m.groupdict():", m.groupdict()) # print ("m.start(2):", m.start(2)) print ("m.end(2):", m.end(2)) print ("m.span(2):", m.span(2)) 输出结果： m.group(1,2): (‘fork‘, ‘you‘) m.groups(): (‘fork‘, ‘you‘, ‘!‘) m.groupdict(): {‘sign‘: ‘!‘} m.start(2): 5 m.end(2): 8 m.span(2): (5, 8)
3，split
按照能够匹配的子串将string分割后返回列表。maxsplit用于指定最大分割次数，不指定将全部分割
示例：
import re p = re.compile(r‘\d+‘) print p.split(‘one1two2three3four4‘) 运算结果： [‘one‘, ‘two‘, ‘three‘, ‘four‘, ‘‘]
4，findall
re.findall 以列表形式返回所有匹配的字符串
re.findall可以获取字符串中所有匹配的字符串。
示例：
# 返回全部能匹配的字符串
import re
p = re.compile(r‘\d+‘)
print(p.findall(‘one1two2three3four4‘))
元算结果：
[‘1‘, ‘2‘, ‘3‘, ‘4‘]
5,finditer
返回一个顺序访问每一个匹配结果（Match对象）的迭代器
示例：
#返回一个顺序访问每一个匹配结果（Match对象）的迭代器 import re p = re.compile(r‘\d+‘) for m in p.finditer(‘one1two2three3four4‘): print (m.group()) 运算结果： 1 2 3 4
6，sub 每一个匹配的子串后返回替换后的字符串
示例：
import re 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)) 运算结果： sayi,worldhello! ISay,HelloWorld!
7,subn
示例：
import re 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)
标签：
原文地址：http://www.cnblogs.com/kongqi816-boke/p/5500851.html
