詳細解析python正規表示式re模組

本篇文章給大家帶來了關於的相關知識，其中主要介紹了關於正規表示式中re模組的相關問題，下面一起來看一下，希望對大家有幫助。

推薦學習：

在Python中需要通過正規表示式對字串進⾏匹配的時候，可以使⽤⼀個python自帶的模組，名字為re。

正規表示式的大致匹配過程是：
1.依次拿出表示式和文字中的字元比較，
2.如果每一個字元都能匹配，則匹配成功；一旦有匹配不成功的字元則匹配失敗。
3.如果表示式中有量詞或邊界，這個過程會稍微有一些不同。

r：Python 中字串的前導 r 代表原始字串識別符號，該字串中的特殊符號不會被跳脫，適用於正規表示式中繁雜的特殊符號表示。因此 r"\n" 表示包含 '\' 和 'n' 兩個字元的字串，而 "\n" 則表示只包含一個換行符的字串。

print("\\n") # 輸出 \n
print(r"\n") #輸出 \n

re模組的使用：import re

re.match函數

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

pattern

匹配的正規表示式

string

要匹配的字串

flags

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

re.I 忽略大小寫
re.L 表示特殊字元集 \w, \W, \b, \B, \s, \S 依賴於當前環境
re.M 多行模式
re.S 即為 . 並且包括換行符在內的任意字元（. 不包括換行符）
re.U 表示特殊字元集 \w, \W, \b, \B, \d, \D, \s, \S 依賴於 Unicode 字元屬性資料庫
re.X 為了增加可讀性，忽略空格和 # 後面的註釋

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

如果上⼀步匹配到資料的話，可以使⽤group⽅法來提取資料。以使用group(num) 或 groups() 匹配物件函數來獲取匹配表示式。

group()用來提出分組截獲的字串，（）用來分組，group() 同group（0）就是匹配正規表示式整體結果，group(1) 列出第一個括號匹配部分，group(2) 列出第二個括號匹配部分，group(3) 列出第三個括號匹配部分。沒有匹配成功的，re.search()返回None。

舉例：

>>> import re
>>> result = re.match("itcast","itcast.cn")
>>> result.group()
'itcast'

從string頭開始匹配pattern完全可以匹配，pattern匹配結束，同時匹配終止，後面的.cn不再匹配，返回匹配成功的資訊。

匹配單個字元

字元	功能	位置
.	匹配任意1個字元（除了\n）
[ ]	匹配[ ]中列舉的字元
\d	匹配數位，即0-9	可以寫在字元集[...]中
\D	匹配⾮數位，即不是數位	可以寫在字元集[...]中
\s	匹配空⽩，即空格，tab鍵	可以寫在字元集[...]中
\S	匹配⾮空⽩字元	可以寫在字元集[...]中
\w	匹配單詞字元，即a-z、A-Z、0-9、_	可以寫在字元集[...]中
\W	匹配⾮單詞字元	可以寫在字元集[...]中
\w	\w 匹配單詞字元，即a-z、A-Z、0-9、_
\W	匹配⾮單詞字元

[...]字元集，對應的位置可以是字元集中任意字元。字元集中的字元可以逐個列出，也可以給出範圍，比如[abc]和[a-c]，第一個字元如果是^表示取反。所有特殊字元（比如"]""-""^"）在字元集中都失去原來的含義，如要使用可把"]""-"放在第一個字元，"^"放在非第一個字元。

舉例：

import re
ret = re.match(".","M")
print(ret.group())
ret = re.match("t.o","too")
print(ret.group())
ret = re.match("t.o","two")
print(ret.group())
# 如果hello的⾸字元⼩寫，那麼正規表示式需要⼩寫的h
ret = re.match("h","hello Python")
print(ret.group())
# 如果hello的⾸字元⼤寫，那麼正規表示式需要⼤寫的H
ret = re.match("H","Hello Python")
print(ret.group())
# ⼤⼩寫h都可以的情況
ret = re.match("[hH]","hello Python")
print(ret.group())
ret = re.match("[hH]","Hello Python")
print(ret.group())
ret = re.match("[hH]ello Python","Hello Python")
print(ret.group())
# 匹配0到9的多種寫法
ret = re.match("[0123456789]Hello Python","7Hello Python")
print(ret.group())
ret = re.match("[0-9]Hello Python","7Hello Python")
print(ret.group())
# 匹配0到3和5-9
ret = re.match("[0-35-9]Hello Python","7Hello Python")
print(ret.group())
ret = re.match("[0-35-9]Hello Python","4Hello Python")
#print(ret.group())
ret = re.match("嫦娥\d號","嫦娥1號發射成功")
print(ret.group())
ret = re.match("嫦娥\d號","嫦娥2號發射成功")
print(ret.group())

結果：

M
too
two
h
H
h
H
Hello Python
7Hello Python
7Hello Python
7Hello Python
嫦娥1號
嫦娥2號

匹配多個字元

字元	功能	位置	表示式範例	完整匹配的字串
*	匹配前⼀個字元出現0次或者⽆限次，即可有可⽆	用在字元或(...)之後	abc*	abccc
+	匹配前⼀個字元出現1次或者⽆限次，即⾄少有1次	用在字元或(...)之後	abc+	abccc
?	匹配前⼀個字元出現1次或者0次，即要麼有1次，要麼沒有	用在字元或(...)之後	abc?	ab,abc
{m}	匹配前⼀個字元出現m次	用在字元或(...)之後	ab{2}c	abbc
{m,n}	匹配前⼀個字元出現從m到n次，若省略m，則匹配0到n次，若省略n，則匹配m到無限次	用在字元或(...)之後	ab{1,2}c	abc,abbc

舉例：

import re
#：匹配出，⼀個字串第⼀個字⺟為⼤寫字元，後⾯都是⼩寫字⺟並且這些⼩寫字⺟可有可⽆
ret = re.match("[A-Z][a-z]*","M")
print(ret.group())
ret = re.match("[A-Z][a-z]*","MnnM")
print(ret.group())
ret = re.match("[A-Z][a-z]*","Aabcdef")
print(ret.group())
#匹配出，變數名是否有效
names = ["name1", "_name", "2_name", "__name__"]
for name in names:
    ret = re.match("[a-zA-Z_]+[\w]*",name)
    if ret:
        print("變數名 %s 符合要求" % ret.group())
    else:
        print("變數名 %s ⾮法" % name)
#匹配出，0到99之間的數位
ret = re.match("[1-9]?[0-9]","7")
print(ret.group())
ret = re.match("[1-9]?\d","33")
print(ret.group())
# 這個結果並不是想要的，利⽤$才能解決
ret = re.match("[1-9]?\d","09")
print(ret.group())
ret = re.match("[a-zA-Z0-9_]{6}","12a3g45678")
print(ret.group())
#匹配出，8到20位的密碼，可以是⼤⼩寫英⽂字⺟、數位、下劃線
ret = re.match("[a-zA-Z0-9_]{8,20}","1ad12f23s34455ff66")
print(ret.group())

結果：
M
Mnn
Aabcdef
變數名 name1 符合要求
變數名 _name 符合要求
變數名 2_name ⾮法
變數名 __name__ 符合要求
7
33
0
12a3g4
1ad12f23s34455ff66

匹配開頭結尾

字元	功能
^	匹配字串開頭
$	匹配字串結尾

舉例：匹配163.com的郵箱地址

import re
email_list = ["[email protected]", "[email protected]", "[email protected]"]
for email in email_list:
    ret = re.match("[\w]{4,20}@163\.com$", email)
    if ret:
        print("%s 是符合規定的郵件地址,匹配後的結果是:%s" % (email, ret.group()))
    else:
        print("%s 不符合要求" % email)

結果：

[email protected] 是符合規定的郵件地址,匹配後的結果是:[email protected]
[email protected] 不符合要求
[email protected] 不符合要求

匹配分組

字元	功能
\|	匹配左右任意⼀個表示式
(ab)	將括號中字元作為⼀個分組
\num	引⽤分組num匹配到的字串
(?P<name>)	分組起別名，匹配到的子串組在外部是通過定義的 name 來獲取的
(?P=name)	引⽤別名為name分組匹配到的字串

舉例：|

#匹配出0-100之間的數位
import re
ret = re.match("[1-9]?\d$|100","8")
print(ret.group()) # 8
ret = re.match("[1-9]?\d$|100","78")
print(ret.group()) # 78
ret = re.match("[1-9]?\d$|100","08")
# print(ret.group()) # 不是0-100之間
ret = re.match("[1-9]?\d$|100","100")
print(ret.group()) # 100

舉例：()

#需求：匹配出163、126、qq郵箱
ret = re.match("\w{4,20}@163\.com", "[email protected]")
print(ret.group()) # [email protected]
ret = re.match("\w{4,20}@(163|126|qq)\.com", "[email protected]")
print(ret.group()) # [email protected]
ret = re.match("\w{4,20}@(163|126|qq)\.com", "[email protected]")
print(ret.group()) # [email protected]
ret = re.match("\w{4,20}@(163|126|qq)\.com", "[email protected]")
if ret:
    print(ret.group())
else:
    print("不是163、126、qq郵箱") # 不是163、126、qq郵箱
#不是以4、7結尾的⼿機號碼(11位)
tels = ["13100001234", "18912344321", "10086", "18800007777"]
for tel in tels:
    ret = re.match("1\d{9}[0-35-68-9]", tel)
    if ret:
        print(ret.group())
    else:
        print("%s 不是想要的⼿機號" % tel)
#提取區號和電話號碼
ret = re.match("([^-]*)-(\d+)","010-12345678")
print(ret.group())
print(ret.group(1))
print(ret.group(2))

舉例：\number

匹配數位代表的組合。每個括號是一個組合，組合從1開始編號。比如 (.+) \1 匹配 'the the' 或者 '55 55', 但不會匹配 'thethe' (注意組合後面的空格)。這個特殊序列只能用於匹配前面99個組合。如果 number 的第一個數位是0，或者 number 是三個八進位制數，它將不會被看作是一個組合，而是八進位制的數位值。在 '[' 和 ']' 字元集合內，任何數位跳脫都被看作是字元。

例子1：匹配出 <html>hh</html>

\1,...,\9，匹配第n個分組的內容。如例子所示，指匹配第一個分組的內容。

import re
# 正確的理解思路：如果在第⼀對<>中是什麼，按理說在後⾯的那對<>中就應該是什麼。通過引⽤分組中匹配到的資料即可，但是要注意是元字串，即類似 r""這種格式。
ret = re.match(r"<([a-zA-Z]*)>\w*</\1>", "<html>hh</html>")
# 因為2對<>中的資料不⼀致，所以沒有匹配出來
test_label = ["<html>hh</html>","<html>hh</htmlbalabala>"]
for label in test_label:
    ret = re.match(r"<([a-zA-Z]*)>\w*</\1>", label)
    if ret:
        print("%s 這是一對正確的標籤" % ret.group())
    else:
        print("%s 這是⼀對不正確的標籤" % label)

結果：

<html>hh</html> 這是一對正確的標籤
<html>hh</htmlbalabala> 這是⼀對不正確的標籤

例子2：匹配出 <html><h1>www.itcast.cn</h1></html>

import re
labels = ["<html><h1>www.itcast.cn</h1></html>", "<html><h1>www.itcast.cn</h2></html>"]
for label in labels:
    ret = re.match(r"<(\w*)><(\w*)>.*</\2></\1>", label)
    if ret:
        print("%s 是符合要求的標籤" % ret.group())
    else:
        print("%s 不符合要求" % label)

結果：

<html><h1>www.itcast.cn</h1></html> 是符合要求的標籤
<html><h1>www.itcast.cn</h2></html> 不符合要求

舉例：(?P<name>) (?P=name)

一個用於標記，一個用於在同一個正規表示式中複用

import re
ret = re.match(r"<(?P<name1>\w*)><(?P<name2>\w*)>.*</(?P=name2)></(?P=name1)>","<html><h1>www.itcast.cn</h1></html>")
ret.group()
ret = re.match(r"<(?P<name1>\w*)><(?P<name2>\w*)>.*</(?P=name2)></(?P=name1)>","<html><h1>www.itcast.cn</h2></html>")
#ret.group()

re.compile 函數

compile 函數用於編譯正規表示式，生成一個正規表示式（ Pattern ）物件，供 match() 和 search() 這兩個函數使用。

prog = re.compile(pattern)
result = prog.match(string)

等價於

result = re.match(pattern, string)

舉例：

>>>import re
>>> pattern = re.compile(r'\d+')   
m = pattern.match('one12twothree34four', 3, 10) # 從'1'的位置開始匹配，正好匹配
>>> print m                                         # 返回一個 Match 物件
<_sre.SRE_Match object at 0x10a42aac0>
>>> m.group(0)   # 可省略 0
'12'
>>> m.start(0)   # 可省略 0
3
>>> m.end(0)     # 可省略 0
5
>>> 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))

re.search函數

re.search 掃描整個字串並返回第一個成功的匹配，如果沒有匹配，就返回一個 None。

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

舉例：

import re
ret = re.search(r"\d+", "閱讀次數為9999")
print(ret.group())

結果：

9999

re.findall函數

在字串中找到正規表示式所匹配的所有子串，並返回一個列表，如果沒有找到匹配的，則返回空列表。注意： match 和 search 是匹配一次 findall 匹配所有。

舉例：

import re
ret = re.findall(r"\d+", "python = 9999, c = 7890, c++ = 12345")
print(ret)

結果：

['9999', '7890', '12345']

re.finditer函數

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

import re
it = re.finditer(r"\d+", "12a32bc43jf3")
for match in it:
    print(match.group())

結果：

12
32
43
3

re.sub函數

sub是substitute的所寫，表示替換，將匹配到的資料進⾏替換。

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

引數	描述
pattern	必選，表示正則中的模式字串
repl	必選，就是replacement，要替換的字串，也可為一個函數
string	必選，被替換的那個string字串
count	可選引數，count 是要替換的最大次數，必須是非負整數。如果省略這個引數或設為 0，所有的匹配都會被替換
flag	可選引數，標誌位，用於控制正規表示式的匹配方式，如：是否區分大小寫，多行匹配等等。

舉例：將匹配到的閱讀次數加1

方法一：

import re
ret = re.sub(r"\d+", '998', "python = 997")
print(ret)

結果：python = 998

方法二：

import re
def add(temp):
    #int（）引數必須是字串，類似位元組的物件或數位，而不是「re.Match」
    strNum = temp.group()
    num = int(strNum) + 1
    return str(num)
ret = re.sub(r"\d+", add, "python = 997")
print(ret)
ret = re.sub(r"\d+", add, "python = 99")
print(ret)

結果;

python = 998
python = 100

re.subn函數

行為與sub()相同，但是返回一個元組 (字串, 替換次數)。

re.subn(pattern, repl, string[, count])

返回：(sub(repl, string[, count]), 替換次數)

import re
pattern = re.compile(r'(\w+) (\w+)')
s = 'i say, hello world!'
print(re.subn(pattern, r'\2 \1', s))
def func(m):
    return m.group(1).title() + ' ' + m.group(2).title()
print(re.subn(pattern, func, s))
### output ###
# ('say i, world hello!', 2)
# ('I Say, Hello World!', 2)

re.split函數

根據匹配進⾏切割字串，並返回⼀個列表。

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

引數	描述
pattern	匹配的正規表示式
string	要匹配的字串
maxsplit	分隔次數，maxsplit=1 分隔一次，預設為 0，不限制次數

舉例：

import re
ret = re.split(r":| ","info:xiaoZhang 33 shandong")
print(ret)

結果：['info', 'xiaoZhang', '33', 'shandong']

python貪婪和⾮貪婪

Python⾥數量詞預設是貪婪的（在少數語⾔⾥也可能是預設⾮貪婪），總是嘗試匹配儘可能多的字元；⾮貪婪則相反，總是嘗試匹配儘可能少的字元。

例如：正規表示式」ab*」如果用於查詢」abbbc」，將找到」abbb」。而如果使用非貪婪的數量詞」ab*?」，將找到」a」。

注：我們一般使用非貪婪模式來提取。

在"*","?","+","{m,n}"後⾯加上？，使貪婪變成⾮貪婪。

舉例1：

import re
s="This is a number 234-235-22-423"
#正規表示式模式中使⽤到通配字，那它在從左到右的順序求值時，會盡量「抓取」滿⾜匹配最⻓字串，在我們上⾯的例⼦⾥⾯，「.+」會從字串的啟始處抓取滿⾜模式的最⻓字元，其中包括我們想得到的第⼀個整型欄位的中的⼤部分，「\d+」只需⼀位字元就可以匹配，所以它匹配了數位「4」，⽽「.+」則匹配了從字串起始到這個第⼀位數位4之前的所有字元
r=re.match(".+(\d+-\d+-\d+-\d+)",s)
print(r.group(1))
#⾮貪婪操作符「？」，這個操作符可以⽤在"*","+","?"的後⾯，要求正則匹配的越少越好
r=re.match(".+?(\d+-\d+-\d+-\d+)",s)
print(r.group(1))

結果：

4-235-22-423
234-235-22-423

舉例2：

>>> re.match(r"aa(\d+)","aa2343ddd").group(1)
'2343'
>>> re.match(r"aa(\d+?)","aa2343ddd").group(1)
'2'
>>> re.match(r"aa(\d+)ddd","aa2343ddd").group(1)
'2343'
>>> re.match(r"aa(\d+?)ddd","aa2343ddd").group(1)
'2343'

舉例3：提取圖片地址

import re
test_str="<img src=https://rpic.douyucdn.cn/appCovers/2016/11/13/1213973.jpg>"
ret = re.search(r"https://.*?.jpg", test_str)
print(ret.group())

結果：https://rpic.douyucdn.cn/appCovers/2016/11/13/1213973.jpg

r的作⽤

與大多數程式語言相同，正規表示式裡使用」\」作為跳脫字元，這就可能造成反斜槓困擾。假如你需要匹配文字中的字元」\」，那麼使用程式語言表示的正規表示式裡將需要4個反斜槓」\\\\」：前兩個和後兩個分別用於在程式語言裡跳脫成反斜槓，轉換成兩個反斜槓後再在正規表示式裡跳脫成一個反斜槓。Python裡的原生字串很好地解決了這個問題，Python中字串前⾯加上 r 表示原⽣字串。

import re
mm = "c:\\a\\b\\c"
print(mm)#c:\a\b\c
ret = re.match("c:\\\\",mm).group()
print(ret)#c:\
ret = re.match("c:\\\\a",mm).group()
print(ret)#c:\a
ret = re.match(r"c:\\a",mm).group()
print(ret)#c:\a
ret = re.match(r"c:\a",mm).group()
print(ret)#AttributeError: 'NoneType' object has no attribute 'group'

推薦學習：

以上就是詳細解析python正規表示式re模組的詳細內容，更多請關注TW511.COM其它相關文章！