正則表達式的元字符有. ^ $ * ? {[ ] | ( )
．表示任意字符
［］用來匹配一個指定的字符類別，所謂的字符類別就是你想匹配的一個字符集，對於字符集中的字符可以理解成或的關係。
^ 如果放在字符串的開頭，則表示取非的意思。[^5]表示除了5之外的其他字符。而如果^不在字符串的開頭，則表示它本身。
具有重複功能的元字符：
* 對於前一個字符重複0到無窮次
對於前一個字符重複1到無窮次
？對於前一個字符重複0到1次
{m,n} 對於前一個字符重複次數在爲m到n次，其中，{0,} = *,{1,} = , {0,1} = ?
{m} 對於前一個字符重複m次
\d 匹配任何十進制數；它相當於類 [0-9]。
\D 匹配任何非數字字符；它相當於類 [^0-9]。
\s 匹配任何空白字符；它相當於類 [ fv]。
\S 匹配任何非空白字符；它相當於類 [^ fv]。
\w 匹配任何字母數字字符；它相當於類 [a-zA-Z0-9_]。
\W 匹配任何非字母數字字符；它相當於類 [^a-zA-Z0-9_]。
正則表達式(可以稱爲REs，regex，regexpattens)是一個小巧的，高度專業化的編程語言，它內嵌於python開發語言中，可通過re模塊使用。正則表達式的
pattern可以被編譯成一系列的字節碼，然後用C編寫的引擎執行。下面簡單介紹下正則表達式的語法
正則表達式包含一個元字符(metacharacter)的列表，列表值如下: . ^ $ * + ? { [ ] \ | ( )
1.元字符([ ]),它用來指定一個characterclass。所謂characterclasses就是你想要匹配的字符(character)的集合.字符(character)可以單個的列出，也可以通過"-"來分隔兩個字符來表示一個範圍。例如，[abc]匹配a，b或者c當中任意一個字符，[abc]也可以用字符區間來表示---[a-c].如果想要匹配單個大寫字母，你可以用[A-Z]。
元字符(metacharacters)在characterclass裏面不起作用，如[akm$]將匹配"a","k","m","$"中的任意一個字符。在這裏元字符(metacharacter)"$"就是一個普通字符。
2.元字符[^]. 你可以用補集來匹配不在區間範圍內的字符。其做法是把"^"作爲類別的首個字符；其它地方的"^"只會簡單匹配"^"字符本身。例如，[^5] 將匹配除 "5" 之外的任意字符。同時，在[]外，元字符^表示匹配字符串的開始，如"^ab+"表示以ab開頭的字符串。
舉例驗證，
>>>m=re.search("^ab+","asdfabbbb")
>>> printm
None
>>>m=re.search("ab+","asdfabbbb")
>>>print
m
<_sre.SRE_Matchobject
at 0x011B1988>
>>>print
m.group()
abbbb
上例不能用re.match,因爲match匹配字符串的開始，我們無法驗證元字符"^"是否代表字符串的開始位置。
>>>m=re.match("^ab+","asdfabbbb")
>>> print m
None
>>>m=re.match("ab+","asdfabbbb")
>>> print m
None
#驗證在元字符[]中，"^"在不同位置所代表的意義。
>>>re.search("[^abc]","abcd") #"^"在首字符表示取反，即abc之外的任意字符。
<_sre.SRE_Match object at0x011B19F8>
>>>m=re.search("[^abc]","abcd")
>>>m.group()
'd'
>>>m=re.search("[abc^]","^") #如果"^"在[]中不是首字符，那麼那就是一個普通字符
>>>m.group()
'^'
不過對於元字符”^”有這麼一個疑問.官方文檔http://docs.python.org/library/re.html有關元字符”^”有這麼一句話，Matchesthe start
of the string, and in MULTILINE modealso matches immediately after each newline.
我理解的是”^”匹配字符串的開始，在MULTILINE模式下，也匹配換行符之後。
>>>m=re.search("^a\w+","abcdfa\na1b2c3")
>>> m.group()
'abcdfa'
>>>m=re.search("^a\w+","abcdfa\na1b2c3",re.MULTILINE)，
>>>m.group() #
'abcdfa'
我認爲flag設定爲re.MULTILINE，根據上面那段話，他也應該匹配換行符之後，所以應該有m.group應該有"a1b2c3",但是結果沒有，用findall來嘗試，可以找到結果。所以這裏我理解之所以group裏面沒有，是因爲search和match方法是匹配到就返回，而不是去匹配所有。
>>>m=re.findall("^a\w+","abcdfa\na1b2c3",re.MULTILINE)
>>>m
['abcdfa', 'a1b2c3']
3.元字符(\),元字符backslash。做爲 Python 中的字符串字母，反斜槓後面可以加不同的字符以表示不同特殊意義。
它也可以用於取消所有的元字符，這樣你就可以在模式中匹配它們了。例如，如果你需要匹配字符 "[" 或 "\"，你可以在它們之前用反斜槓來取消它們的特殊意義： \[ 或\\
4。元字符($)匹配字符串的結尾或者字符串結尾的換行之前。（在MULTILINE模式下，"$"也匹配換行之前）
正則表達式"foo"既匹配"foo"又匹配"foobar",而"foo$"僅僅匹配"foo".
>>>re.findall("foo.$","foo1\nfoo2\n")#匹配字符串的結尾的換行符之前。
['foo2']
>>>re.findall("foo.$","foo1\nfoo2\n",re.MULTILINE)
['foo1',
'foo2']
>>>m=re.search("foo.$","foo1\nfoo2\n")
>>> m
<_sre.SRE_Match object at0x00A27170>
>>>m.group()
'foo2'
>>>m=re.search("foo.$","foo1\nfoo2\n",re.MULTILINE)
>>>m.group()
'foo1'
看來re.MULTILINE對$的影響還是蠻大的。
5.元字符(*),匹配0個或多個
6.元字符(?)，匹配一個或者0個
7.元字符(+),
匹配一個或者多個
8,元字符(|),表示"或"，如A|B，其中A，B爲正則表達式，表示匹配A或者B
9.元字符({})
{m},用來表示前面正則表達式的m次copy，如"a{5}"，表示匹配5個”a”,即"aaaaa"
>>>re.findall("a{5}","aaaaaaaaaa")
['aaaaa', 'aaaaa']
>>>re.findall("a{5}","aaaaaaaaa")
['aaaaa']
{m.n}用來表示前面正則表達式的m到n次copy,嘗試匹配儘可能多的copy。
>>>re.findall("a{2,4}","aaaaaaaa")
['aaaa', 'aaaa']
通過上面的例子，可以看到{m,n}，正則表達式優先匹配n，而不是m，因爲結果不是["aa","aa","aa","aa"]
>>>re.findall("a{2}","aaaaaaaa")
['aa', 'aa', 'aa', 'aa']
{m,n}? 用來表示前面正則表達式的m到n次copy，嘗試匹配儘可能少的copy
>>>re.findall("a{2,4}?","aaaaaaaa")
['aa', 'aa', 'aa', 'aa']
10。元字符( "()" ),用來表示一個group的開始和結束。
比較常用的有(REs),(?P<name>REs),這是無名稱的組和有名稱的group，有名稱的group，可以通過matchObject.group(name)
獲取匹配的group，而無名稱的group可以通過從1開始的group序號來獲取匹配的組，如matchObject.group(1)。具體應用將在下面的group()方法中舉例講解
11．元字符(.)
元字符“.”在默認模式下，匹配除換行符外的所有字符。在DOTALL模式下，匹配所有字符，包括換行符。
>>>import re
>>>re.match(".","\n")
>>>m=re.match(".","\n")
>>>print m
None
>>>m=re.match(".","\n",re.DOTALL)
>>>print m
<_sre.SRE_Match object at0x00C2CE20>
>>>m.group()
'\n'
下面我們首先來看一下Match Object對象擁有的方法,下面是常用的幾個方法的簡單介紹
1.group([group1,…])
返回匹配到的一個或者多個子組。如果是一個參數，那麼結果就是一個字符串，如果是多個參數，那麼結果就是一個參數一個item的元組。group1的默認值爲0(將返回所有的匹配值).如果groupN參數爲0，相對應的返回值就是全部匹配的字符串，如果group1的值是[1…99]範圍之內的,那麼將匹配對應括號組的字符串。如果組號是負的或者比pattern中定義的組號大，那麼將拋出IndexError異常。如果pattern沒有匹配到，但是group匹配到了，那麼group的值也爲None。如果一個pattern可以匹配多個，那麼組對應的是樣式匹配的最後一個。另外，子組是根據括號從左向右來進行區分的。
>>> m=re.match("(\w+)(\w+)","abcd efgh, chaj")
>>>m.group() # 匹配全部
'abcd efgh'
>>>m.group(1) # 第一個括號的子組.
'abcd'
>>> m.group(2)
'efgh'
>>>m.group(1,2) # 多個參數返回一個元組
('abcd', 'efgh')
>>>m=re.match("(?P<first_name>\w+)(?P<last_name>\w+)","samlee")
>>>m.group("first_name") #使用group獲取含有name的子組
'sam'
>>>m.group("last_name")
'lee'
下面把括號去掉
>>> m=re.match("\w+\w+","abcd efgh, chaj")
>>> m.group()
'abcd efgh'
>>> m.group(1)
Traceback (most recent call last):
File"<pyshell#32>", line 1, in<module>
m.group(1)
IndexError: no such group
If a group matches multiple times, only the last match isaccessible:
如果一個組匹配多個，那麼僅僅返回匹配的最後一個的。
>>>m=re.match(r"(..)+","a1b2c3")
>>> m.group(1)
'c3'
>>> m.group()
'a1b2c3'
Group的默認值爲0，返回正則表達式pattern匹配到的字符串
>>>s="afkak1aafal12345adadsfa"
>>>pattern=r"(\d)\w+(\d{2})\w"
>>>m=re.match(pattern,s)
>>> print m
None
>>>m=re.search(pattern,s)
>>> m
<_sre.SRE_Match object at0x00C2FDA0>
>>> m.group()
'1aafal12345a'
>>> m.group(1)
'1'
>>> m.group(2)
'45'
>>>m.group(1,2,0)
('1', '45', '1aafal12345a')
2。groups([default])
返回一個包含所有子組的元組。Default是用來設置沒有匹配到組的默認值的。Default默認是"None”,
>>>m=re.match("(\d+)\.(\d+)","23.123")
>>> m.groups()
('23', '123')
>>>m=re.match("(\d+)\.?(\d+)?","24") #這裏的第二個\d沒有匹配到，使用默認值"None"
>>> m.groups()
('24', None)
>>> m.groups("0")
('24', '0')
3.groupdict([default])
返回匹配到的所有命名子組的字典。Key是name值，value是匹配到的值。參數default是沒有匹配到的子組的默認值。這裏與groups()方法的參數是一樣的。默認值爲None
>>> m=re.match("(\w+)(\w+)","hello world")
>>> m.groupdict()
{}
>>>m=re.match("(?P<first>\w+)(?P<secode>\w+)","hello world")
>>> m.groupdict()
{'secode': 'world', 'first': 'hello'}
通過上例可以看出，groupdict()對沒有name的子組不起作用
正則表達式對象
re.search(string[, pos[, endpos]])
掃描字符串string，查找與正則表達式匹配的位置。如果找到一個匹配就返回一個MatchObject對象(並不會匹配所有的)。如果沒有找到那麼返回None。
第二個參數表示從字符串的那個位置開始，默認是0
第三個參數endpos限定字符串最遠被查找到哪裏。默認值就是字符串的長度。.
>>>m=re.search("abcd", '1abcd2abcd')
>>>m.group() #找到即返回一個matchobject，然後根據該對象的方法，查找匹配到的結果。
'abcd'
>>>m.start()
1
>>> m.end()
5
>>>re.findall("abcd","1abcd2abcd")
['abcd', 'abcd']
re.split(pattern, string[, maxsplit=0, flags=0])
用pattern來拆分string。如果pattern有含有括號，那麼在pattern中所有的組也會返回。
>>>re.split("\W+","words,words,works",1)
['words', 'words,works']
>>>re.split("[a-z]","0A3b9z",re.IGNORECASE)
['0A3', '9', '']
>>>re.split("[a-z]+","0A3b9z",re.IGNORECASE)
['0A3', '9', '']
>>>re.split("[a-zA-Z]+","0A3b9z")
['0', '3', '9', '']
>>>re.split('[a-f]+', '0a3B9',re.IGNORECASE)#re.IGNORECASE用來忽略pattern中的大小寫。
['0', '3B9']
如果在split的時候捕獲了組，並且匹配字符串的開始，那麼返回的結果將會以一個空串開始。
>>> re.split('(\W+)','...words, words...')
['', '...', 'words', ', ', 'words', '...', '']
>>> re.split('(\W+)','words, words...')
['words', ', ', 'words', '...', '']
re.findall(pattern, string[, flags])
以list的形式返回string中所有與pattern匹配的不重疊的字符串。String從左向右掃描，匹配的返回結果也是以這個順序。
Return all non-overlapping matches of pattern in string,as a list of strings. The string isscanned left-to-right, and matches are returned in the order found.If one or more groups are present in the pattern, return a list ofgroups; this will be a list of tuples if the pattern has more thanone group. Empty matches are included in the result unless theytouch the beginning of another match.
>>>re.findall('(\W+)', 'words, words...')
[', ', '...']
>>>re.findall('(\W+)d', 'words, words...d')
['...']
>>>re.findall('(\W+)d', '...dwords, words...d')
['...', '...']
re.finditer(pattern, string[, flags])
與findall類似，只不過是返回list，而是返回了一個疊代器
我們來看一個sub和subn的例子
>>>re.sub("\d","abc1def2hijk","RE")
'RE'
>>>x=re.sub("\d","abc1def2hijk","RE")
>>> x
'RE'
>>>re.sub("\d","RE","abc1def2hijk",)
'abcREdefREhijk'
>>>re.subn("\d","RE","abc1def2hijk",)
('abcREdefREhijk', 2)
通過例子我們可以看出sub和subn的差別：sub返回替換後的字符串，而subn返回由替換後的字符串以及替換的個數組成的元組。
re.sub(pattern, repl, string[, count, flags])
用repl替換字符串string中的pattern。如果pattern沒有匹配到，那麼返回的字符串沒有變化]。Repl可以是一個字符串，也可以是一個function。如果是字符串，如果repl是個方法/函數。對於所有的pattern匹配到。他都回調用這個方法/函數。這個函數和方法使用單個match object作爲參數，然後返回替換後的字符串。下面是官網提供的例子:
>>> def dashrepl(matchobj):
... if matchobj.group(0) == '-': return ' '
... else: retu