python中re模塊的使用（正則表達式）

1、什麼是正則表達式？

• 正則表達式，又稱規則表達式，一般被用來檢索、替換那些符合某個模式(規則)的文本。
• 正則表達式是對字符串操做的一種邏輯公式，就是用事先定義好的一些特定字符、及這些特定字符的組合，組成一個「規則字符串」，這個「規則字符串」用來表達對字符串的一種過濾邏輯。

2、正則表達式的匹配規則

1.表示字符

• ·：匹配任意除換行符'\n'外的字符，可是在DOTALL模式中也能夠匹配換行符'\n'
• \：轉義字符，使後一個字符改變原來的意思，若是字符串中想匹配*，能夠使用\*，也能夠使用字符集[*]
• [...]：字符集，匹配字符集中列出的任意字符。字符能夠逐個列出，也能夠給出範圍，好比[a-z]，[0-9]，第一個字符是^表示取反。全部特殊字符在字符集中都失去其原有的特殊含義。若是想使用']','-'或者'^'，能夠在前面加上\，或者將]或者-放在首位，將^放在非首位

2.預約義字符集（可寫在字符集[]中）

• \d：數字[0-9]
• \D：非數字[^0-9]
• \s：空白字符[<空格>，\t,\n,\r,\f,\v]
• \S：非空白字符[^\s]
• \w：單詞字符[a-zA-Z0-9_]
• \W：非單詞字符[^\w]

3.表示數量

• *：匹配前一個字符0次或無限次，便可有可無
• +：匹配前一個字符出現1次或者無限次，即至少有1次
• {m}：匹配前一個字符出現m次
• {m,}：匹配前一個字符至少出現m次
• {,n}：匹配前一個字符至多出現n次
• {m,n}：匹配前一個字符出現從m到n次

4.表示邊界

• ^：匹配字符串開頭。在多行模式中匹配每一行的開頭
• $：匹配字符串結尾。在多行模式中匹配每一行的結尾
• \A：僅匹配字符串開頭
• \Z：僅匹配字符串結尾
• \b：匹配單詞邊界，\w和\W之間
• \B：匹配非單詞邊界，[^\b]

5.匹配分組

• |：匹配左右任意一個表達式
• (...)：被括起來的表達式做爲一個分組，從表達式左邊開始，每遇到一個'('，編號+1。分組表達式做爲一個總體，後面可接數量詞。表達式中的|僅在該分組中有效
• (?P<name>)：分組，除了原有的編號之外，再給分組取一個別名
• (?P=<name>)：引用別名爲<name>的分組匹配到的字符串
• \<number>：引用編號爲<number>的分組匹配到的字符串

6.特殊構造(不做爲分組)

• (?:...)：(...)的不分組版本，用於使用'|'或後面接上數量詞，好比(?:[1-9]?\d|100)表示匹配數字0-100，(?:abc){2}表示匹配abcabc
• 剩下的一些不常見，略

3、re模塊

在 Python中，咱們能夠使用內置的 re 模塊來使用正則表達式。與大多數編程語言相同，正則表達式裏使用'\'做爲轉義字符，這就可能形成反斜槓困擾。Python裏的原生字符串很好地解決了這個問題，只須要在字符串前面加上'r'前綴。

re模塊的通常使用步驟：

1. 使用 compile() 函數將正則表達式的字符串形式編譯爲一個 Pattern 對象

2. 經過 Pattern 對象提供的一系列方法對文本進行匹配查找

1.compile函數

• compile 函數用於編譯正則表達式，生成一個 Pattern 對象。必須傳入的第一個參數是'規則字符串'，另外能夠經過第二個參數(flags)來指定匹配模式。
• 常見的匹配模式：

1. re.I(re.IGNORECASE): 忽略大小寫
2. re.M(MULTILINE): 多行模式，改變’^’和’$’的行爲
3. re.S(DOTALL): 點任意匹配模式，改變’.’的行爲，能夠匹配'\n'

   import re
   
   # 將正則表達式編譯成 Pattern對象，並指定匹配模式爲點任意匹配模式
   pattern = re.compile(r'\d+',re.S)

2.Pattern 對象的一些經常使用方法

• match方法

  • match 方法用於查找字符串的頭部（也能夠指定起始位置），它是一次匹配，只要找到了一個匹配的結果就返回，而不是查找全部匹配的結果。
  • 它的通常使用形式以下：

    match(string[, pos[, endpos]])

    其中，string 是待匹配的字符串，pos 和 endpos 是可選參數，指定字符串的起始和終點位置，默認值分別是 0 和 len (字符串長度)。所以，當你不指定 pos 和 endpos 時，match 方法默認匹配字符串的頭部。

  • 當匹配成功時，返回一個 Match 對象，若是沒有匹配上，則返回 None。
  • Match對象經常使用的方法:
    • group(([group1, …])：用於得到一個或多個分組匹配的字符串，若是傳入多個分組編號，則返回的結果爲元組形式。當要得到整個匹配的子串時，可直接使用 group() 或 group(0)；
    • groups()：得到全部分組匹配到的字符串所構成的元組
    • start([group]) 方法用於獲取分組匹配的子串在整個字符串中的起始位置（子串第一個字符的索引），參數默認值爲 0；
    • end([group]) 方法用於獲取分組匹配的子串在整個字符串中的結束位置（子串最後一個字符的索引+1），參數默認值爲 0；
    • span([group]) 方法返回 (start(group), end(group))，獲取分組匹配的子串在整個字符串中的起始和結束位置構成的元組。
    • 經過一些例子來熟悉一下：

      In [1]: import re
      
      In [2]: pattern = re.compile(r"(\w+) (\d+)")
      
      In [3]: m = pattern.match('hello 123')
      
      In [4]: m.group(1)
      Out[4]: 'hello'
      
      In [5]: m.group(1,2)
      Out[5]: ('hello', '123')
      
      In [6]: m.group()
      Out[6]: 'hello 123'
      
      In [7]: m.groups()
      Out[7]: ('hello', '123')
      
      In [8]: m.start(1)
      Out[8]: 0
      
      In [9]: m.start(2)
      Out[9]: 6
      
      In [10]: m.end(1)
      Out[10]: 5
      
      In [11]: m.span(1)
      Out[11]: (0, 5)
      
      In [12]: m.span(2)
      Out[12]: (6, 9)

• search方法

  • search 方法用於查找字符串的任何位置，它也是一次匹配，只要找到了一個匹配的結果就返回，而不是查找全部匹配的結果
  • 它的通常使用形式以下：

    search(string[, pos[, endpos]])

    其中，string 是待匹配的字符串，pos 和 endpos 是可選參數，指定字符串的起始和終點位置，默認值分別是 0 和 len (字符串長度)。

  • 看看例子

    >>> import re
    >>> pattern = re.compile('\d+')
    >>> m = pattern.search('one12twothree34four')  # 這裏若是使用 match 方法則不匹配
    >>> m
    <_sre.SRE_Match object at 0x10cc03ac0>
    >>> m.group()
    '12'
    >>> m = pattern.search('one12twothree34four', 10, 30)  # 指定字符串區間
    >>> m
    <_sre.SRE_Match object at 0x10cc03b28>
    >>> m.group()
    '34'
    >>> m.span()
    (13, 15)

• findall方法

  • 上面的 match 和 search 方法都是一次匹配，只要找到了一個匹配的結果就返回。然而，在大多數時候，咱們須要搜索整個字符串，得到全部匹配的結果。
  • findall 方法的使用形式以下：

    findall(string[, pos[, endpos]])

    其中，string 是待匹配的字符串，pos 和 endpos 是可選參數，指定字符串的起始和終點位置，默認值分別是 0 和 len (字符串長度)。

  • findall 以列表形式返回所有能匹配的子串，若是沒有匹配，則返回一個空列表。
  • 看個例子：

    import re
    
    #re模塊提供一個方法叫compile模塊，提供咱們輸入一個匹配的規則
    #而後返回一個pattern實例，咱們根據這個規則去匹配字符串
    pattern = re.compile(r'\d+\.\d*')
    
    #經過partten.findall()方法就可以所有匹配到咱們獲得的字符串
    result = pattern.findall("123.141593, 'bigcat', 232312, 3.15")
    
    #findall 以 列表形式 返回所有能匹配的子串給result
    for item in result:
        print(item)

    運行結果:

    123.141593
    3.15

• finditer方法

  • finditer 方法的行爲跟 findall 的行爲相似，也是搜索整個字符串，得到全部匹配的結果。但它返回一個順序訪問每個匹配結果（Match 對象）的迭代器。
  • 舉例：

    In [1]: import re
    
    In [2]: pattern = re.compile(r"\d+")
    
    In [3]: iter = pattern.finditer('hello123world456  haha789')
    
    In [4]: iter
    Out[4]: <callable_iterator at 0x7fb824fe2a90>
    
    In [5]: for m in iter:
       ...:     print(m.group())
       ...: 
    123
    456
    789

• split方法

  • split 方法按照可以匹配的子串將字符串分割後返回列表
  • 它的使用形式以下:

    split(string[, maxsplit])

    其中，maxsplit 用於指定最大分割次數，不指定將所有分割。

  • 舉個例子:

    In [1]: import re
    
    In [2]: pattern = re.compile(r"[\d\s]")
    
    In [3]: pattern.split('hello1word2aaa bbb')
    Out[3]: ['hello', 'word', 'aaa', 'bbb']
    
    In [4]: pattern.split('hello1word2aaa bbb',2)
    Out[4]: ['hello', 'word', 'aaa bbb']

• sub方法

  • sub 方法用於替換。
  • 它的使用形式以下：

    sub(repl, string[, count])

    其中，repl 能夠是字符串也能夠是一個函數：

    • 若是 repl 是字符串，則會使用 repl 去替換字符串每個匹配的子串，並返回替換後的字符串，另外，repl 還能夠使用 id 的形式來引用分組，但不能使用編號 0；
    • 若是 repl 是函數，這個方法應當只接受一個參數（Match 對象），並返回一個字符串用於替換（返回的字符串中不能再引用分組）。
    • count 用於指定最多替換次數，不指定時所有替換。

      In [1]: import re
      
      In [2]: pattern = re.compile(r'\d+')
      
      In [3]: pattern.sub('100','hello20 world30')#將全部匹配到的數據替換成100
      Out[3]: 'hello100 world100'
      
      In [4]: pattern.sub('100','hello20 world30',1)#只替換第一個數據爲100
      Out[4]: 'hello100 world30'
      
      In [5]: def add(temp):
         ...:    '''將匹配到的數據加1'''
         ...:     strNum = temp.group()
         ...:     num = int(strNum)+1
         ...:     return str(num)
      In [6]: pattern.sub(add,'hello20 world30')#將全部匹配到的數據加1
      Out[6]: 'hello21 world31'
      
      In [7]: pattern.sub(add,'hello20 world30',1)#只將匹配到的第一個數據加1
      Out[7]: 'hello21 world30'

4、貪婪模式與非貪婪模式

• 貪婪模式：在整個表達式匹配成功的前提下，儘量多的匹配
• 非貪婪模式：在整個表達式匹配成功的前提下，儘量少的匹配
• 在表示數量的"*","?","+","{m,n}"後面加上？，使貪婪變成非貪婪

  In [1]: import re
  
  In [2]: pattern = re.compile(r'\d+')
  
  In [3]: pattern.match('123456789').group()
  Out[3]: '123456789'
  
  In [4]: pattern = re.compile(r'\d+?')#關閉貪婪模式
  
  In [5]: pattern.match('123456789').group()#非貪婪模式下，?只匹配一個字符
  Out[5]: '1'
  
  In [6]: pattern = re.compile(r'<div>.*</div>')
  
  In [7]: pattern.match('<div>test1</div>bb<div>test2</div>').group()
  Out[7]: '<div>test1</div>bb<div>test2</div>'
  
  In [8]: pattern = re.compile(r'<div>.*?</div>')#關閉貪婪模式
  
  In [9]: pattern.match('<div>test1</div>bb<div>test2</div>').group()
  Out[9]: '<div>test1</div>'