搞懂 Python 正則表達式用法

搞懂 Python 正則表達式用法

Python 正則表達式

正則表達式是一個特殊的字元序列，它能幫助你方便的檢查一個字元串是否與某種模式匹配。

Python 自1.5版本起增加了re 模塊，它提供 Perl 風格的正則表達式模式。

re 模塊使 Python 語言擁有全部的正則表達式功能。

compile 函數根據一個模式字元串和可選的標誌參數生成一個正則表達式對象。該對象擁有一系列方法用於正則表達式匹配和替換。

re 模塊也提供了與這些方法功能完全一致的函數，這些函數使用一個模式字元串做為它們的第一個參數。

正則表達式模式

模式字元串使用特殊的語法來表示一個正則表達式：

字母和數字表示他們自身。一個正則表達式模式中的字母和數字匹配同樣的字元串。

多數字母和數字前加一個反斜杠時會擁有不同的含義。

標點符號只有被轉義時才匹配自身，否則它們表示特殊的含義。

反斜杠本身需要使用反斜杠轉義。

由於正則表達式通常都包含反斜杠，所以你最好使用原始字元串來表示它們。模式元素(如 r ，等價於 \t)匹配相應的特殊字元。

下表列出了正則表達式模式語法中的特殊元素。如果你使用模式的同時提供了可選的標誌參數，某些模式元素的含義會改變。

模式

描述

^

匹配字元串的開頭

$

匹配字元串的末尾。

.

匹配任意字元，除了換行符，當re.DOTALL標記被指定時，則可以匹配包括換行符的任意字元。

[...]

用來表示一組字元,單獨列出：[amk] 匹配 a，m或k

[^...]

不在[]中的字元：[^abc] 匹配除了a,b,c之外的字元。

re*

匹配0個或多個的表達式。

re+

匹配1個或多個的表達式。

re?

匹配0個或1個由前面的正則表達式定義的片段，非貪婪方式

re{ n}

精確匹配 n 個前面表達式。例如， o{2} 不能匹配 "Bob" 中的 "o"，但是能匹配 "food" 中的兩個 o。

re{ n,}

匹配 n 個前面表達式。例如， o{2,} 不能匹配"Bob"中的"o"，但能匹配 "foooood"中的所有 o。"o{1,}" 等價於 "o+"。"o{0,}" 則等價於 "o*"。

re{ n, m}

匹配 n 到 m 次由前面的正則表達式定義的片段，貪婪方式

a| b

匹配a或b

(re)

匹配括弧內的表達式，也表示一個組

(?imx)

正則表達式包含三種可選標誌：i, m, 或 x 。隻影響括弧中的區域。

(?-imx)

正則表達式關閉 i, m, 或 x 可選標誌。隻影響括弧中的區域。

(?: re)

類似 (...), 但是不表示一個組

(?imx: re)

在括弧中使用i, m, 或 x 可選標誌

(?-imx: re)

在括弧中不使用i, m, 或 x 可選標誌

(?#...)

注釋.

(?= re)

前向肯定界定符。如果所含正則表達式，以 ... 表示，在當前位置成功匹配時成功，否則失敗。但一旦所含表達式已經嘗試，匹配引擎根本沒有提高；模式的剩餘部分還要嘗試界定符的右邊。

(?! re)

前向否定界定符。與肯定界定符相反；當所含表達式不能在字元串當前位置匹配時成功

(?> re)

匹配的獨立模式，省去回溯。

w

匹配字母數字及下劃線

W

匹配非字母數字及下劃線

s

匹配任意空白字元，等價於 [

f].

S

匹配任意非空字元

d

匹配任意數字，等價於 [0-9].

D

匹配任意非數字

A

匹配字元串開始



匹配字元串結束，如果是存在換行，只匹配到換行前的結束字元串。

z

匹配字元串結束

G

匹配最後匹配完成的位置。



匹配一個單詞邊界，也就是指單詞和空格間的位置。例如， er 可以匹配"never" 中的 er，但不能匹配 "verb" 中的 er。

B

匹配非單詞邊界。erB 能匹配 "verb" 中的 er，但不能匹配 "never" 中的 er。

, , 等.

匹配一個換行符。匹配一個製表符。等

1...9

匹配第n個分組的內容。

10

匹配第n個分組的內容，如果它經匹配。否則指的是八進位字元碼的表達式。

正則表達式實例

字元匹配

實例

描述

python

匹配 "python".

字元類

實例

描述

[Pp]ython

匹配 "Python" 或 "python"

rub[ye]

匹配 "ruby" 或 "rube"

[aeiou]

匹配中括弧內的任意一個字母

[0-9]

匹配任何數字。類似於 [0123456789]

[a-z]

匹配任何小寫字母

[A-Z]

匹配任何大寫字母

[a-zA-Z0-9]

匹配任何字母及數字

[^aeiou]

除了aeiou字母以外的所有字元

[^0-9]

匹配除了數字外的字元

特殊字元類

實例

描述

.

匹配除 "
" 之外的任何單個字元。要匹配包括
在內的任何字元，請使用象 [.
] 的模式。

d

匹配一個數字字元。等價於 [0-9]。

D

匹配一個非數字字元。等價於 [^0-9]。

s

匹配任何空白字元，包括空格、製表符、換頁符等等。等價於 [ f

v]。

S

匹配任何非空白字元。等價於 [^ f

v]。

w

匹配包括下劃線的任何單詞字元。等價於[A-Za-z0-9_]。

W

匹配任何非單詞字元。等價於 [^A-Za-z0-9_]。

re模塊

1.Re模塊簡介

re模塊是python中處理正則表達式的一個模塊，通過re模塊的方法，把正則表達式pattern編譯成正則對象，以便使用正則對象的方法

效率問題：

#!/usr/bin/env python# -*- coding: utf-8 -*-# @Time :

2018/4/29 22:02# @Author : Feng Xiaoqing# @File : test.py# @Function:

-----------import reimport timeit

print(timeit.timeit(setup=import re; reg =

re.compile(<(?P<tagname>w*)>.*</(?P=tagname)>), stmt=reg.match(<h1>xxx</h1>), number=1000000))

print(timeit.timeit(setup=import re, stmt=re.match(<(?P<tagname>w*)>.*</(?P=tagname)>,

<h1>xxx</h1>), number=1000000))

reg = re.compile(<(?P<tagname>w*)>.*</(?P=tagname)>)

reg.match(<h1>xxx</h1>)

執行結果：

0.42296138327572711.0246964437151256

常用方法：先申明一個正則對象，在通過正則對象去匹配。這樣的效率高。

1 re.compile(pattern[, flags])方法

re.I(re.IGNORECASE): 忽略大小寫（括弧內是完整寫法，下同）

M(MULTILINE): 多行模式，改變^和$的行為

S(DOTALL): 點任意匹配模式，改變.的行為

L(LOCALE): 使預定字元類 w W  B s S 取決於當前區域設定

U(UNICODE): 使預定字元類 w W  B s S d D 取決於unicode定義的字元屬性

X(VERBOSE): 詳細模式。這個模式下正則表達式可以是多行，忽略空白字元，並可以加入注釋。以下兩個正則表達式是等價的：

compile 函數用於編譯正則表達式，生成一個正則表達式（ Pattern ）對象，供 match() 和 search() 這兩個函數使用。

語法格式為：

re.compile(pattern[, flags])

參數：

·

pattern : 一個字元串形式的正則表達式

·

flags : 可選，表示匹配模式，比如忽略大小寫，多行模式等，具體參數為：

1.

re.I 忽略大小寫

2.

re.L 表示特殊字符集 w, W, , B, s, S 依賴於當前環境

3.

re.M 多行模式

4.

re.S 即為 . 並且包括換行符在內的任意字元（. 不包括換行符）

5.

re.U 表示特殊字符集 w, W, , B, d, D, s, S 依賴於 Unicode 字元屬性資料庫

6.

re.X 為了增加可讀性，忽略空格和 # 後面的注釋

實例

>>>import re>>> pattern =

re.compile(rd+) # 用於匹配至少一個數字>>>

m = pattern.match(one12twothree34four)

# 查找頭部，沒有匹配>>> print mNone>>> m =

pattern.match(one12twothree34four, 2, 10) # 從e的位置開始匹配，沒有匹配>>> print mNone>>> m =

pattern.match(one12twothree34four, 3, 10) # 從1的位置開始匹配，正好匹配>>> print m

# 返回一個 Match 對象<_sre.SRE_Match

object at 0x10a42aac0>>>> m.group(0) # 可省略 012>>> m.start(0) # 可省略 03>>> m.end(0)

# 可省略 05>>> m.span(0) # 可省略 0(3, 5)

在上面，當匹配成功時返回一個 Match 對象，其中：

·

group([group1, …]) 方法用於獲得一個或多個分組匹配的字元串，當要獲得整個匹配的子串時，可直接使用 group()或 group(0)；

·

start([group]) 方法用於獲取分組匹配的子串在整個字元串中的起始位置（子串第一個字元的索引），參數默認值為

0；

·

end([group]) 方法用於獲取分組匹配的子串在整個字元串中的結束位置（子串最後一個字元的索引+1），參數默認值為

0；

·

span([group]) 方法返回 (start(group),

end(group))。

再看看一個例子：

實例

>>>import re>>> pattern = re.compile(r([a-z]+)

([a-z]+), re.I) # re.I 表示忽略大小寫>>> m =

pattern.match(Hello World Wide Web)>>> print m

# 匹配成功，返回一個 Match 對象<_sre.SRE_Match object at

0x10bea83e8>>>> m.group(0)

# 返回匹配成功的整個子串Hello World>>> m.span(0)

# 返回匹配成功的整個子串的索引(0, 11)>>> m.group(1)

# 返回第一個分組匹配成功的子串Hello>>> m.span(1)

# 返回第一個分組匹配成功的子串的索引(0, 5)>>> m.group(2)

# 返回第二個分組匹配成功的子串World>>> m.span(2)

# 返回第二個分組匹配成功的子串(6, 11)>>> m.groups()

# 等價於

(m.group(1), m.group(2), ...)(Hello, World)>>> m.group(3)

# 不存在第三個分組Traceback (most recent call last):

File "<stdin>", line 1, in <module>IndexError: no such

group

2.findall方法

在字元串中找到正則表達式所匹配的所有子串，並返回一個列表，如果沒有找到匹配的，則返回空列表。

注意： match 和

search 是匹配一次 findall 匹配所有。

語法格式為：

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

參數：

·

string : 待匹配的字元串。

·

pos : 可選參數，指定字元串的起始位置，默認為 0。

·

endpos : 可選參數，指定字元串的結束位置，默認為字元串的長度。

查找字元串中的所有數字：

實例

#!/usr/bin/env python# -*- coding: utf-8 -*-# @Time :

2018/4/29 22:15# @Author : Feng Xiaoqing# @File : test2.py#

@Function: -----------import re

pattern = re.compile(rd+) # 查找數字result1 =

pattern.findall(runoob 123 google 456)

result2 = pattern.findall(run88oob123google456, 0, 10)

print(result1)

print(result2)

輸出結果：

[123, 456]

[88, 12]

Re模塊的方法：

(1)re.match函數

re.match 嘗試從字元串的起始位置匹配一個模式，如果不是起始位置匹配成功的話，match()就返回none。

函數語法：

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

函數參數說明：

參數

描述

pattern

匹配的正則表達式

string

要匹配的字元串。

flags

標誌位，用於控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等等。參見：正則表達式修飾符 - 可選標誌

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

我們可以使用group(num) 或 groups() 匹配對象函數來獲取匹配表達式。

匹配對象方法

描述

group(num=0)

匹配的整個表達式的字元串，group() 可以一次輸入多個組號，在這種情況下它將返回一個包含那些組所對應值的元組。

groups()

返回一個包含所有小組字元串的元組，從 1 到 所含的小組號。

實例

#!/usr/bin/env python# -*- coding: utf-8 -*-# @Time :

2018/4/29 22:15# @Author : Feng Xiaoqing# @File : test2.py#

@Function: -----------import re

pattern = re.compile(rd+) # 查找數字result1 =

pattern.findall(runoob 123 google 456)

result2 = pattern.findall(run88oob123google456, 0, 10)

print(result1)

print(result2)

以上實例運行輸出結果為：

(0, 3)

None

實例

#!/usr/bin/env python# -*- coding: utf-8 -*-# @Time :

2018/4/29 22:55# @Author : Feng Xiaoqing# @File : test2.py#

@Function: -----------import re

line = "Cats are smarter than dogs"

matchObj = re.match( r(.*) are

(.*?) .*, line, re.M|re.I)

if matchObj: print "matchObj.group() :

", matchObj.group() print "matchObj.group(1)

: ", matchObj.group(1) print "matchObj.group(2)

: ", matchObj.group(2)else: print "No

match!!"

以上實例執行結果如下：

matchObj.group() : Cats are smarter than dogsmatchObj.group(1) : CatsmatchObj.group(2) : smarter

(2)re.search方法

re.search 掃描整個字元串並返回第一個成功的匹配。

函數語法：

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

函數參數說明：

參數

描述

pattern

匹配的正則表達式

string

要匹配的字元串。

flags

標誌位，用於控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等等。

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

我們可以使用group(num) 或 groups() 匹配對象函數來獲取匹配表達式。

匹配對象方法

描述

group(num=0)

匹配的整個表達式的字元串，group() 可以一次輸入多個組號，在這種情況下它將返回一個包含那些組所對應值的元組。

groups()

返回一個包含所有小組字元串的元組，從 1 到 所含的小組號。

實例

#!/usr/bin/env python# -*- coding: utf-8 -*-# @Time :

2018/4/29 22:15# @Author : Feng Xiaoqing# @File : test2.py#

@Function: -----------import re

print(re.search(www, www.runoob.com).span())

# 在起始位置匹配print(re.search(com, www.runoob.com).span())

# 不在起始位置匹配

以上實例運行輸出結果為：

(0, 3)

(11, 14)

實例

#!/usr/bin/pythonimport re

line = "Cats are smarter than dogs";

searchObj = re.search( r(.*) are (.*?) .*, line, re.M|re.I)

if searchObj: print "searchObj.group() :

", searchObj.group() print "searchObj.group(1)

: ", searchObj.group(1) print "searchObj.group(2)

: ", searchObj.group(2)else: print "Nothing

found!!"

以上實例執行結果如下：

searchObj.group() : Cats are smarter than dogssearchObj.group(1) : CatssearchObj.group(2) : smarter

re.match與re.search的區別

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

實例

#!/usr/bin/pythonimport re

line = "Cats are smarter than dogs";

matchObj = re.match( rdogs, line, re.M|re.I)if matchObj:

print "match --> matchObj.group() : ", matchObj.group()else: print "No

match!!"

matchObj = re.search( rdogs, line,

re.M|re.I)if matchObj: print "search -->

matchObj.group() : ", matchObj.group()else: print "No

match!!"

以上實例運行結果如下：

No match!!

search --> matchObj.group() : dogs

Match從開頭開始匹配，匹配不到，返回空

Search從開頭開始匹配，然後第第二個開始匹配，只匹配一個結果。

Match的效率是最高的，就要求我們正則表達式要寫正確

（3）Split方法

re.split

split 方法按照能夠匹配的子串將字元串分割後返回列表，它的使用形式如下：

re.split(pattern, string[, maxsplit=0, flags=0])

參數：

參數

描述

pattern

匹配的正則表達式

string

要匹配的字元串。

maxsplit

分隔次數，maxsplit=1 分隔一次，默認為 0，不限制次數。

flags

標誌位，用於控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等等。參見：正則表達式修飾符 - 可選標誌

實例

>>>import re

>>> re.split(W+, runoob,

runoob, runoob.) [runoob, runoob, runoob, ]

>>> re.split((W+), runoob,

runoob, runoob.) [, , runoob, , , runoob, , , runoob, ., ] >>> re.split(W+, runoob, runoob, runoob., 1) [, runoob,

runoob, runoob.]

>>> re.split(a*, hello world) # 對於一個找不到匹配的字元串而言，split

不會對其作出分割 [hello world]

split(string[, maxsplit])

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

#!/usr/bin/env python# -*- coding: utf-8 -*-# @Time :

2018/4/29 22:15# @Author : Feng Xiaoqing# @File : test2.py#

@Function: -----------import re

p = re.compile(rd+)

print(p.split(one1two2three3four4))

結果：

[one, two, three, four, ]

(4)sub檢索和替換

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

語法：

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

參數：

·

pattern : 正則中的模式字元串。

·

repl : 替換的字元串，也可為一個函數。

·

string : 要被查找替換的原始字元串。

·

count : 模式匹配後替換的最大次數，默認 0 表示替換所有的匹配。

實例

#!/usr/bin/env python# -*- coding: utf-8 -*-# @Time :

2018/4/29 22:33# @Author : Feng Xiaoqing# @File : test2.py#

@Function: -----------

import re

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

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

", num

# 刪除非數字(-)的字元串 num = re.sub(rD, "", phone)print "電話號碼是 :

", num

以上實例執行結果如下：

電話號碼是: 2004-959-559

電話號碼是 : 2004959559

repl 參數是一個函數

以下實例中將字元串中的匹配的數字乘以 2：

實例

#!/usr/bin/env python# -*- coding: utf-8 -*-# @Time :

2018/4/29 22:15# @Author : Feng Xiaoqing# @File : test2.py#

@Function: -----------import re

pattern = re.compile(rd+) # 查找數字result1 =

pattern.findall(runoob 123 google 456)

result2 = pattern.findall(run88oob123google456, 0, 10)

print(result1)

print(result2)

執行輸出結果為：

A46G8HFD1134

（5）findall方法

在字元串中找到正則表達式所匹配的所有子串，並返回一個列表，如果沒有找到匹配的，則返回空列表。

注意： match 和

search 是匹配一次 findall 匹配所有。

語法格式為：

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

參數：

·

string : 待匹配的字元串。

·

pos : 可選參數，指定字元串的起始位置，默認為 0。

·

endpos : 可選參數，指定字元串的結束位置，默認為字元串的長度。

查找字元串中的所有數字：

實例

#!/usr/bin/env python# -*- coding: utf-8 -*-# @Time :

2018/4/29 22:15# @Author : Feng Xiaoqing# @File : test2.py#

@Function: -----------

import re

pattern = re.compile(rd+) # 查找數字result1 =

pattern.findall(runoob 123 google 456)

result2 = pattern.findall(run88oob123google456, 0, 10)

print(result1)

print(result2)

輸出結果：

[123, 456]

[88, 12]

（6）finditer方法

和 findall 類似，在字元串中找到正則表達式所匹配的所有子串，並把它們作為一個迭代器返回。

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

參數：

參數

描述

pattern

匹配的正則表達式

string

要匹配的字元串。

flags

標誌位，用於控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等等。參見：正則表達式修飾符 - 可選標誌

實例

#!/usr/bin/env python# -*- coding: utf-8 -*-# @Time :

2018/4/29 22:15# @Author : Feng Xiaoqing# @File : test2.py#

@Function: -----------import re

it = re.finditer(r"d+","12a32bc43jf3")

for match in it:

print

(match.group() )

輸出結果：

12

32

43

3

group()

group(0)

group(1) group(「tagname」)

gourps()

groupdict()

findall

import re

p = re.compile(rd+)

print(findall(one1two2three3four4))

結果：

[1, 2, 3, 4]

finditer

sub

Split d+

『one1two2three3four4』

#!/usr/bin/env python# -*- coding: utf-8 -*-# @Time :

2018/4/29 20:24# @Author : fengxiaoqing# @File : test.py<h1>xxx</h1>

查看不同匹配規則的效率import reimport timeit#

print(timeit.timeit(setup=import re; reg = re.compile(<(?P<tagname>w*)>.*</(?P=tagname)>),

stmt=reg.match(<h1>xxx</h1>), number=1000000))#

print(timeit.timeit(setup=import re,

stmt=re.match(<(?P<tagname>w*)>.*</(?P=tagname)>,

<h1>xxx</h1>), number=1000000))s = "ab<h1>xxx</h1>dsafasdf<html>sdfads</html>"reg =

re.compile(r"(<(?P<tag>w+)>(.*)</(?P=tag)>)")

print(reg.match(s))

print(reg.search(s).group(3))

print(reg.findall(s))# print(reg.findall(s)[1])#

print(reg.findall(s)[2])# reg.split(s)# reg.findall(s)# reg.groups(s)x = 1one2two3three4fourreg1 =

re.compile("d")

print(reg1.findall(x))

print(reg1.split(x))

*聲明：推送內容及圖片來源於網路，部分內容會有所改動，版權歸原作者所有，如來源信息有誤或侵犯權益，請聯繫我們刪除或授權事宜。

http://weixin.qq.com/r/dEyJkUjEgRX_rQzy9xlm (二維碼自動識別)

推薦閱讀：