[ python ] 正則表達式及re模塊

正則表達式

正則表達式描述：

    正則表達式是對字符串操做的一種邏輯公式，就是用事先定義好的一些特定字符、及這些特定字符的組合，組成一個‘規則字符串’，這個‘規則字符串’用來
    表達對字符串的一種過濾邏輯。

　　在線測試工具：http://tool.chinaz.com/regex/

　　須要明確的是正則表達式只和字符串相關。

　　正則表達式基礎使用參考：http://tool.chinaz.com/regex/

 

re 模塊中經常使用功能函數

1. compile()

編譯正則表達式模式，返回一個對象的模式。（能夠把那些經常使用的正則表達式編譯成正則表達式對象，這樣能夠提升一點效率。）

格式：

re.compile(pattern,flags=0)
pattern: 編譯時用的表達式字符串。
flags 編譯標誌位，用於修改正則表達式的匹配方式

 

實例：

import re
s1 = 'have a good day.'
rr = re.compile("\w*oo\w*")
print(rr.findall(s1))   # 查看字符串中包含'oo'的單詞

# 執行結果：
# ['good']

re_compile.py

 

2. match()

 

描述：
決定RE是否在字符串剛開始的位置匹配。

注意：
    這個方法並非徹底匹配，當pattern結束時，若string還有剩餘字符，仍然視爲成功。想要徹底匹配，能夠在表達式末尾加上邊界匹配符 '$'
    
格式：

re.match(pattern, string, flags=0)

 

實例：

import re
s1 = 'runnicegoodrunbetterrun'
# rr = re.match('run', 'nicegoodrun better.run')
r1 = re.match('run', 'runnicegoodrunbetterrun').group()
r2 = re.match('run', 'Runnicegoodrunbetterrun', re.I).group()   # re.I 忽視大小寫

print('r1:', r1)
print('r2:', r2)

# 執行結果：
# r1: run
# r2: Run

re_match.py

 

 

3. search()

re.search函數會在字符串內查找模式匹配，只要找到第一個匹配而後返回，若是字符串沒有匹配，則返回None

re.search(pattern, string, flags=0)

 

實例：

import re
s1 = 'run nice good run better rungood'
rr = re.search("good", s1).group()    # 只會匹配到一個就直接返回
print(rr)

# 執行結果：
# good

re_search.py

 

 

注意：
    match和search一旦匹配成功，就是一個 match object 對象，而match object對象有如下方法：

•     group()　　返回被 RE 匹配的字符串
•     start() 　　返回匹配開始的位置
•     end()   　　 返回匹配結束的位置
•     span()    　　返回一個元組包含匹配的位置
•     group() 　　返回 re 總體匹配的字符串，能夠一次輸入多個組號，對應組號匹配的字符串。

 

a.group()    返回re總體匹配的字符串
b.group(n, m)    返回組號爲n,m所匹配的字符串，若是組號不存在，則返回indexError異常
c.groups()    groups() 方法返回一個包含正則表達式中全部小組字符串的元組，從 1 到所含的小組號，一般groups()不須要參數，返回一個元組，
元組中的元就是正則表達式中定義的組。   

 

import re
a = "123abc456"
rr = re.compile("([0-9]*)([a-z]*)([0-9]*)")
print('group(0):', rr.search(a).group(0))    # group(0) 返回正則匹配到的所有內容
print('group(1):', rr.search(a).group(1))    # group(1) 列出第一個 ([a-z]*) 匹配到的部分
print('group(2):', rr.search(a).group(2))    # group(2) 列出第二個 ([0-9]*) 匹配到的部分
print('group(3):', rr.search(a).group(3))    # group(3) 列出第三個 ([0-9]*) 匹配到的部分
print('groups():', rr.search(a).groups())    # groups() 以元組的形式列出每一個括號中匹配到的內容

# 執行結果：
# group(0): 123abc456
# group(1): 123
# group(2): abc
# group(3): 456
# groups(): ('123', 'abc', '456')

re_group.py

 

 

4. findall()

描述：
re.findall 遍歷匹配，能夠得到字符串中全部匹配的字符串，返回一個列表

格式：

re.findall(pattern, string, flags=0)

 

實例：

import re

p = re.findall("(\d+)", 'asdf12sdf123ad')   # 當匹配到多個值，以列表的形式返回
print(p)

# 執行結果：
# ['12', '123']


import re

tt = 'ggood booyy nice day'
print(re.findall("\w*oo\w*", tt))
print(re.findall("(\w)*oo(\w)", tt))    # 經過小括號分組，獲得列表中的元組

# 執行結果：
# ['ggood', 'booyy']
# [('g', 'd'), ('b', 'y')]

re_findall.py

 

 

5. finditer()

描述：

搜索string，返回一個順序訪問每個匹配結果（Match對象）的迭代器。找到RE匹配的全部部分，並把他們做爲一個迭代器返回。

 

格式：

re.finditer(pattern, string, flags=0)

 

 

實例：

import re

iter = re.finditer('\d+', 'adfasdfq2313sdasf2qe4123')
for i in iter:
    print(i)    # finditer返回的是一個迭代器
    print(i.group())    # 返回一組匹配到的部分
    print(i.span())     # 返回一個元組包含匹配（開始，結束）的位置

# 執行結果：
# <_sre.SRE_Match object; span=(8, 12), match='2313'>
# 2313
# (8, 12)
# <_sre.SRE_Match object; span=(17, 18), match='2'>
# 2
# (17, 18)
# <_sre.SRE_Match object; span=(20, 24), match='4123'>
# 4123
# (20, 24)

re_finditer.py

 

 

6. split()

描述：

按照可以匹配的字串將 string 分割後返回列表。
可使用re.split來分割字符串，如：re.split(r'\s+', text)；將字符串按空格分割成一個單詞列表。

import re
print(re.split("\s+", 'nice to meeting you'))

# 執行結果：
# ['nice', 'to', 'meeting', 'you']

 

格式：

re.split(pattern, string[, maxsplit])
maxsplit用於指定最大分割次數，不指定將所有分割。

 

 

實例：

import re
print(re.split('\d+','one1two2three3four4five5'))

# 執行結果：
# ['one', 'two', 'three', 'four', 'five', '']


re.split 用法在這裏要注意下：
    當正則中使用分組和不使用分組返回的是不一樣的結果：
    
import re
print(re.split('[a-z]','111a222'))
print(re.split('([a-z])','111a222'))

# 執行結果：
# ['111', '222']        # 未使用分組
# ['111', 'a', '222']   # 使用分組

re_split.py

 

 

經過上面的例子，咱們能夠看到未使用分組和使用分組的不一樣，這裏總結一下：

當正則未使用分組（正則未帶小括號）時，按照匹配到的部分進行切割，且匹配到的部分不會出如今結果列表中
當正則使用分組（正則帶小括號）時，按照匹配到的部分進行切割，匹配到的部分做爲元素出如今列表中，且匹配到值的索引按照奇數位出現一、三、五、7...

靈活的使用分組會帶來不少的便捷，後面編寫計算器的代碼中就會用到。

 

7. sub()

使用re替換string中每個匹配的子串後返回替換後的字符串

格式：

re.sub(pattern, repl, string, count)

默認所有替換

實例：

import re
s1 = '1 + 2 + (4 / 5  + 2)'

print(re.sub(' ', '', s1))  # 直接去除計算表達式中的空格

# 執行結果：
# 1+2+(4/5+2)

re_sub.py

 

 

8. subn()

 

描述：

返回元組類型，最後一位爲替換的次數

格式：

subn(pattern, repl, string, count=0, flags=0)

 

 

實例：

import re
s1 = '1 + 2 + (4 / 5  + 2)'

print(re.subn(' ', '', s1))  # 直接去除計算表達式中的空格

# 執行結果：
# ('1+2+(4/5+2)', 9)    # 替換了9次空格

re_subn.py

 

 

re模塊方法區分

1. re.match與re.search與re.findall的區別：

re.match     只是匹配字符串的開始，若是字符串開始不符合正則表達式，則匹配失敗，函數返回None
re.search     匹配整個字符串，直到直到一個匹配。

import re
s1 = 'abc123'
print(re.match("[\d]", s1))     # 從頭開始搜索數字，若是開始沒有匹配到返回None
print(re.search("[\d]", s1).group())    # 從頭開始搜索數字，匹配到第一個直接返回一個迭代器
print(re.findall("[\d]", s1))   # 遍歷查找字符串中的數字部分，查找到每一個數字都以元素的形式展示

# 執行結果：
# None
# 1
# ['1', '2', '3']

re_match_search.py

 

 

2. 貪婪匹配和非貪婪匹配

*?,+?,??,{m,n}?    前面的*,+,?等都是貪婪匹配，也就是儘量匹配，後面加?號使其變成惰性匹配

 

實例1：

import re
a = re.findall(r"a(\d+?)",'a23b')   # 在正則後面加'?'，表示惰性匹配，匹配到一個就直接返回
print(a)
b = re.findall(r"a(\d+)",'a23b')    # 貪婪匹配
print(b)

# 執行結果：
# ['2']
# ['23']

實例1

 

實例2：

a = re.match('<(.*)>','<H1>title<H1>').group()
print(a)
b = re.match('<(.*?)>','<H1>title<H1>').group()
print(b)

# 執行結果：
# <H1>title<H1>
# <H1>

實例2

實例3：

a = re.findall(r"a(\d+)b",'a3333b')
print(a)
b = re.findall(r"a(\d+?)b",'a3333b')
print(b)

# 執行結果：
# ['3333']
# ['3333']

實例3

 

 

參考連接：    https://www.cnblogs.com/tina-python/p/5508402.html    http://tool.chinaz.com/regex/    http://www.cnblogs.com/Eva-J/articles/7228075.html#_label10