为什么使用正则表达式
在Python中已经有很多关于字符串检索的函数，那为什么还要学习正则表达式呢？可以从以下的场景进行体会（学自慕课）：# encoding:utf-8
# 读取文件的内容：
# imooc Php
# imooc java
# imooc python imooc
# C#
# VB
# ASP.NET
def find_in_imooc(fname):
f = open(fname)
for line in f:
# 因为python读取的文件以/n结尾所以得不到匹配
if line.startswith('imooc') and line.endswith('imooc'):
print line
else:
f.close()
print '------------------'
find_in_imooc('imooc.txt')
print '------------------'
def find_in_imooc(fname):
f = open(fname)
for line in f:
# 因为python读取的文件以/n结尾所以舍去最后一个字符\n0
if line.startswith('imooc') and line[:-1].endswith('imooc'):
print '------------------'
print line[-1]
print '------------------'
print line
else:
f.close()
print '------------------'
find_in_imooc('imooc.txt')
print '------------------'------------------
------------------
------------------
imooc python imooc
------------------
[Finished in 0.1s]如同上面的例子，使用find,findall等函数时必须先知道字符串的格式和每次都写好检索条件这样本身给字符检索带来了大量的工作。而正则表达式是一个模式多个匹配，可以在不清楚检索字符串结构情况下，实现通用的匹配。
Python的re模块
使用re生成Match的两种方法：
第一种：- compile 函数根据一个模式字符串和可选的标志参数生成一个Pattern对象。该对象拥有一系列方法用于正则表达式匹配和替换。
- 使用生成的Pattern对象的match方法生成一个Match对象。3.最后使用Match对象的一系列方法得到匹配的信息。
第二种：区别第一种方法不生成Patttern对象直接生成Match对象
案例：
匹配字符串中是否出现'imooc'（没有打广告的意思）首先使用普通的字符匹配函数：
In [23]: str1 = 'imooc python'
In [24]: str1.find('11')
Out[24]: -1
In [25]: str1.find('imooc')
Out[25]: 0
In [26]: str1.startswith('imooc')
Out[26]: True接着使用正则：
第一种生成Match对象的方法：
In [27]: import re
In [28]: pa = re.compile(r'imooc') # 生成Pattern对象
In [29]: pa
Out[29]: re.compile(r'imooc')
In [30]: type(pa)
Out[30]: _sre.SRE_Pattern
In [31]: pa. # 查看Pattern对象所具有的方法
pa.findall pa.groupindex pa.pattern pa.split
pa.finditer pa.groups pa.scanner pa.sub
pa.flags pa.match pa.search pa.subn使用Pattern对象的match方法生成一个Match对象
In [32]: str1
Out[32]: 'imooc python'
In [33]: pa.match(str1)
Out[33]: <_sre.SRE_Match at 0x29baac0> # 生成Match对象
In [34]: ma = pa.match(str1)
In [35]: ma
Out[35]: <_sre.SRE_Match at 0x3861d98>
In [36]: ma. # 查看Match所具有的方法
ma.end ma.group ma.lastgroup ma.re ma.start
ma.endpos ma.groupdict ma.lastindex ma.regs ma.string
ma.expand ma.groups ma.pos ma.span
In [36]: ma.group() # 返回匹配得到的字符或者元组
Out[36]: 'imooc'
In [37]: ma.groups()
Out[37]: ()
In [38]: help(ma.g
ma.group ma.groupdict ma.groups
In [38]: help(ma.group)
Help on built-in function group:
group(...) # 查看帮助文档
group([group1, ...]) -> str or tuple.
Return subgroup(s) of the match by indices or names.
For 0 returns the entire match.返回匹配的索引位置：
In [40]: ma.span()
Out[40]: (0, 5)
In [41]: str1
Out[41]: 'imooc python'
匹配的字符串放在Match对象的string中，而Pattern对象则放在Match对象的re中
In [42]: ma.string
Out[42]: 'imooc python'
In [43]: ma.re
Out[43]: re.compile(r'imooc')第二种生成Match对象的方法：
In [52]: ma = re.match(r'imooc',str1) # 直接使用match方法生成
In [53]: ma
Out[53]: <_sre.SRE_Match at 0x3861f38>
In [54]: ma.group()
Out[54]: 'imooc'
In [55]: ma.re
Out[55]: re.compile(r'imooc')
In [56]: ma.string
Out[56]: 'imooc python'两种方法的使用情况：
如果而要做大量的匹配，而正则表达式只有一个，可以先生成一个Pattern对象，如果只有一次的匹配，则无需先生成一个Pattern对象。正则表达式语法
字符匹配
| python | 匹配 "python". |
字符类
| [Pp]ython | 匹配 "Python" 或 "python" |
| rub[ye] | 匹配 "ruby" 或 "rube" |
| [aeiou] | 匹配中括号内的任意一个字母 |
| [0-9] | 匹配任何数字。类似于 [0123456789] |
| [a-z] | 匹配任何小写字母 |
| [A-Z] | 匹配任何大写字母 |
| [a-zA-Z0-9] | 匹配任何字母及数字 |
| [^aeiou] | 除了aeiou字母以外的所有字符 |
| [^0-9] | 匹配除了数字外的字符 |
特殊字符类
| . | 匹配除 "\n" 之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用象 '[.\n]' 的模式。 |
| \d | 匹配一个数字字符。等价于 [0-9]。 |
| \D | 匹配一个非数字字符。等价于 [^0-9]。 |
| \s | 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。 |
| \S | 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。 |
| \w | 匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'。 |
| \W | 匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'。 |
正则表达式模式
模式字符串使用特殊的语法来表示一个正则表达式：
字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。
多数字母和数字前加一个反斜杠时会拥有不同的含义。
标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。
反斜杠本身需要使用反斜杠转义。
由于正则表达式通常都包含反斜杠，所以你最好使用原始字符串来表示它们。
模式元素(如 r'/t'，等价于'//t')匹配相应的特殊字符。
下表列出了正则表达式模式语法中的特殊元素。如果你使用模式的同时提供了可选的标志参数，
某些模式元素的含义会改变。
| ^ | 匹配字符串的开头 |
| $ | 匹配字符串的末尾。 |
| . | 匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。 |
| [...] | 用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k' |
| [^...] | 不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。 |
| re* | 匹配0个或多个的表达式。 |
| re+ | 匹配1个或多个的表达式。 |
| re? | 匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式 |
| re{ n,} | 精确匹配n个前面表达式。 |
| re{ n, m} | 匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式 |
| a| b | 匹配a或b |
| (re) | G匹配括号内的表达式，也表示一个组 |
| (?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 | 匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。c |
| \z | 匹配字符串结束 |
| \G | 匹配最后匹配完成的位置。 |
| \b | 匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。 |
| \B | 匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。 |
| \n, \t, 等. | 匹配一个换行符。匹配一个制表符。等 |
| \1...\9 | 匹配第n个分组的子表达式。 |
| \10 | 匹配第n个分组的子表达式，如果它经匹配。否则指的是八进制字符码的表达式。 |
贪婪模式与非贪婪模式：
| * | 匹配前一个字符0次或者无限次 |
| + | 匹配前一个字符1次或者无限次 |
| ？ | 匹配前一个0次或者1次 |
| {m} / {m,n} | 匹配前一个字符m次或者m到n次 |
| *？ / +? / ?? | 匹配模式变为非贪婪模式（尽可能的少匹配字符） |
分组匹配：
| \<num> | 引用编号为num的分组匹配得到的字符 |
| (?P<name>) | 为分组起一个别名 |
| (?P=name) | 引用别名为name的分组匹配字符 |
实例：
贪婪模式
In [58]: ma = re.match(r'[a-zA-Z0-9]*','133ABAD')
In [60]: ma.group()
Out[60]: '133ABAD'非贪婪模式：
In [61]: ma = re.match(r'[a-zA-Z0-9]*?','133ABAD')
In [62]: ma.group()
Out[62]: ''
In [63]: ma = re.match(r'[a-zA-Z0-9]+?','133ABAD')
In [64]: ma.group()
Out[64]: '1'
In [65]: ma = re.match(r'[a-zA-Z0-9]??','133ABAD')
In [66]: ma.group()
Out[66]: ''模式匹配：
In [70]: ma = re.match('[\w]{4,10}@163.com$','imooc@163.comabc')
In [71]: ma
In [72]: ma = re.match('[\w]{4,10}@163.com$','imooc@163.com')
In [73]: ma
Out[73]: <_sre.SRE_Match at 0x3acf370>
In [74]: ma.group()
Out[74]: 'imooc@163.com'
In [75]: ma = re.match('^[\w]{4,10}@163.com$','imooc@163.com')
In [76]: ma
Out[76]: <_sre.SRE_Match at 0x3acf3d8>
In [77]: ma.group()
Out[77]: 'imooc@163.com'
In [78]: ma = re.match('\Aimooc@163.com$','Iimooc@163.com')
In [79]: ma
In [80]: ma = re.match('\Aimooc@163.com$','imooc@163.com')
In [81]: ma
Out[81]: <_sre.SRE_Match at 0x3acf7e8>
In [82]: ma.group()
Out[82]: 'imooc@163.com'
In [83]: ma = re.match('\Aimooc@163.\Zcom','imooc@163.comC')
In [84]: ma
In [85]: ma = re.match('\Aimooc@163.\Zcom','imooc@163.com')
In [86]: ma
In [87]: ma = re.match('\Aimooc@163.com\Z','imooc@163.com')
In [88]: ma
Out[88]: <_sre.SRE_Match at 0x3acfb90>
In [89]: ma.group()
Out[89]: 'imooc@163.com'
In [90]:
In [70]: ma = re.match('[\w]{4,10}@163.com$','imooc@163.comabc')
In [71]: ma
In [72]: ma = re.match('[\w]{4,10}@163.com$','imooc@163.com')
In [73]: ma
Out[73]: <_sre.SRE_Match at 0x3acf370>
In [74]: ma.group()
Out[74]: 'imooc@163.com'
In [75]: ma = re.match('^[\w]{4,10}@163.com$','imooc@163.com')
In [76]: ma
Out[76]: <_sre.SRE_Match at 0x3acf3d8>
In [77]: ma.group()
Out[77]: 'imooc@163.com'
In [78]: ma = re.match('\Aimooc@163.com$','Iimooc@163.com')
In [79]: ma
In [80]: ma = re.match('\Aimooc@163.com$','imooc@163.com')
In [81]: ma
Out[81]: <_sre.SRE_Match at 0x3acf7e8>
In [82]: ma.group()
Out[82]: 'imooc@163.com'
In [83]: ma = re.match('\Aimooc@163.\Zcom','imooc@163.comC')
In [84]: ma
In [85]: ma = re.match('\Aimooc@163.\Zcom','imooc@163.com')
In [86]: ma
In [87]: ma = re.match('\Aimooc@163.com\Z','imooc@163.com')
In [88]: ma
Out[88]: <_sre.SRE_Match at 0x3acfb90>
In [89]: ma.group()
Out[89]: 'imooc@163.com'
In [90]:分组匹配：
In [98]: ma = re.match(r'<(?P<mark>[\w]+>)[\w]+</(?P=mark)','<book>python</book>')
In [99]: ma
Out[99]: <_sre.SRE_Match at 0x37d4f30>
In [100]: ma.groups()
Out[100]: ('book>',)
In [101]:re中其他的重要函数：
In [1]: import re
In [2]: help(re.search)
Help on function search in module re:
search(pattern, string, flags=0)
Scan through string looking for a match to the pattern, returning
a match object, or None if no match was found.
In [3]: help(re.findall)
Help on function findall in module re:
findall(pattern, string, flags=0)
Return a list of all non-overlapping matches in the string.
If one or more groups are present in the pattern, return a
list of groups; this will be a list of tuples if the pattern
has more than one group.
Empty matches are included in the result.
In [4]: help(re.sub)
Help on function sub in module re:
sub(pattern, repl, string, count=0, flags=0)
Return the string obtained by replacing the leftmost
non-overlapping occurrences of the pattern in string by the
replacement repl. repl can be either a string or a callable;
if a string, backslash escapes in it are processed. If it is
a callable, it's passed the match object and must return
a replacement string to be used.
In [5]: help(re.split)
Help on function split in module re:
split(pattern, string, maxsplit=0, flags=0)
Split the source string by the occurrences of the pattern,
returning a list containing the resulting substrings实例：
In [9]: import re
In [10]: str1 = "imooc videonum = 1000"
In [11]: str1.find("1000")
Out[11]: 17
In [12]: info = re.search(r'\d+',str1)
In [13]: info.group()
Out[13]: '1000'
In [14]: str1 = "imooc videonum = 10000"
In [15]: info = re.search(r'\d+',str1)
In [16]: info
Out[16]: <_sre.SRE_Match at 0x43b13d8>
In [17]: info.group()
Out[17]: '10000'
In [18]: str2 = "c++ = 100,java=90,python=80"
In [20]: info = re.search(r'\d+',str2)
In [21]: info.group()
Out[21]: '100'
In [22]: info = re.findall(r'\d+',str2
In [24]: info
Out[24]: ['100', '90', '80']
In [118]: str3 = 'imooc videonum = 1000'
In [119]: info = re.sub(r'\d+','1001',str3)
In [120]: info
Out[120]: 'imooc videonum = 1001'
In [121]: def add1(match):
.....: val = match.group()
.....: num = int(val)+1
.....: return str(num)
.....:
In [122]: str3
Out[122]: 'imooc videonum = 1000'
In [123]: re.sub(r'\d+',add1,str3)
Out[123]: 'imooc videonum = 1001'
In [124]: str3 = 'imoooc videonum = 9999'
In [125]: re.sub(r'\d+',add1,str3)
Out[125]: 'imoooc videonum = 10000'
In [126]: str4 = 'imooc:C C++ Java Python'
In [127]: re.split(r':| ',str4)
Out[127]: ['imooc', 'C', 'C++', 'Java', 'Python']
In [128]: str4 = 'imooc:C C++ Java Python,C#'
In [129]: re.split(r':| |,',str4)
Out[129]: ['imooc', 'C', 'C++', 'Java', 'Python', 'C#']
In [130]:正则表达式修饰符 - flag
正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：
| re.I | 使匹配对大小写不敏感 |
| re.L | 做本地化识别（locale-aware）匹配 |
| re.M | 多行匹配，影响 ^ 和 $ |
| re.S | 使 . 匹配包括换行在内的所有字符 |
| re.U | 根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B. |
| re.X | 该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解 |