正則表達式是文本匹配模式，也就是按照固定模式匹配文本

一、導入

re模塊是Python環(huán)境的內(nèi)置模塊，所以無需手動安裝。直接在文件中導入即可：

import re

---

二、正則表達式基礎知識

. 匹配除換行符以外的任意字符

^ 匹配字符串的開始

$ 匹配字符串的結尾

* 匹配前面的子表達式零次或多次

+ 匹配前面的子表達式一次或多次

? 匹配前面的子表達式零次或一次

{n} n 是一個非負整數(shù)。匹配確定的 n 次

{n,} n 是一個非負整數(shù)。至少匹配n 次

{n,m} m 和 n 均為非負整數(shù)，其中n <= m。最少匹配 n 次且最多匹配 m 次

[xyz] 字符集合。匹配所包含的任意一個字符 [^xyz] 負值字符集合。匹配未包含的任意字符

\d 匹配一個數(shù)字字符。等價于 [0-9]

\D 匹配一個非數(shù)字字符。等價于 [^0-9]

\s 匹配任何空白字符，包括空格、制表符、換頁符等等。等價于 [\f\n\r\t\v]

\S 匹配任何非空白字符。等價于 [^\f\n\r\t\v]

\w 匹配包括下劃線的任何單詞字符。等價于'[A-Za-z0-9_]'

\W 匹配任何非單詞字符。等價于 '[^A-Za-z0-9_]'

---

例如：

有一個字符串：python pytttthon

正則表達式格式為：pyt{4}hon

那么只有"pytttthon"匹配到

如果正則表達式為：pyt{1,4}hon

那么匹配到的字符串就是python和pytttthon

三、compile

compile()函數(shù)用于編譯一個字符串形式的正則表達式，將其轉(zhuǎn)換為一個模式對象（Pattern object）。這個模式對象具有匹配（match()）、搜索（search()）、查找所有（findall()）、查找迭代（finditer()）以及分割（split()）等方法，用于對字符串進行各種基于正則表達式的操作。

案例：

import re
pattern=re.compile(r'\d+')
print(pattern)

上述代碼編譯了一個字符串：‘\d+’為正則表達式，字符串前的r:代表是原始字符，通常與轉(zhuǎn)義字符聯(lián)用，當不加r時使用轉(zhuǎn)義字符需要使用兩個\，并返回一個對象給pattern。這個正則表達式的意義為：找到一個數(shù)字或多個數(shù)字的字符串。輸出pattern：

re.compile('\\d+')

四、compile中的方法使用

1、match方法

match方法是用來按順序從頭匹配字符串的。不會全部匹配，而是找到第一個符合正則格式的字符串就返回。

案例1：

import re
pattern=re.compile(r'\d+')
m1=pattern.match('one123two457three89')
#因為o不是數(shù)字，所以無匹配數(shù)據(jù)
print(m1)

.match中是要匹配格式的字符串，通過上文，我們可知，這個代碼是要找一個帶有數(shù)字的字符串，且match是從頭開始匹配，所以在匹配第一個字符時發(fā)現(xiàn)不是數(shù)字，所以直接返回。

導致輸出結果為：None

案例2，按索引查詢：

import re
pattern=re.compile(r'\d+')
m1=pattern.match('one123two457three89',3,6)
print(m1.group())#通過group查看匹配的數(shù)據(jù)

match函數(shù)的參數(shù)：（要匹配的字符串，開始索引，結束索引），開始和結束索引是前閉后開集合，也就是包括開始索引字符，不包括結束索引字符。上述代碼實現(xiàn)了從索引值為3的字符開始，到6結束，不包括6。.group是查看匹配的數(shù)據(jù)

輸出：123

如果不寫.group輸出：<re.Match object; span=(3, 6), match='123'>

2、search方法

search方法也是搜索匹配字符串，但是與match不同，他是整體的字符串匹配，但只返回第一個匹配的字符串。

import re
pattern=re.compile(r'\d+')
s1=pattern.search('one123two457three89')
print(s1)

輸出：123。因為search不是從頭開始嚴格匹配，所以就會匹配到123。

3、findall方法

findall也是用來檢索匹配字符串的，而且他會返回所有符合條件的字符串。并且返回一個列表。

案例：

import re
pattern=re.compile(r'\d+')
f1=pattern.findall('one123two457three89')
print(f1)

上述代碼是要匹配所有是數(shù)字的字符串，但返回的是一個列表，所以輸出形式為：

['123', '457', '89']

4、split方法

split方法是分隔字符串的，并且返回一個列表。這個方法不歸屬于正則表達式。

比如我們要按逗號分隔一個字符串：

import re
str='a,b,c'
print(str.split(','))

那么我們就可以得到一個列表：['a', 'b', 'c']

但是如果分隔符是多種的，我們就需要用到正則表達式了

案例：

import re
str='a,b;;c d'
pattern=re.compile(r'[\s\,\;]+')
print(pattern.split(str))

如果我們要將str中的abcd作為單獨元素分隔，但他們之間的分隔符不一樣，那么我們就可以將分隔符寫到正則表達式中。上述代碼將空格逗號分號作為分隔符寫入正則表達式。那么我們將返回的pattern對象打點調(diào)用split就可以按照pattern格式分隔，split（）括號中填入要分割的字符串。因為字符串中可能兩個或多個分隔符連著使用，所以后邊加上一個加號用來匹配一次或多次。

輸出：['a', 'b', 'c', 'd']

5、sub方法

sub方法是用來替換字符串的，sub方法中有三個參數(shù)：參數(shù)一：替換后的值，參數(shù)二：原值,參數(shù)三：替換幾個。參數(shù)一既可以傳值也可以穿函數(shù)

案例1：

string='<h1 class="test">1 helloworld</h1>'
pattern=re.compile(r'\d')
print(pattern.sub('2',string))
print(pattern.sub('2',string,1))

上述代碼的第一個sub方法是要將string字符串中的所有數(shù)字都換成2，第二個sub方法是將string字符串中的第一個數(shù)字替換成2。

輸出：<h2 class="test">2 helloworld</h2>
???????????<h2 class="test">1 helloworld</h1>

五、分組

.group方法是將檢索出來的字符串按組取出

在寫正則表達式時我們可以將字符串進行分組

案例：

string='<h1 class="test">1 helloworld</h1>'
pattern=re.compile(r'<(.\d)\sclass="(.*?)">.*?</(.1)>')#p給組起名字:classname,可以通過名字調(diào)用該組
print(pattern.search(string).group(1))

上述代碼的結果：test。在寫正則表達式時我們可以用括號對字符串進行分組，數(shù)字代表第幾組，上述代碼是要第一組，也就是class后面括號內(nèi)的內(nèi)容，在匹配時，匹配到class后邊的組括號。

我們也可以給組起名，用分組名：

pattern=re.compile(r'<(.\d)\sclass="(?P<classname>.*?)">.*?</(.1)>')
print(pattern.search(string).group('classname'))

上述代碼跟上一個案例的結果一樣

sub方法補充（參數(shù)一傳函數(shù)時）：

sub方法中 參數(shù)1函數(shù)名，是對字符串的替換規(guī)則。參數(shù)2是要操作的字符串，將sub(str)的結果傳入到第一個參數(shù)中，返回第一個參數(shù)的結果。將匹配的結果傳入func方法中，對傳入的數(shù)據(jù)操作，這個方法的內(nèi)容就是替換規(guī)則。替換后的語句就是func的返回值。

import re
string='<h1 class="test">1 helloworld</h1>'
pattern=re.compile(r'<(.\d)\sclass="(?P<classname>.*?)">.*?</(.1)>')
def func(m):#m是要匹配的格式return "after sub:"+m.group('classname')
#sub方法中傳入函數(shù)
#參數(shù)一：函數(shù)名，參數(shù)二：原字符串
print(pattern.sub(func,string))

上述代碼輸出：after sub:test

六、防止貪婪模式：？

import re
string='<h1 class="test">1 helloworld</h1>'
pattern=re.compile(r'<.\d\sclass=.*>')
print(pattern.search(string).group())
#'?'防止貪婪匹配
pattern=re.compile(r'<.\d\sclass=.*?>')
print(pattern.search(string).group())

上述代碼第一個輸出語句為string完整字符串，而第二個輸出語句為：<h1 class="test">。因為第一個是貪婪模式，當出現(xiàn)重復的結尾字符時，他會匹配到最后一個>符號，而加上問號，他會匹配到離他最近的那個。