站長資訊網正則表達式是處理字符串的強大工具，擁有獨特的語法和獨立的處理引擎。下面本篇文章就來給大家介紹一下python中的正則表達式（re模塊），希望對大家有所幫助！
程序員必備接口測試調試工具：立即使用
Apipost = Postman + Swagger + Mock + Jmeter
Api設計、調試、文檔、自動化測試工具
后端、前端、測試，同時在線協作，內容實時同步
在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 |
標志位，用于控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等等。
|
嘗試從字符串的起始位置匹配一個模式，如果不是起始位置匹配成功的話，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 = ["xiaoWang@163.com", "xiaoWang@163.comheihei", ".com.xiaowang@qq.com"] 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)
結果：
xiaoWang@163.com 是符合規定的郵件地址,匹配后的結果是:xiaoWang@163.com xiaoWang@163.comheihei 不符合要求 .com.xiaowang@qq.com 不符合要求
匹配分組
| 字符 | 功能 |
| | | 匹配左右任意?個表達式 |
| (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", "test@163.com") print(ret.group()) # test@163.com ret = re.match("w{4,20}@(163|126|qq).com", "test@126.com") print(ret.group()) # test@126.com ret = re.match("w{4,20}@(163|126|qq).com", "test@qq.com") print(ret.group()) # test@qq.com ret = re.match("w{4,20}@(163|126|qq).com", "test@gmail.com") 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("1d{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:abc 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'
【
