1. 正则表达式基础
1.1. 简单介绍
正则表达式并不是Python的一部分。正则表达式是用于处理字符串的强大工具，拥有自己独特的语法以及一个独立的处理引擎，效率上可能不如str自带的方法，但功能十分强大。得益于这一点，在提供了正则表达式的语言里，正则表达式的语法都是一样的，区别只在于不同的编程语言实现支持的语法数量不同；但不用担心，不被支持的语法通常是不常用的部分。如果已经在其他语言里使用过正则表达式，只需要简单看一看就可以上手了。
下图展示了使用正则表达式进行匹配的流程： http://www.cnblogs.com/huxi/archive/2010/07/04/1771073.html
正则表达式的大致匹配过程是：依次拿出表达式和文本中的字符比较，如果每一个字符都能匹配，则匹配成功；一旦有匹配不成功的字符则匹配失败。如果表达式中有量词或边界，这个过程会稍微有一些不同，但也是很好理解的，看下图中的示例以及自己多使用几次就能明白。
下图列出了Python支持的正则表达式元字符和语法：
1.”.“匹配任意除换行符以外的字符
>>> string = "abafsdafd
afdasfd" #包含换行符
>>> string1 = "adfasdfadfasdfwer12345656耿" #不包含换行符
>>> import re
>>> m = re.search(".+",string) #验证是否可以匹配换行符
>>> m.group()
'abafsdafd'
>>> n = re.search(".+",string1)
>>> n.group()
'adfasdfadfasdfwer12345656耿'
从上面输出结果可以看出，”.“是匹配任意除了换行符的字符。遇到"
"换行符即终止匹配。
2.”"转义字符
转义字符，使后一个字符改变原来的意思。如果字符串中有*号需要匹配，可以使用*或者字符集[*],"a.c"代表匹配a.c "a\c"代表匹配ac
>>> str_num = "22.567979mafdasdf"
>>> m = re.search("d+.d+",str_num)
>>> m.group()
'22.567979'
我们知道，"."在python中代表的含义是除了"
"之外的所有字符，如果这里不进行转义的话，匹配出来的就是任意非"
"字符，因此要使用""进行转义。
>>> string = "dfafdasfdfafdasfda"
>>> string
'dfafdasfdx0cafdasfda'
在python中，如果字符串中包含""，有时候会显示不出来，或者修改后面的内容，把别人改变了，这个不知道在Linux平台上是怎么回事。
3.[...]字符集（字符类）
[...]：字符集（字符类）对应的位置可以是字符集中任意字符。字符集中的字符可以逐个列出[0,1,2,3,4,5,6,7,8,9]，也可以给出范围[0-9]。第一个字符集如果是^表示取反，如[^abc]表示不是abc的其他字符。
所有的特殊字符在字符集中都失去其原有的特殊意义。在字符集中如果要使用]、或^，可以在前面加上""反斜杠，或把]、-放在第一个字符，把^放在非第一个字符。
>>> string = "dafdafdasf[adfas^fad"
>>> m = re.search("[a-z]+[",string)
>>> m.group()
'dafdafdasf['
从上面脚本可以看出，如果要匹配[要在前面加上""转义字符。
>>> m = re.search("w+[[]",string) （1）在字符集中匹配"["
>>> m.group()
'dafdafdasf['
>>> n = re.search("w+[[]",string) （2）转义匹配，验证在字符集中匹配[是否需要加[]
>>> n.group()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute 'group'
在字符集中如果要使用]、或^，可以在前面加上""反斜杠，或把]、-放在第一个字符，把^放在非第一个字符。
预定义字符集
1.d数字
>>> m = re.search("d",string)
>>> m.group()
'1'
d是匹配数字，等价于[0-9]
2.D非数字 等价于[^d]
>>> string = "dfaMNA12581耿fa"
>>> m = re.search("D",string)
>>> m.group()
'd'
>>> n = re.search("[^d]",string)
>>> n.group()
'd'
>>> l = re.search("[^0-9]",string)
>>> l.group()
'd'
从上面可以看出,“D”是用来匹配非数字的，匹配除了数字0-9意外的任意字符，等价于[^0-9]或[^d]
3.s空白字符 [<空格>
fv]
“s”是匹配任意非空字符，如[<空格> fv]等，实例如下：
>>> m = re.search("s+",string) #s进行匹配空白字符
>>> m.group()
'
x0c x0b
'
从上面可以看出，s是匹配任意空白字符，如空格、
、 、
、f、v等
4.S非空白字符 S与s正好相反，是匹配任意非空字符。等价于[^s]匹配任意非空字符
>>> string = "faMM耿
f v
DASDF"
>>> n = re.search("S+",string)
>>> n.group()
'faMM耿'
从上面可以看出"S"是匹配任意非空字符，遇到空的字符即停止了，匹配任意非空字符，"."匹配任意字符，除了换行符之外。
>>> m = re.search(".+",string)
>>> m.group()
'faMM耿 '
从上面看出，“S”和“.”还是有差别的，一个是任意非空字符，一个是匹配任意除了"
"意外任意非空字符。
5.w 单词字符[A-Z0-9a-z_]
w是匹配单词字符，下面来看下能不能匹配汉字或其他：
>>> string = "faMM耿 f v DASDF"
>>> m = re.search("w+",string)
>>> m.group()
'faMM耿' （1）脚本
>>> format_string = "fdMM更KKMM长 /大MM
MMKDSI"
>>> m = re.search("w+",format_string)
>>> m.group()
'fdMM更KKMM长' （2）脚本
可以看出，"w"是可以匹配汉字的，不能匹配空格，换行符这些，但是能够匹配汉字。
6.W 等价于非单词字符 [^w]
>>> import re
>>> string = "naefda曾 LmKDS 1316547
@@3$&^$"
>>> m = re.search("W+",string)
>>> m.group()
' '
从上面可以看出"W "匹配出来了空，说明" "不是单词字符，"W"是匹配非单词字符。
数量词（用在字符或(...)之后）
1."*" 匹配前一个字符0或无限次 前一个字符
"*"是匹配前一个字符0或无限次
>>> import re
>>> string = "naefda曾 LmKDS 1316547
@@3$&^$"
>>> m = re.search("w*",string)
>>> m.group()
'naefda曾'
>>> n = re.search("d*",string)
>>> n.group()
''
>>> n = re.search("耿",string)
>>> n
>>> n.group()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute 'group'
从上面脚本代码可以看出，当使用*要查找的字符在开头的时候就会匹配到，在中间就匹配不到。这种懒惰的匹配方式，如果其他情况下匹配不到，则会返回错误。
2.“+” 匹配前一个字符一次或无限次 前一个字符（牢记，只是匹配前面一个）
>>> import re
>>> string = "naefda曾 LmKDS 1316547
@@3$&^$"
>>> m = re.search("w+",string)
>>> m.group()
'naefda曾'
>>> n = re.search("s+",string)
>>> n.group()
' '
>>> d = re.search("更",string)
>>> d.group()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute 'group'
从上面可以看出，"+"是匹配前一个字符一次或无限次，如果匹配不到，则返回None
3."?" 匹配前一个字符0次或一次 前一个字符（牢记，只是匹配前面一个）
>>> import re
>>> string = "naefda曾 LmKDS 1316547
@@3$&^$"
>>> m = re.search("w?",string)
>>> m.group()
'n'
>>> n = re.search("f?",string)
>>> n.group()
''
从上面可以看出，?是以贪婪的方式进行匹配。?是匹配前一个字符0次或1次。从上面的例子中发现一个问题，即"?"和"*"都是从头开始进行匹配，如果开头匹配不到，就返回""，等价于如果使用search()出现”?"和“*”等价于使用match()从头开始匹配，找不到则不找了，不一样的是match()返回的是None，而seach()返回的是""。
4.{m} 代表匹配前一个字符m次 前一个字符（牢记，只是匹配前面一个）
>>> import re
>>> string = "dafMM
更1134657Qqcd m,l#!"
>>> m = re.search("d{4}",string) #代表匹配数字四次
>>> m.group()
'1134'
>>> n = re.search("d{10}",string)
>>> n.group()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute 'group'
从上面可以看出，如果匹配不到，则返回None；{m}是代表匹配前一个字符m次，要注意在匹配的时候，我们可以像下面一样设定一个匹配区间，这样就不会出现匹配超标的情况。
5.{m,n} 匹配一个字符m次至n次 前一个字符（牢记，只是匹配前面一个）
m和n可以省略，如省略m({,n})则匹配0到n次；若省略n（{m,}）,则匹配m至无限次。
>>> import re
>>> string = "dafMM 更1134657Qqcd m,l#!"
>>> m = re.search("d{1,10}",string)
>>> m.group()
'1134657'
>>> n = re.search("d{,5}",string)
>>> n.group()
''
>>> d = re.search("d{4,}",string)
>>> d.group()
'1134657'
从上面可以看出，{m,n}是匹配在一个范围内的个数，但是我们也发现了一个问题，千万不要让正则表达式匹配包含0次的情况，一旦匹配0次，那么就会出现如果开头匹配不到之后，就不匹配的情况，直接返回""。
*? +? ?? {m,n}?使*,+,?,{m,n}变成非贪婪模式。
边界匹配
1.^ 匹配字符串开头，在多行模式中，匹配第一行的开头
>>> import re
>>> string = "dafMM 更1134657Qqcd m,l#!"
>>> m = re.search("^da",string)
>>> m.group()
'da'
开头匹配，相当于使用match()进行匹配了。
2.$ 匹配字符串末尾，在多行模式中匹配每一行的末尾
>>> import re
>>> string = "dafMM 更1134657Qqcd m,l#!"
>>> m = re.search("#!",string)
>>> m.group()
'#!'
"$"是匹配字符串的末尾，不管前面，值匹配末尾是否是要匹配的内容。
3.A 仅匹配字符串开头
>>> import re
>>> string = "dafMM 更1134657Qqcd m,l#!"
>>> m = re.search("Adaf",string)
>>> m.group()
'daf'
“A”是仅匹配字符串开头，即仅仅从字符串的开头进行匹配。
4. 仅匹配字符串末尾
>>> import re
>>> string = "dafMM 更1134657Qqcd m,l#!"
>>> n = re.search("l#!",string)
>>> n.group()
'l#!'
""是仅匹配字符串末尾，仅从末尾进行匹配，可能和$的区别就是，$是匹配每行的末尾，而是仅匹配字符串的末尾。
5. 匹配w和W之间的字符
6.B 匹配非w和W之间的字符 即[^]
逻辑分组
1.“|” 代表左右表达式任意匹配一个
它总是先尝试匹配左边的表达式，一旦成功则跳过右边的表达式。如果|没有被包含在()中，则它的范围是整个正则表达式
>>> import re
>>> m = re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict()
>>> m
{'city': '81', 'birthday': '1993', 'province': '3714'}
可以依次分组匹配，生成一个字典，groupdict()，分组匹配，给匹配到的字符串起名字。
1.2. 数量词的贪婪模式与非贪婪模式
正则表达式通常用于在文本中查找匹配的字符串。Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字符；非贪婪的则相反，总是尝试匹配尽可能少的字符。例如：正则表达式"ab*"如果用于查找"abbbc"，将找到"abbb"。而如果使用非贪婪的数量词"ab*?"，将找到"a"。
1.3. 反斜杠的困扰
与大多数编程语言相同，正则表达式里使用""作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符""，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\\"：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式可以使用r"\"表示。同样，匹配一个数字的"\d"可以写成r"d"。有了原生字符串，你再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。
1.4. 匹配模式
正则表达式提供了一些可用的匹配模式，比如忽略大小写、多行匹配等，这部分内容将在Pattern类的工厂方法re.compile(pattern[, flags])中一起介绍。
2. re模块
2.1. 开始使用re
Python通过re模块提供对正则表达式的支持。使用re的一般步骤是先将正则表达式的字符串形式编译为Pattern实例，然后使用Pattern实例处理文本并获得匹配结果（一个Match实例），最后使用Match实例获得信息，进行其他的操作。
import re #将正则表达式编译成Pattern对象 pattern = re.compile(r'hello') #使用pattern匹配文本,获得匹配结果，无法匹配时将返回None match = pattern.match("hello world!") if match: #使用match获得分组信息 print(match.group())
上面正则匹配中，首先进行了编译，编译成正则格式，然后进行匹配。
re.compile(strPattern[, flag]):
这个方法是Pattern类的工厂方法，用于将字符串形式的正则表达式编译为Pattern对象。 第二个参数flag是匹配模式，取值可以使用按位或运算符'|'表示同时生效，比如re.I | re.M。另外，你也可以在regex字符串中指定模式，比如re.compile('pattern', re.I | re.M)与re.compile('(?im)pattern')是等价的。
可选值有：
re模块还提供了一个方法escape(string)，用于将string中的正则表达式元字符如*/+/?等之前加上转义符再返回，在需要大量匹配元字符时有那么一点用。
2.2. Match
>>> string = "aafaaMMaaaa"
>>> m = re.search("aa?",string)
>>> m.group()
'aa'
>>> n = re.search("aaa?",string)
>>> n.group()
'aa'
>>> d = re.search("aaaa?",string)
>>> d.group()
'aaaa'
上面代码中，"?"的作用是匹配前一个字符，就是这个正则符号前面的那个字符0次或一次。
正则表达式匹配中文（http://blog.csdn.net/tao_627/article/details/51019972）
import re
name = "ge耿长学164——///大师傅"
# name = name.encode('utf-8')
d = re.search(u"([u4e00-u9fa5]+)",name)
print(d.group())
unicode中中文的编码为/u4e00-/u9fa5
上面的正则表达式u"([u4e00-u9fa5]+)"就是用来匹配中文字符的，
匹配非中文字符集如下：
import re
name = "ge耿长学164——///大师傅"
# name = name.encode('utf-8')
d = re.search(u"([^u4e00-u9fa5]+)",name)
print(d.group())
只需在正则表达式里面加上^,非的意思，就是匹配中文意外的其他字符。