python 詳解re模組

正規表示式的元字元有. ^ $ * ? { [ ] | ( )
．表示任意字元
〔〕用來匹配一個指定的字元類別，所謂的字元類別就是你想匹配的一個字符集，對於字符集中的字元可以理解成或的關係。
^ 如果放在字串的開頭，則表示取非的意思。[^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，regex pattens)是一個小巧的，高度專業化的程式語言，它內嵌於python開發語言中，可透過re模組使用。正規表示式的
pattern可以被編譯成一系列的位元組碼，然後用C編寫的引擎執行。下面簡單介紹下正規表示式的語法
     正規表示式包含一個元字元(metacharacter)的列表，列表值如下:    . ^ $ * + ? { [ ] \ | ( )
　   1.元字元([ ]),它用來指定一個character class。所謂character classes就是你想要匹配的字元(character)的集合.字元(character)可以單個的列出，也可以透過"-"來分隔兩個字元來表示一 個範圍。例如，[abc]匹配a，b或者c當中任意一個字元，[abc]也可以用字元區間來表示---[a-c].如果想要匹配單個大寫字母，你可以用 [A-Z]。
     元字元(metacharacters)在character class裡面不起作用，如[akm$]將匹配"a","k","m","$"中的任意一個字元。在這裡元字元(metacharacter)"$"就是一個普通字元。
     2.元字元[^]. 你可以用補集來匹配不在區間範圍內的字元。其做法是把"^"作為類別的首個字元；其它地方的"^"只會簡單匹配 "^"字元本身。例如，[^5] 將匹配除 "5" 之外的任意字元。同時，在[ ]外，元字元^表示匹配字串的開始，如"^ab+"表示以ab開頭的字串。
    舉例驗證，
    >>> m=re.search("^ab+","asdfabbbb")
　 >>> print m
    None
    >>> m=re.search("ab+","asdfabbbb")
    >>> print m
    <_sre.SRE_Match object 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 at 0x011B19F8>
　>>> m=re.search("[^abc]","abcd")
　>>> m.group()
　'd'
　>>> m=re.search("[abc^]","^")  #如果"^"在[ ]中不是首字元，那麼那就是一個普通字元
　>>> m.group()
　'^'
不過對於元字元”^”有這麼一個疑問.官方文件有關元字元”^”有這麼一句話，Matches the start
of the string, and in MULTILINE mode also 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來嘗試，可以找到結果，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 at 0x00A27170>
　　>>> 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),(?PREs),這是無名稱的組和有名稱的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 at 0x00C2CE20>
　>>> 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\w+) (?P\w+)","sam lee")
　>>> 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 "", line 1, in
   m.group(1)
　IndexError: no such group
 
　If a group matches multiple times, only the last match is accessible:
   如果一個組匹配多個，那麼僅僅返回匹配的最後一個的。
　>>> 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 at 0x00C2FDA0>
　>>> 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\w+) (?P\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()  #找到即返回一個match object，然後根據該物件的方法，查詢匹配到的結果。
　'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 is scanned left-to-right, and matches are returned in the order found. 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 unless they touch 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，而是返回了一個疊代器
 
re.sub

1. >>> import re  
2. >>> re.search('[abc]', 'Mark')     
3. <_sre.SRE_Match object at 0x001C1FA8>  
4. >>> re.sub('[abc]', 'o', 'Mark')   
5. 'Mork'  
6. >>> re.sub('[abc]', 'o', 'rock')   
7. 'rook'  
8. >>> re.sub('[abc]', 'o', 'caps')   
9. 'oops' 

好的，現在找出 a，b，或者 c 並以 o 取代之。Mark 就變成 Mork 了。

 　我們來看一個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


原文連結：