python：正則表達式_re模塊

Python 正則表達式

簡介

1、正則表達式是一個特殊的字符序列，它能幫助你方便的檢查一個字符串是否與某種模式匹配。從而達到快速檢索或替換符合某個模式、規則的文本。

2、Python自1.5版本起增加了re 模塊，re模塊使Python語言擁有全部的正則表達式功能。

3、這種匹配是根據一個字符一個字符來匹配的
 

re模塊

re.search( )方法

作用：
1、re.search( )方法用於掃描整個字符串並返回第一個成功的匹配的字符
2、如果匹配成功，re.search( )就返回一個匹配的對象，否則返回None

函數語法：

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

參數說明：
pattern：匹配的正則表達式
string：要匹配的字符串。
flags：標誌位，用於控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等等。(參數flags用於編譯pattern時指定匹配模式)

返回值：
匹配成功re.search方法返回一個匹配的對象，否則返回None。

例1：

import re

string = "In me The tiger sniffs the rose"
expression = r" the"  #r表示後面爲正則表達式
result = re.search(expression,string,re.I)
result_1 = re.search(expression,string)
print("區分大小寫時的匹配:",result)
print("不區分大小寫時的匹配:",result_1)

"""
區分大小寫時的匹配: <_sre.SRE_Match object; span=(5, 9), match=' The'>
不區分大小寫時的匹配: <_sre.SRE_Match object; span=(22, 26), match=' the'>
"""

備註：
1、search( )方法返回的是一個匹配對象(_sre.SRE_Match object)，返回結果中span表示匹配到的字符串所在的位置，使用的是索引(從0開始，包左不包右)，match表示匹配到的字符串

2、第一個參數是正則表達式模式，也就是你要描述的搜索規則，可以使用原始字符串來寫，因爲這樣可以避免很多不必要的麻煩(也可以使用具體的正則表達式，如pattern = r" (\w+) (\w+)")

search對象的方法

作用：返回由search()方法返回的對象的中詞組(search()方法返回的是一個對象，但是沒有返回具體匹配到的字符串，因此需要使用這些方法來獲得具體匹配的字符串)

匹配對象方法	描述
end([group=0])	返回指定分組的結束位置，默認返回正則表達式所匹配到的最後一個字符的索引
expand(template)	根據模版返回相應的字符串，類似與 sub 函數裏面的 repl， 可使用 \1 或者 \g<name> 來選擇分組
group([group1, ...])	根據提供的索引或名字返回響應分組的內容，默認返回 start() 到 end() 之間的字符串， 提供多個參數將返回一個元組
groupdict([default=None])	返回 返回一個包含所有匹配到的命名分組的字典，沒有命名的分組不包含在內，key 爲組名， value 爲匹配到的內容，參數 default 爲沒有參與本次匹配的命名分組提供默認值
groups([default=None])	以元組形式返回每一個分組匹配到的字符串，包括沒有參與匹配的分組，其值爲 default
span([group])	返回指定分組的起止位置組成的元組，默認返回由 start() 和 end() 組成的元組
start([group])	返回指定分組的開始位置，默認返回正則表達式所匹配到的第一個字符的索引

例1_1:

import re

string = "In me The tiger sniffs the rose"

pattern = r" (?P<name>\w+) (\w+) tiger"
result = re.search(pattern,string)

print("不區分大小寫時的匹配:",result)

# 根據提供的索引或名字返回響應分組的內容，默認返回start()到end()之間的字符串，提供多個參數將返回一個元組
#若提供的索引超出了元組實際的長度，則會報錯
print(result.group(1),type(result.group(1,2)))
print(result.group(2),type(result.group(2)))

#以元組形式返回每一個分組匹配到的字符串，包括沒有參與匹配的分組，其值爲default
print(result.groups(),type(result.groups()))

# 返回指定分組的結束位置，默認返回正則表達式所匹配到的最後一個字符的索引
print(result.end())

# 返回指定分組的起止未知組成的元組，默認返回由start()和end()組成的元組
print(result.span())

# 返回 返回一個包含所有匹配到的命名分組的字典，沒有命名的分組不包含在內，key爲組名，value爲匹配到的內容，參數default爲沒有參與本次匹配的命名分組提供默認值
print(result.groupdict('default_string'))

"""
不區分大小寫時的匹配: <_sre.SRE_Match object; span=(2, 15), match=' me The tiger'>
me <class 'tuple'>
The <class 'str'>
('me', 'The') <class 'tuple'>
15
(2, 15)
{'name': 'me'}
"""

備註：
1、(…) 用來匹配符合條件的字符串。並且將此部分，打包放在一起，看做成一個組：group

2、組是通過 "(" 和 ")" 元字符來標識的，如果不引起括號的話，匹配出來的字符串就是一個組(索引只能是0)，引入括號後可以將匹配到的字符串分組

例1_2：

import re
s = '1102231990xxxxxxxx'
res = re.search('(?P<province>\d{3})(?P<city>\d{3})(?P<born_year>\d{4})',s)
print(res.groupdict())

#{'province': '110', 'city': '223', 'born_year': '1990'}

 

re.match()函數

1、一般使用re模塊的步驟是先將正則表達式的字符串形式編譯爲Pattern實例，然後使用Pattern實例處理文本並獲得匹配結果(一個match()函數)，最後使用match()函數獲得信息，進行其他操作

2、re.match()函數嘗試從字符串的起始位置匹配一個模式，如果在起始位置匹配成功的話，就返回匹配結果對象；如果不是起始位置匹配成功的話，match()就返回none。

函數語法：
re.match(pattern, string, flags=0)

參數說明：
pattern：匹配的正則表達式
string：要匹配的字符串。
flags：標誌位，用於控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等等。

例2：

import re
print(re.match('www', 'www.baidu.com'))  # 在起始位置匹配
print(re.match('com', 'www.baidu.com'))  # 不在起始位置匹配

"""
<_sre.SRE_Match object; span=(0, 3), match='www'>
None
"""

re.match()與re.search()的區別

1、re.match只匹配字符串的開始，如果字符串開始的字符不符合正則表達式，則匹配失敗，函數返回None
2、re.search匹配整個字符串，直到找到一個匹配的對象，匹配結束也沒找到匹配值才返回None
例3：

import re

line = "Cats are smarter than dogs"

matchObj = re.match(r'dogs', line, re.M | re.I)
if matchObj:
    print("match --> matchObj.group() : ", matchObj.group())

else:
    print("No match!!")


matchObj = re.search(r'dogs', line, re.M | re.I)
if matchObj:
    print("search --> matchObj.group() : ", matchObj.group())

else:
    print("No match!!")

"""
No match!!
search --> matchObj.group() :  dogs
"""

編譯正則表達式

語法如下：
re.compile(strPattern[, flag])
參數：
strPattern：需要編譯的正則表達式
flag：匹配模式

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

2、如果需要重複使用某個正則表達式，那麼可以先將該正則表達式編譯成模式對象。使用re.compile()方法來進行編譯

3、re提供了衆多模塊方法用於完成正則表達式的功能。這些方法可以使用Pattern實例的相應方法替代，唯一的好處是少寫一行re.compile()代碼，但同時也無法複用編譯後的Pattern對象。

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

例4：

import re
string = "In Me The Tiger Sniffs The Rose"
string_1 ="hello,world"

pattern = re.compile(r"[a-z]")

word = re.search(pattern,string)
word_1 = re.search(pattern,string_1)
print(word)
print(word_1)

#如果不編譯的話，就需要每次都在search()方法中加上正則表達式

"""
<_sre.SRE_Match object; span=(1, 2), match='n'>
<_sre.SRE_Match object; span=(0, 1), match='h'>
"""

編譯標誌

通過編譯標誌，可以修改正則表達式的工作方式，可以使用的編譯標誌如下：

re.A(ASCII)	使得轉義符號如\w,\b,\s和\d只能匹配ASCII字符而不匹配完整的Unicode字符(括號內是完整寫法，下同） re.I(re.IGNORECASE): 匹配時忽略大小寫
re.M(MULTILINE)	多行模式，改變'^'和'$'的行爲
re.S(DOTALL)	點任意匹配模式，包括換行符，改變'.'的行爲
re.L(LOCALE)	使預定字符類 \w \W \b \B \s \S 取決於當前區域設定
re.U(UNICODE)	使預定字符類 \w \W \b \B \s \S \d \D 取決於unicode定義的字符屬性
re.X(VERBOSE)	詳細模式。這個模式下正則表達式可以是多行，忽略空白字符，並可以加入註釋。

以下兩個正則表達式是等價的：

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")

例5：

import re

string = "In me The tiger sniffs the rose"

pattern = re.compile(r" the",re.I) #將字符串形式的正則表達式編譯爲Pattern對象
result_1 = re.search(pattern,string)

print("不區分大小寫時的匹配:",result_1)

#不區分大小寫時的匹配: <_sre.SRE_Match object; span=(5, 9), match=' The'>

如以上例子可以簡寫爲：
例5_1：

import re

string = "In me The tiger sniffs the rose"

pattern = r" the" 
result_1 = re.search(pattern,string,re.I)

print("不區分大小寫時的匹配:",result_1)

#不區分大小寫時的匹配: <_sre.SRE_Match object; span=(5, 9), match=' The'>
#即就是上面說的：可以使用Pattern實例的相應方法替代，唯一的好處是少寫一行re.compile()代碼

注：編譯正則表達式時使用了編譯標誌(re.I等)，在search()等方法中就不能再次使用編譯標誌了

 

split( )方法

語法如下：

split(string[, maxsplit]) | re.split(pattern, string[, maxsplit])

參數
pattern    匹配的正則表達式
string    要匹配的字符串。
maxsplit    分隔次數，maxsplit=1 分隔一次，默認爲 0，不限制次數。
flags    標誌位，用於控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等等。參見：正則表達式修飾符 - 可選標誌

返回值：
按照能夠匹配的子串將string分割後返回列表。maxsplit用於指定最大分割次數，不指定將全部分割。 

例6：

import re
string = "one1two2three3four4"

pattern = re.compile(r"\d+")

word = re.split(pattern,string)
word_1 = re.split(pattern,string,2)
print(word)
print(word_1)

"""
['one', 'two', 'three', 'four', '']
['one', 'two', 'three3four4']
"""

 

findall( )方法

語法如下：
findall(string[, pos[, endpos]]) | re.findall(pattern, string[, flags])

參數：
string : 待匹配的字符串。
pos : 可選參數，指定字符串的起始位置，默認爲 0。
endpos : 可選參數，指定字符串的結束位置，默認爲字符串的長度。

作用：
搜索string，以列表形式返回全部能匹配的子串：返回一個由所有匹配結果組成的列表

例7：

import re
string = "one1two2three3four4"

pattern = re.compile(r"\d+")

word = re.findall(pattern,string)
print(word)
print(type(word))
for n in word:
    print(n)

"""
['1', '2', '3', '4']
<class 'list'>
1
2
3
4
"""

 

finditer( )方法

語法如下：
finditer(string[, pos[, endpos]]) | re.finditer(pattern, string[, flags])
作用：
搜索string，返回一個順序訪問每一個匹配結果（Match對象）的迭代器。 

例8：

import re
string = "one1two2three3four4"

pattern = re.compile(r"\d+")

word = re.finditer(pattern,string)
print(word)
print(type(word))
for n in word:

    print(n.group())
print(n)

"""
<callable_iterator object at 0x000001409C13FFD0>
<class 'callable_iterator'>
1
2
3
4
<_sre.SRE_Match object; span=(18, 19), match='4'>
"""

 

拓展：

檢索和替換

Python的re模塊提供了re.sub用於替換字符串中的匹配項。

語法：

re.sub(pattern, repl, string, count=0, flags=0)

參數：
pattern : 正則中的模式字符串。
repl : 替換的字符串，也可爲一個函數。
string : 要被查找替換的原始字符串。
count : 模式匹配後替換的最大次數，默認 0 表示替換所有的匹配。

例9：

import re

phone = "2004-959-559 # 這是一個國外電話號碼"

# 刪除字符串中的 Python註釋
word = print(re.findall(r'#.*$',phone))
num = re.sub(r'#.*$', "", phone)
print("電話號碼是: ", num)

# 刪除非數字(-)的字符串
num = re.sub(r'\D', "", phone)
word_2 = print(re.findall(r'\D',phone))
print("電話號碼是 : ", num)

"""
['# 這是一個國外電話號碼']
電話號碼是:  2004-959-559 
['-', '-', ' ', '#', ' ', '這', '是', '一', '個', '國', '外', '電', '話', '號', '碼']
電話號碼是 :  2004959559
"""