[轉載]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")

    None

#驗證在元字元[]中，"^"在不同位置所代表的意義。

　>>>

re.search("[^abc]","abcd") 

#"^"在首字元表示取反，即abc之外的任意字元。

　<_sre.SRE_Match object at

0x011B19F8>

m=re.search("[^abc]","abcd")

m.group()

　'd'

m=re.search("[abc^]","^")  #如果"^"在[

]中不是首字元，那麼那就是一個普通字元

　'^'

the start

also matches immediately after each newline.

我了解的是”^”比對字元串的開始，在MULTILINE模式下，也比對換行符之後。

m=re.search("^aw+","abcdfana1b2c3")

>>> m.group()

　'abcdfa'

m=re.search("^aw+","abcdfana1b2c3",re.MULTILINE)，

m.group()  #

我

認為flag設定為re.MULTILINE，根據上面那段話，他也應該比對換行符之後，是以應該有m.group應該有"a1b2c3",但是結果沒

有，用findall來嘗試，可以找到結果。是以這裡我了解之是以group裡面沒有，是因為search和match方法是比對到就傳回，而不是去比對

所有。

m=re.findall("^aw+","abcdfana1b2c3",re.MULTILINE)

　['abcdfa', 'a1b2c3']

   3.

元字元(),元字元backslash。做為 Python 中的字元串字母，反斜杠後面可以加不同的字元以表示不同特殊意義。

   它也可以用于取消所有的元字元，這樣你

就可以在模式中比對它們了。例如，如果你需要比對字元 "[" 或 ""，你可以在它們之前用反斜杠來取消它們的特殊意義： [ 或

\

   4。元字元($)比對字元串的結尾或者字元串結尾的換行之前。（在MULTILINE模式下，"$"也比對換行之前）

   正規表達式"foo"既比對"foo"又比對"foobar",而"foo$"僅僅比對"foo".

　　

　 

re.findall("foo.$","foo1nfoo2n")#比對字元串的結尾的換行符之前。

['foo2']

re.findall("foo.$","foo1nfoo2n",re.MULTILINE)

['foo1', 'foo2']

　　>>>

m=re.search("foo.$","foo1nfoo2n")

　　>>> m

　　<_sre.SRE_Match object at

0x00A27170>

　　'foo2'

m=re.search("foo.$","foo1nfoo2n",re.MULTILINE)

　　'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")

   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")

　None

m=re.match(".","n",re.DOTALL)

0x00C2CE20>

　'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()

　>>> 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")

　'c3'

　'a1b2c3'

　Group的預設值為0，傳回正規表達式pattern比對到的字元串

s="afkak1aafal12345adadsfa"

pattern=r"(d)w+(d{2})w"

m=re.match(pattern,s)

　>>> print m

m=re.search(pattern,s)

　>>> m

0x00C2FDA0>

　'1aafal12345a'

　'1'

　'45'

m.group(1,2,0)

　('1', '45', '1aafal12345a')

<b></b>

　2。groups([default])

　傳回一個包含所有子組的元組。Default是用來設定沒有比對到組的預設值的。Default預設是"None”,

m=re.match("(d+).(d+)","23.123")

　&gt;&gt;&gt; m.groups()

　('23', '123')

m=re.match("(d+).?(d+)?","24") #這裡的第二個d沒有比對到，使用預設值"None"

　('24', None)

　&gt;&gt;&gt; m.groups("0")

　('24', '0')

　3.groupdict([default])

　傳回比對到的所有命名子組的字典。Key是name值，value是比對到的值。參數default是沒有比對到的子組的預設值。這裡與groups()方法的參數是一樣的。預設值為None

(w+)","hello world")

　&gt;&gt;&gt; m.groupdict()

　{}

m=re.match("(?P&lt;first&gt;w+)

(?P&lt;secode&gt;w+)","hello world")

　{'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，然後根據該對象的方法，查找比對到的結果。

m.start()

　1

　&gt;&gt;&gt; m.end()

　5

re.findall("abcd","1abcd2abcd")

　['abcd', 'abcd']

　re.<b>split</b>(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)

re.split("[a-zA-Z]+","0A3b9z")

　['0', '3', '9', '']

re.split('[a-f]+', '0a3B9',

re.IGNORECASE)#re.IGNORECASE用來忽略pattern中的大小寫。

　['0', '3B9']

　如果在split的時候捕獲了組，并且比對字元串的開始，那麼傳回的結果将會以一個空串開始。

　&gt;&gt;&gt; re.split('(W+)',

'...words, words...')

　['', '...', 'words', ', ', 'words', '...', '']

'words, words...')

　['words', ', ', 'words', '...', '']

　re.<b>findall</b>(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.<b>finditer</b>(pattern, string[, flags])

　與findall類似，隻不過是傳回list，而是傳回了一個疊代器

 　我們來看一個sub和subn的例子

re.sub("d","abc1def2hijk","RE")

　'RE'

x=re.sub("d","abc1def2hijk","RE")

　&gt;&gt;&gt; x

re.sub("d","RE","abc1def2hijk",)

　'abcREdefREhijk'

re.subn("d","RE","abc1def2hijk",)

　('abcREdefREhijk', 2)

　通過例子我們可以看出sub和subn的差别：sub傳回替換後的字元串，而subn傳回由替換後的字元串以及替換的個數組成的元組。

　re.<b>sub</b>(pattern, repl, string[, count, flags])

用repl替換字元串string中的pattern。如果pattern沒有比對到，那麼傳回的字元串沒有變化]。Repl可以是一個字元串，也可以是

一個function。如果是字元串，如果repl是個方法/函數。對于所有的pattern比對到。他都回調用這個方法/函數。這個函數和方法使用單個

match object作為參數，然後傳回替換後的字元串。下面是官網提供的例子: