本文主要就是在自己的认识的基础上翻译了部分python的官方文档。官方文档的地址是：
#coding:utf-8
import re
#match只是从头匹配字符串，search是匹配字符串的任何位置
#group都是从1开始的而不是0
re.match("c", "abcdef") # No match False
re.search("c", "abcdef") # Match True
reobj = re.compile("^ab\w*") #reobj是一个regular expression object
result = reobj.match("abcdef") #result是一个resulting regular expression object
#忽略大小写
re.I
re.IGNORECASE
#使\w, \W, \b, \B, \s and \S与当前位置有关
re.L
re.LOCALE
#使^,$分别匹配字符串和行的开始和结束，如果不指定则只匹配字符串的
re.M
re.MULTILINE
#使"."匹配任何东西，包括一个新行；如果不指定，则不匹配新行
re.S
re.DOTALL
#使\w, \W, \b, \B, \d, \D, \s and \S依赖于unicode字符属性数据库
re.U
re.UNICODE
#是空格（除了转义字符代表的空格），"#"不作为正则表达式的一部分，这样写出的正则表达式更加优美
re.X
re.VERBOSE
#以上这些可用于re.compile, re.search, re.match等等的第三个参数flags，可以使用"|"按位进行或操作
#以上的这些用法如下，下面这两个匹配是一样的。re.X的作用的是匹配正则表达式中的换行等，这样可以使正则表达式写的更优雅
a = re.compile(r"""\d + # the integral part
\. # the decimal point
\d * # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
#re.search(pattern, string[, flags])
#re.match(pattern, string[, flags])
#re.split(pattern, string[, maxsplit=0]) #用pattern来分割stirng，相当于字符串的split函数。如果pattern是用()括起来的，则pattern所匹配的部分也是匹配结果list中的元素
#如果maxsplit不等于0，只分割maxsplit次，剩下的部分作为结果list里面的最后一项（就相当于分割了maxsplit+1次，前maxsplit是正常分割，其余的部分作为结果list的最后一项放进去）。
"""
>>> re.split('\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split('(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split('\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
#pattern都是进行最大匹配
>>> re.split('(\W+)', '...words, words...')
['', '...', 'words', ', ', 'words', '...', '']
#如果没有匹配成功，则不进行分割，使整个字符串作为结果list的唯一一项
>>> re.split('x*', 'foo')
['foo']
>>> re.split("(?m)^$", "foo\n\nbar\n")
['foo\n\nbar\n']
"""
#re.findall(pattern, string[, flags]) #查找string中所有符合pattren的非重叠项
"""
>>> re.findall("a\w?","abcabccbaabcac")
['ab', 'ab', 'aa', 'ac']
"""
#re.finditer(pattern, string[, flags])
#re.sub(pattern, repl, string[, count]) #用repl替换string匹配pattern的部分，count是替换的次数。string还可以是一个函数，他有一个匹配对象的参数，返回用于替换的字符串
"""
>>> re.sub(r'def\s+([a-zA-Z_][a-zA-Z_0-9]*)\s*\(\s*\):',
... r'static PyObject*\npy_\1(void)\n{',
... 'def myfunc():')
'static PyObject*\npy_myfunc(void)\n{'
>>> def dashrepl(matchobj):
... if matchobj.group(0) == '-': return ' '
... else: return '-'
>>> re.sub('-{1,2}', dashrepl, 'pro----gram-files')
'pro--gram files'
>>> re.sub('x*', '-', 'abc') #这里x*当x出现0次讲，所以算是匹配上了
'-a-b-c-'
>>> re.sub('x', '-', 'abc')
'abc'
"""
#re.subn(pattern, repl, string[, count]) #和re.sub是一样的，只不过他返回一个tuple。(new_string, number_of_subs_made)
"""
>>> re.subn("cbw?", "CB", "cbacbacba")
('CBaCBaCBa', 3)
"""
#re.escape(string) #这个相当于对string进行转义，如果string里面包含着正则表达式，则将其转换为普通的字符串
"""
>>> re.escape("(^cb\w+)+")
'\\(\\^cb\\\\w\\+\\)\\+'
"""
#exception re.error #当遇到不合法的正则表达式的时候会抛出的异常
#Regular Expression Objects
#Regular Expression Objects是re.compile得到的对象
#RegexObject.match(string[, pos[, endpos]]) #字符串是否符合正则表达式，pos是正则匹配在字符串中的位置，endpos是结束位置
#如果匹配返回MatchObject，否则返回None
"""
>>> pattern = re.compile("o")
>>> pattern.match("dog") # No match as "o" is not at the start of "dog."
>>> pattern.match("dog", 1) # Match as "o" is the 2nd character of "dog".
<_sre.SRE_Match object at ...>
"""
#RegexObject.search(string[, pos[, endpos]]) #和re.search相似，pos与endpos和RegexObject.match中的类似
#RegexObject.split(string[, maxsplit=0]) #和re.split相似
#RegexObject.findall #与re.findall类似
#RegexObject.finditer #与re.finditer类似
#RegexObject.sub #与re.sub类似
#RegexObject.subn #与re.subn类似
#RegexObject.flags #RegexObject编译（re.complie）时候的flag值，如果编译的时候没提供flag，就是0
#RegexObject.groups #正则表达式中的组的数
#RegexObject.groupindex #是一个字典，键名是正则表达式中的组名，键值是组所对应的索引。
#RegexObject.pattern #RegexObject所对应的正则表达式
#Match Objects
#Match Objects是RegexObject.match（或者re.match）在匹配的情况下返回的对象
#MatchObject.expand(template) #根据一个模版用找到的内容替换模版里的相应位置
"""
>>> m.expand(r'name is \g<1> , age is \g
, tel is \3')
'name is Tom , age is 24 , tel is 88888888'
"""
#MatchObject.group([group1, ...]) #返回一个或者更多的子组的匹配
"""
>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
>>> m.group(0) # The entire match
'Isaac Newton'
>>> m.group(1) # The first parenthesized subgroup.
'Isaac'
>>> m.group(2) # The second parenthesized subgroup.
'Newton'
>>> m.group(1, 2) # Multiple arguments give us a tuple.
('Isaac', 'Newton')
#对于命名组
>>> m = re.match(r"(?P\w+) (?P\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
#仍然可以用索引
>>> m.group(1)
'Malcolm'
>>> m.group(2)
'Reynolds'
#如果匹配到了多次，则只有最后一次可得
>>> m = re.match(r"(..)+", "a1b2c3") # Matches 3 times.
>>> m.group(1) # Returns only the last match.
'c3'
"""
#MatchObject.groups([default]) #返回一个tuple，里面包含了所有的组
"""
>>> m = re.match(r"(\d+)\.(\d+)", "24.1632")
>>> m.groups()
('24', '1632')
#default是没有匹配到的时候的默认值，有点像字典的get方法
>>> m = re.match(r"(\d+)\.?(\d+)?", "24")
>>> m.groups() # Second group defaults to None.
('24', None)
>>> m.groups('0') # Now, the second group defaults to '0'.
('24', '0')
"""
#MatchObject.groupdict([default]) #返回所有命名组的字典，键名是组名，键值是匹配到的值。default是用来作为为匹配到的组的默认值的
"""
>>> m = re.match(r"(?P\w+) (?P\w+)", "Malcolm Reynolds")
>>> m.groupdict()
{'first_name': 'Malcolm', 'last_name': 'Reynolds'}
"""
#MatchObject.start([group]) #返回匹配开始和结束的位置。
#MatchObject.end([group]) #组默认情况下是0，匹配整个字符串。如果给出的组没有匹配上，则返回-1。
"""
#如果group匹配到了，要获得group g匹配的字符串：
m.string[m.start(g):m.end(g)]
m = re.search('b(c?)', 'cba') #m.start(0)等于1, m.end(0)等于2, m.start(1)和m.end(1)都等于2, m.start(2) raises an IndexError exception.
>>> email = "tony@tiremove_thisger.net"
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
'tony@tiger.net'
"""
#MatchObject.span([group]) #如果MatchObject匹配到了，返回一个有两个值的tuple： (m.start(group), m.end(group))。如果group没有匹配到返回(-1,-1)。group默认是0，匹配真个字符串
"""
>>> robj = re.search('a(\w)',"abcabccba")
>>> robj.span()
(0, 2)
>>> robj.span(1)
(1, 2)
"""
#MatchObject.pos #匹配的开始位置
#MatchObject.endpos #匹配的结束位置
#MatchObject.lastindex #返回组后匹配到的组的整数索引，如果没有匹配到，则返回None
"""
>>> robj = re.search('(a)(b)',"abcabccba") #最后匹配到的组是(b),所以是2
>>> robj.lastindex
2
>>> robj = re.search('(a)b',"abcabccba") #最后匹配到的组是(a),所以是1
>>> robj.lastindex
1
"""
#MatchObject.lastgroup #返回最后匹配到的组的组名。如果非命名组，或者没有匹配到则返回None
#MatchObject.re #返回产生这个MatchObject对象的正则表达式对象(regular expression object)
#MatchObject.string #返回产生这个MatchObject对象的字符串
"""
>>> robj = re.search('(a)b',"abcabccba")
>>> robj.re
<_sre.SRE_Pattern object at 0x00AF33E8>
>>> robj.string
'abcabccba'
"""
