Python re模塊詳解

轉自(http://blog.sina.com.cn/s/blog_a15aa56901017liq.html)

正則表達式的元字符有. ^ $ * ? { [ ] | ( )

.表示任意字符

[]用來匹配一個指定的字符類別,所謂的字符類別就是你想匹配的一個字符集,對於字符集中的字符可以理解成或的關係。

^ 如果放在字符串的開頭,則表示取非的意思。[^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()

 '^'

不過對於元字符”^”有這麼一個疑問.官方文檔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")

 ('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()  #找到即返回一個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,而是返回了一個疊代器

 

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


發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章