碼上歡樂
相關內容    簡體    繁體

python 詳解re模塊

本文轉載自   查看原文   2015-04-13 11:43   5281    Python

Python正則表達式指南

 

本文介紹了Python對於正則表達式的支持，包括正則表達式基礎以及Python正則表達式標准庫的完整介紹及使用示例。本文的內容不包括如何編寫高效的正則表達式、如何優化正則表達式，這些主題請查看其他教程。

注意：本文基於Python2.4完成；如果看到不明白的詞匯請記得百度谷歌或維基，whatever。

尊重作者的勞動，轉載請注明作者及原文地址 >.<html

1. 正則表達式基礎

1.1. 簡單介紹

正則表達式並不是Python的一部分。正則表達式是用於處理字符串的強大工具，擁有自己獨特的語法以及一個獨立的處理引擎，效率上可能不如str自帶的方法，但功能十分強大。得益於這一點，在提供了正則表達式的語言里，正則表達式的語法都是一樣的，區別只在於不同的編程語言實現支持的語法數量不同；但不用擔心，不被支持的語法通常是不常用的部分。如果已經在其他語言里使用過正則表達式，只需要簡單看一看就可以上手了。

下圖展示了使用正則表達式進行匹配的流程：    re_simple

正則表達式的大致匹配過程是：依次拿出表達式和文本中的字符比較，如果每一個字符都能匹配，則匹配成功；一旦有匹配不成功的字符則匹配失敗。如果表達式中有量詞或邊界，這個過程會稍微有一些不同，但也是很好理解的，看下圖中的示例以及自己多使用幾次就能明白。

下圖列出了Python支持的正則表達式元字符和語法：   pyre

1.2. 數量詞的貪婪模式與非貪婪模式

正則表達式通常用於在文本中查找匹配的字符串。Python里數量詞默認是貪婪的（在少數語言里也可能是默認非貪婪），總是嘗試匹配盡可能多的字符；非貪婪的則相反，總是嘗試匹配盡可能少的字符。例如：正則表達式"ab*"如果用於查找"abbbc"，將找到"abbb"。而如果使用非貪婪的數量詞"ab*?"，將找到"a"。

1.3. 反斜杠的困擾

與大多數編程語言相同，正則表達式里使用"\"作為轉義字符，這就可能造成反斜杠困擾。假如你需要匹配文本中的字符"\"，那么使用編程語言表示的正則表達式里將需要4個反斜杠"\\\\"：前兩個和后兩個分別用於在編程語言里轉義成反斜杠，轉換成兩個反斜杠后再在正則表達式里轉義成一個反斜杠。Python里的原生字符串很好地解決了這個問題，這個例子中的正則表達式可以使用r"\\"表示。同樣，匹配一個數字的"\\d"可以寫成r"\d"。有了原生字符串，你再也不用擔心是不是漏寫了反斜杠，寫出來的表達式也更直觀。

1.4. 匹配模式

正則表達式提供了一些可用的匹配模式，比如忽略大小寫、多行匹配等，這部分內容將在Pattern類的工廠方法re.compile(pattern[, flags])中一起介紹。

2. re模塊

2.1. 開始使用re

Python通過re模塊提供對正則表達式的支持。使用re的一般步驟是先將正則表達式的字符串形式編譯為Pattern實例，然后使用Pattern實例處理文本並獲得匹配結果（一個Match實例），最后使用Match實例獲得信息，進行其他的操作。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# encoding: UTF-8
import re
 
# 將正則表達式編譯成Pattern對象
pattern = re. compile (r 'hello' )
 
# 使用Pattern匹配文本，獲得匹配結果，無法匹配時將返回None
match = pattern.match( 'hello world!' )
 
if match:
    # 使用Match獲得分組信息
    print match.group()
 
### 輸出 ###
# hello

re.compile(strPattern[, flag]):

這個方法是Pattern類的工廠方法，用於將字符串形式的正則表達式編譯為Pattern對象。 第二個參數flag是匹配模式，取值可以使用按位或運算符'|'表示同時生效，比如re.I | re.M。另外，你也可以在regex字符串中指定模式，比如re.compile('pattern', re.I | re.M)與re.compile('(?im)pattern')是等價的。   可選值有：

  • re.I(re.IGNORECASE): 忽略大小寫（括號內是完整寫法，下同）
  • M(MULTILINE): 多行模式，改變'^'和'$'的行為（參見上圖）
  • S(DOTALL): 點任意匹配模式，改變'.'的行為
  • L(LOCALE): 使預定字符類 \w \W \b \B \s \S 取決於當前區域設定
  • U(UNICODE): 使預定字符類 \w \W \b \B \s \S \d \D 取決於unicode定義的字符屬性
  • X(VERBOSE): 詳細模式。這個模式下正則表達式可以是多行，忽略空白字符，並可以加入注釋。以下兩個正則表達式是等價的：
?
1
2
3
4
a = re. compile (r """\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""" , re.X)
b = re. compile (r "\d+\.\d*" )

re提供了眾多模塊方法用於完成正則表達式的功能。這些方法可以使用Pattern實例的相應方法替代，唯一的好處是少寫一行re.compile()代碼，但同時也無法復用編譯后的Pattern對象。這些方法將在Pattern類的實例方法部分一起介紹。如上面這個例子可以簡寫為：

?
1
2
m = re.match(r 'hello' , 'hello world!' )
print m.group()

re模塊還提供了一個方法escape(string)，用於將string中的正則表達式元字符如*/+/?等之前加上轉義符再返回，在需要大量匹配元字符時有那么一點用。

2.2. Match

Match對象是一次匹配的結果，包含了很多關於此次匹配的信息，可以使用Match提供的可讀屬性或方法來獲取這些信息。

屬性：

  1. string: 匹配時使用的文本。
  2. re: 匹配時使用的Pattern對象。
  3. pos: 文本中正則表達式開始搜索的索引。值與Pattern.match()和Pattern.seach()方法的同名參數相同。
  4. endpos: 文本中正則表達式結束搜索的索引。值與Pattern.match()和Pattern.seach()方法的同名參數相同。
  5. lastindex: 最后一個被捕獲的分組在文本中的索引。如果沒有被捕獲的分組，將為None。
  6. lastgroup: 最后一個被捕獲的分組的別名。如果這個分組沒有別名或者沒有被捕獲的分組，將為None。

方法：

  1. group([group1, …]): 獲得一個或多個分組截獲的字符串；指定多個參數時將以元組形式返回。group1可以使用編號也可以使用別名；編號0代表整個匹配的子串；不填寫參數時，返回group(0)；沒有截獲字符串的組返回None；截獲了多次的組返回最后一次截獲的子串。
  2. groups([default]): 以元組形式返回全部分組截獲的字符串。相當於調用group(1,2,…last)。default表示沒有截獲字符串的組以這個值替代，默認為None。
  3. groupdict([default]):       返回以有別名的組的別名為鍵、以該組截獲的子串為值的字典，沒有別名的組不包含在內。default含義同上。
  4. start([group]): 返回指定的組截獲的子串在string中的起始索引（子串第一個字符的索引）。group默認值為0。
  5. end([group]):       返回指定的組截獲的子串在string中的結束索引（子串最后一個字符的索引+1）。group默認值為0。
  6. span([group]):       返回(start(group), end(group))。
  7. expand(template): 將匹配到的分組代入template中然后返回。template中可以使用\id或\g<id>、\g<name>引用分組，但不能使用編號0。\id與\g<id>是等價的；但\10將被認為是第10個分組，如果你想表達\1之后是字符'0'，只能使用\g<1>0。
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import re
m = re.match(r '(\w+) (\w+)(?P<sign>.*)' , 'hello world!' )
 
print "m.string:" , m.string
print "m.re:" , m.re
print "m.pos:" , m.pos
print "m.endpos:" , m.endpos
print "m.lastindex:" , m.lastindex
print "m.lastgroup:" , m.lastgroup
 
print "m.group(1,2):" , m.group( 1 , 2 )
print "m.groups():" , m.groups()
print "m.groupdict():" , m.groupdict()
print "m.start(2):" , m.start( 2 )
print "m.end(2):" , m.end( 2 )
print "m.span(2):" , m.span( 2 )
print r "m.expand(r'\2 \1\3'):" , m.expand(r '\2 \1\3' )
 
### output ###
# m.string: hello world!
# m.re: <_sre.SRE_Pattern object at 0x016E1A38>
# m.pos: 0
# m.endpos: 12
# m.lastindex: 3
# m.lastgroup: sign
# m.group(1,2): ('hello', 'world')
# m.groups(): ('hello', 'world', '!')
# m.groupdict(): {'sign': '!'}
# m.start(2): 6
# m.end(2): 11
# m.span(2): (6, 11)
# m.expand(r'\2 \1\3'): world hello!

2.3. Pattern

Pattern對象是一個編譯好的正則表達式，通過Pattern提供的一系列方法可以對文本進行匹配查找。

Pattern不能直接實例化，必須使用re.compile()進行構造。

Pattern提供了幾個可讀屬性用於獲取表達式的相關信息：

  1. pattern: 編譯時用的表達式字符串。
  2. flags: 編譯時用的匹配模式。數字形式。
  3. groups: 表達式中分組的數量。
  4. groupindex: 以表達式中有別名的組的別名為鍵、以該組對應的編號為值的字典，沒有別名的組不包含在內。
?
1
2
3
4
5
6
7
8
9
10
11
12
13
import re
p = re. compile (r '(\w+) (\w+)(?P<sign>.*)' , re.DOTALL)
 
print "p.pattern:" , p.pattern
print "p.flags:" , p.flags
print "p.groups:" , p.groups
print "p.groupindex:" , p.groupindex
 
### output ###
# p.pattern: (\w+) (\w+)(?P<sign>.*)
# p.flags: 16
# p.groups: 3
# p.groupindex: {'sign': 3}

實例方法[ | re模塊方法]：

  1. match(string[, pos[, endpos]]) | re.match(pattern, string[, flags]):       這個方法將從string的pos下標處起嘗試匹配pattern；如果pattern結束時仍可匹配，則返回一個Match對象；如果匹配過程中pattern無法匹配，或者匹配未結束就已到達endpos，則返回None。     pos和endpos的默認值分別為0和len(string)；re.match()無法指定這兩個參數，參數flags用於編譯pattern時指定匹配模式。     注意：這個方法並不是完全匹配。當pattern結束時若string還有剩余字符，仍然視為成功。想要完全匹配，可以在表達式末尾加上邊界匹配符'$'。     示例參見2.1小節。
  2. search(string[, pos[, endpos]]) | re.search(pattern, string[, flags]):       這個方法用於查找字符串中可以匹配成功的子串。從string的pos下標處起嘗試匹配pattern，如果pattern結束時仍可匹配，則返回一個Match對象；若無法匹配，則將pos加1后重新嘗試匹配；直到pos=endpos時仍無法匹配則返回None。     pos和endpos的默認值分別為0和len(string))；re.search()無法指定這兩個參數，參數flags用於編譯pattern時指定匹配模式。    
    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    # encoding: UTF-8
    import re
     
    # 將正則表達式編譯成Pattern對象
    pattern = re. compile (r 'world' )
     
    # 使用search()查找匹配的子串，不存在能匹配的子串時將返回None
    # 這個例子中使用match()無法成功匹配
    match = pattern.search( 'hello world!' )
     
    if match:
        # 使用Match獲得分組信息
        print match.group()
     
    ### 輸出 ###
    # world
  3. split(string[, maxsplit]) | re.split(pattern, string[, maxsplit]):       按照能夠匹配的子串將string分割后返回列表。maxsplit用於指定最大分割次數，不指定將全部分割。    
    ?
    1
    2
    3
    4
    5
    6
    7
    import re
     
    p = re. compile (r '\d+' )
    print p.split( 'one1two2three3four4' )
     
    ### output ###
    # ['one', 'two', 'three', 'four', '']
  4. findall(string[, pos[, endpos]]) | re.findall(pattern, string[, flags]):       搜索string，以列表形式返回全部能匹配的子串。    
    ?
    1
    2
    3
    4
    5
    6
    7
    import re
     
    p = re. compile (r '\d+' )
    print p.findall( 'one1two2three3four4' )
     
    ### output ###
    # ['1', '2', '3', '4']
  5. finditer(string[, pos[, endpos]]) | re.finditer(pattern, string[, flags]):       搜索string，返回一個順序訪問每一個匹配結果（Match對象）的迭代器。    
    ?
    1
    2
    3
    4
    5
    6
    7
    8
    import re
     
    p = re. compile (r '\d+' )
    for m in p.finditer( 'one1two2three3four4' ):
        print m.group(),
     
    ### output ###
    # 1 2 3 4
  6. sub(repl, string[, count]) | re.sub(pattern, repl, string[, count]):       使用repl替換string中每一個匹配的子串后返回替換后的字符串。     當repl是一個字符串時，可以使用\id或\g<id>、\g<name>引用分組，但不能使用編號0。     當repl是一個方法時，這個方法應當只接受一個參數（Match對象），並返回一個字符串用於替換（返回的字符串中不能再引用分組）。     count用於指定最多替換次數，不指定時全部替換。    
    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    import re
     
    p = re. compile (r '(\w+) (\w+)' )
    s = 'i say, hello world!'
     
    print p.sub(r '\2 \1' , s)
     
    def func(m):
        return m.group( 1 ).title() + ' ' + m.group( 2 ).title()
     
    print p.sub(func, s)
     
    ### output ###
    # say i, world hello!
    # I Say, Hello World!
  7. subn(repl, string[, count]) |re.sub(pattern, repl, string[, count]):       返回 (sub(repl, string[, count]), 替換次數)。    
    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    import re
     
    p = re. compile (r '(\w+) (\w+)' )
    s = 'i say, hello world!'
     
    print p.subn(r '\2 \1' , s)
     
    def func(m):
        return m.group( 1 ).title() + ' ' + m.group( 2 ).title()
     
    print p.subn(func, s)
     
    ### output ###
    # ('say i, world hello!', 2)
    # ('I Say, Hello World!', 2)

以上就是Python對於正則表達式的支持。熟練掌握正則表達式是每一個程序員必須具備的技能，這年頭沒有不與字符串打交道的程序了。筆者也處於初級階段，與君共勉，^_^

另外，圖中的特殊構造部分沒有舉出例子，用到這些的正則表達式是具有一定難度的。有興趣可以思考一下，如何匹配不是以abc開頭的單詞，^_^

 

正則表達式 re模塊

hejiasheng 於 2014-02-10 07:00:17+00:00 更新 訪問次數：1547

Regular Expression、regex或regexp，（縮寫為RE） 是指一個用來描述或者匹配一系列符合某個句法規則的字符串的單個字符串。

計算機里處理文本和數據是非常重要的事情。

一般匹配規則：

1 字符串匹配

"abcd" 這種是沒有特殊規則，就是完全按照 字符去匹配。 例如："hello，abcd" 可以匹配。 "hello,abc" 匹配不上。

  1. >>> import re
  2. >>> re.search("abcd","hello,abcd")
  3. <_sre.SRE_Match object at 0x994e2c0>
  4. >>> re.search("abcd","hello,abdc")

2 選擇匹配 gray|grey ,“gray” 和"grey " 都能匹配上。 或者用 gr(a|e)y 規則來匹配后面2個單詞 "gray","grey"。

  1. >>> print re.search("gray|grey","gray")
  2. <_sre.SRE_Match object at 0x994e2c0>
  3. >>> print re.search("gray|grey","grey")
  4. <_sre.SRE_Match object at 0x994e2c0>
  5. >>> print re.search("gray|grey","grcy")
  6. None
  7. >>> print re.search("gr(a|e)y","gray")
  8. <_sre.SRE_Match object at 0xb77268a0>

3 數量限定

  1. ‘+’ 加號代表前面的字符必須至少出現一次。(1次、或多次)。例如，“goo+gle”可以匹配google、gooogle、goooogle等;
  3. ? 問號代表前面的字符最多只可以出現一次。(0次、或1次)。例如，“colou?r”可以匹配color或者colour;
  5. ‘*’ 星號代表前面的字符可以不出現，也可以出現一次或者多次。(0次、或1次、或多次)。例如，“0*42” 可以匹配42、042、0042、00042等。
  1. >>> re.search("goo+gle","google")
  2. <_sre.SRE_Match object at 0xb7717e20>
  3. >>> re.search("goo+gle", "gogle")
  4. >>> re.search("goo+gle", "goooogle")
  5. <_sre.SRE_Match object at 0x994e2c0>

“？” 例子

  1. >>> re.search("colou?r","color")
  2. <_sre.SRE_Match object at 0xb7717e20>
  3. >>> re.search("colou?r","colour")
  4. <_sre.SRE_Match object at 0x994e2c0>
  5. >>> re.search("colou?r","colouur")
  6. >>> #對比 "+"
  7. >>> re.search("colou+r","colouur")
  8. <_sre.SRE_Match object at 0xb7717e20>
  9. >>> re.search("colou+r","color")

“*” 例子:

  1. >>> re.search("goo*gle","google")
  2. <_sre.SRE_Match object at 0xb7717e20>
  3. >>> re.search("goo*gle","gooogle")
  4. <_sre.SRE_Match object at 0x994e2c0>

4 [...] 括號里面包含的任意字符

b[aeou]d 匹配"bad","bed","bod","bud"

  1. >>> re.search("b[aeoud]d","bad")
  2. <_sre.SRE_Match object at 0x994e2c0>
  3. >>> re.search("b[aeoud]d","bed")
  4. <_sre.SRE_Match object at 0xb7717e20>
  5. >>> re.search("b[aeoud]d","bud")
  6. <_sre.SRE_Match object at 0x994e2c0>
  7. >>> re.search("b[aeoud]d","bcd")
  8. >>> re.search("b[aeoud]d","baed")

匹配 [0-9],[0-9a-z]

  1. >>> re.search('b[0-9a-z]d',"b12d")
  2. >>> re.search('b[0-9a-z]d',"b1d")
  3. <_sre.SRE_Match object at 0xb7717e20>
  4. >>> re.search('b[0-9a-z]d',"bad")
  5. <_sre.SRE_Match object at 0x994e2c0>

5 多字符匹配 {n}

[0-9]{3} ： []以內的字母、數字在后面字符串中出現的次數。 “hd543”,符合規則。 "hello32rew",不符合規則。

  1. >>> re.search("[0-9]{3}","hd23")
  2. >>> re.search("[0-9]{3}","hd232")
  3. <_sre.SRE_Match object at 0x92ec2c0>
  4. >>> re.search("[0-9]{3}","hd234")
  5. <_sre.SRE_Match object at 0xb77bee20>
  6. >>>
  7. >>> re.search("[0-9]{4}","hd234")
  8. >>> re.search("[0-9d]{4}","hd234")
  9. <_sre.SRE_Match object at 0x92ec2c0>

6. []{m,n}, 按照[]內規則匹配 m---n之間個數，m必須小於n。

7 "." 匹配任何1個字符。

  1. >>> import re
  2. >>> re.search('b.b',"beb")
  3. <_sre.SRE_Match object at 0xb7280170>
  4. >>> re.search('b.b',"bab")
  5. <_sre.SRE_Match object at 0xb7280368>
  6. >>> re.search('b.b',"badb")
  7. >>> re.search('b..b',"badb")
  8. <_sre.SRE_Match object at 0xb7280170>
  9. >>>

8 “^” 匹配字符串的開始

  1. >>> re.search('^bad',"badb")
  2. <_sre.SRE_Match object at 0xb7280368>
  3. >>> re.search('^ad',"badb")
  4. >>> re.search('^.ad',"badb")
  5. <_sre.SRE_Match object at 0xb7280170>
  6. >>> re.search('^..ad',"badb")
  7. >>>

9

"$" 匹配字符串的結尾

  1. >>> re.search('adb$',"badb")
  2. <_sre.SRE_Match object at 0xb7280170>
  3. >>> re.search('.db$',"badb")
  4. <_sre.SRE_Match object at 0xb7280368>

10

  1. '\d' 匹配數字
  2. ‘\D' 匹配非數字
  1. >>> re.search('\d',"badec3b2v432")
  2. <_sre.SRE_Match object at 0xb7280368>
  3. >>> re.search('\D',"badec3b2v432")
  4. <_sre.SRE_Match object at 0xb7280170>
  5. >>>

11

  1. '\w' 匹配任意數字和字母
  2. '\W' 非數字和字母

12

  1. '\s' 匹配任意空白字符，相當於 [ \t\n\r\f\v]
  2. \S 匹配任意非空白字符，相當於 [^ \t\n\r\f\v]

使用方法

A)

  1. compiled_pattern = re.compile(pattern)
  2. result = compiled_pattern.match(string)

B)

  1. result = re.match(pattern, string)

pattern,就是上面提到的規則。

除了match，以為還有幾個函數，我們一起做說明: match() 函數只在字符串的開始位置嘗試匹配正則表達式，也就是只報告從位置 0 開始的匹配情況。

search() 函數是掃描整個字符串來查找匹配。如果想要搜索整個字符串來尋找匹配，應當用 search()。 但search 返回第一個匹配的字符串。

split() 將字符串按照規則分成list。如果按照規則里面找不到，就不分割，返回原字符串。

  1. >>> re.split(":","test:test1:test2")
  2. ['test', 'test1', 'test2']

findall（） 函數搜索整個字符串，返回所有匹配項。返回一個list。

sub() 函數 查找並替換

  1. >>> re.sub("one","num","one world, on dream",1)
  2. 'num world, on dream'
  3. >>> re.sub("one","num","one world, one dream",1)
  4. 'num world, one dream'
  5. >>> re.sub("one","num","one world, one dream",2)
  6. 'num world, num dream'
  7. >>>

可以：

  1. >>> p = re.compile( '(one|two|three)')
  2. >>> p.sub( 'num', 'one word two words three words')
  3. 'num word num words num words'

匹配網址的實例：

  1. #coding=utf-8
  2. import re
  3. urls=r'fdsa<a class="pic" href= "http://www.jeapedu.com ">... </a> '
  4. s = re.findall("<a.*href.*>",urls)
  5. print s

非貪婪匹配 + 后結束標記

  1. all_buf = re.findall(r'<a.*?href.*?=(.*?)[> ]',buf)
  2. for n in all_buf:
  3. print n

簡單匹配 @ 后面的用戶正則

  1. #s = "@fdsa;1232"
  2. s = "fdsfds@fdsa你好.1, 232"
  3. a = re.findall("""@(.*?)(?=[;,| '".?])""",s)
  4. print a[0]

如果@后面沒有任何特殊符號，就結束了匹配方法，加了$：

  1. >>> a= re.compile("@(.*?)(?=[ ,'$]|$)")
  2. >>> print a.findall("@sina @abd, @fds")

其他正則表達式參考網址 http://www.cnblogs.com/huxi/archive/2010/07/04/1771073.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


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 python re模塊findall()詳解 re模塊詳解 re模塊詳解 Python中的Re模塊 python re模塊 Python re模塊學習 python re 模塊 python re模塊 Python之re正則模塊 python3 re模塊
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM