python 詳解re模塊

* 對於前一個字符重複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()
　'^'

不過對於元字符」^」有這麼一個疑問.官方文檔http://docs.python.org/library/re.html有關元字符」^」有這麼一句話，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來嘗試，能夠找到結果。因此這裏我理解之因此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),(?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 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<first_name>\w+) (?P<last_name>\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 "<pyshell#32>", line 1, in <module>

   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")#把默認改成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')#找到即返回一個match object
　>>> m.group()  ，#根據該對象的方法，查找匹配到的結果。
　'abcd'
　>>> m.start() #返回匹配到的第一個字母的index
　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，而是返回了一個疊代器

 

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