文章來源與：http://www.cnblogs.com/zjltt/p/6955965.html

正則表達式

正則表達式本身是一種小型的、高度專業化的編程語言，而在python中，通過內嵌集成re模塊，程序員們可以直接調用來實現正則匹配。正則表達式模式被編譯成一系列的字節碼，然后由用C編寫的匹配引擎執行。

正則表達式是用來匹配處理字符串的python 中使用正則表達式需要引入re模塊

如：

import re #第一步，要引入re模塊

a = re.findall("匹配規則", "要匹配的字符串") #第二步，調用模塊函數

以列表形式返回匹配到的字符串

如：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模塊
a = re.findall("匹配規則", "這個字符串是否有匹配規則的字符")   #第二步，調用模塊函數
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹配規則']

View Code

^元字符

字符串開始位置與匹配規則符合就匹配，否則不匹配

匹配字符串開頭。在多行模式中匹配每一行的開頭

^元字符如果寫到[]字符集里就是反取

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模塊
a = re.findall("^匹配規則", "匹配規則這個字符串是否匹配")   #字符串開始位置與匹配規則符合就匹配，否則不匹配
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹配規則']

View Code

[^a-z]反取，匹配出除字母外的字符，^元字符如果寫到字符集里就是反取

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模塊
a = re.findall("[^a-z]", "匹配s規則這s個字符串是否s匹配f規則則re則則則")   #反取，匹配出除字母外的字符
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹', '配', '規', '則', '這', '個', '字', '符', '串', '是', '否', '匹', '配', '規', '則', '則', '則', '則', '則']

View Code

$元字符

字符串結束位置與匹配規則符合就匹配，否則不匹配

匹配字符串末尾，在多行模式中匹配每一行的末尾

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模塊
a = re.findall("匹配規則$", "這個字符串是否匹配規則")   #字符串結束位置與匹配規則符合就匹配，否則不匹配
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹配規則']

View Code

*元字符

需要字符串里完全符合，匹配規則，就匹配，（規則里的*元字符）前面的一個字符可以是0個或多個原本字符

匹配前一個字符0或多次，貪婪匹配前導字符有多少個就匹配多少個很貪婪

如果規則里只有一個分組，盡量避免用*否則會有可能匹配出空字符串

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模塊
a = re.findall("匹配規則*", "這個字符串是否匹配規則則則則則")   #需要字符串里完全符合，匹配規則，就匹配，（規則里的*元字符）前面的一個字符可以是0或多個原本字符
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹配規則則則則則']

View Code

+元字符

需要字符串里完全符合，匹配規則，就匹配，（規則里的+元字符）前面的一個字符可以是1個或多個原本字符

匹配前一個字符1次或無限次，貪婪匹配前導字符有多少個就匹配多少個很貪婪

#!/usr/bin/env python
# -*- coding:gbk -*-
import re   #第一步，要引入re模塊
a = re.findall("匹配+", "匹配配配配配規則這個字符串是否匹配規則則則則則")   #需要字符串里完全符合，匹配規則，就匹配，（規則里的+元字符）前面的一個字符可以是1個或多個原本字符
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹配配配配配', '匹配']

View Code

?元字符，和防止貪婪匹配

需要字符串里完全符合，匹配規則，就匹配，（規則里的?元字符）前面的一個字符可以是0個或1個原本字符

匹配一個字符0次或1次

還有一個功能是可以防止貪婪匹配，詳情見防貪婪匹配

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模塊
a = re.findall("匹配規則?", "匹配規這個字符串是否匹配規則則則則則")   #需要字符串里完全符合，匹配規則，就匹配，（規則里的?元字符）前面的一個字符可以是0個或1個原本字符
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹配規', '匹配規則']

View Code

{}元字符,范圍

需要字符串里完全符合，匹配規則，就匹配，（規則里的{} 元字符）前面的一個字符，是自定義字符數，位數的原本字符

{m}匹配前一個字符m次，{m,n}匹配前一個字符m至n次，若省略n，則匹配m至無限次

{0,}匹配前一個字符0或多次,等同于*元字符
{+,}匹配前一個字符1次或無限次,等同于+元字符
{0,1}匹配前一個字符0次或1次,等同于?元字符

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模塊
a = re.findall("匹配規則{3}", "匹配規這個字符串是否匹配規則則則則則")   #{m}匹配前一個字符m次，{m,n}匹配前一個字符m至n次，若省略n，則匹配m至無限次
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹配規則則則']

View Code

[]元字符,字符集

需要字符串里完全符合，匹配規則，就匹配，（規則里的[] 元字符）對應位置是[]里的任意一個字符就匹配

字符集。對應的位置可以是字符集中任意字符。字符集中的字符可以逐個列出，也可以給出范圍，如[abc]或[a-c]。[^abc]表示取反，即非abc。
所有特殊字符在字符集中都失去其原有的特殊含義。用反斜杠轉義恢復特殊字符的特殊含義。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模塊
a = re.findall("匹配[a,b,c]規則", "匹配a規則這個字符串是否匹配b規則則則則則")   #需要字符串里完全符合，匹配規則，就匹配，（規則里的 [] 元字符）對應位置是[]里的任意一個字符就匹配
print(a)  #以列表形式返回匹配到的字符串

View Code

[^]非，反取，匹配出除[^]里面的字符，^元字符如果寫到字符集里就是反取

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模塊
a = re.findall("[^a-z]", "匹配s規則這s個字符串是否s匹配f規則則re則則則")   #反取，匹配出除字母外的字符
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹', '配', '規', '則', '這', '個', '字', '符', '串', '是', '否', '匹', '配', '規', '則', '則', '則', '則', '則']

View Code

反斜杠后邊跟普通字符實現特殊功能；（即預定義字符）

預定義字符是在字符集和組里都是有用的

d匹配任何十進制數，它相當于類[0-9]

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模塊
a = re.findall("d", "匹配規則這2個字符串3是否匹配規則5則則則7則")   #d匹配任何十進制數，它相當于類[0-9]
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['2', '3', '5', '7']

View Code

d+如果需要匹配一位或者多位數的數字時用

#!/usr/bin/env python
# -*- coding:gbk -*-
import re   #第一步，要引入re模塊
a = re.findall("d+", "匹配規則這2個字符串134444是否匹配規則5則則則7則")   #d+如果需要匹配一位或者多位數的數字時用
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['2', '134444', '5', '7']

View Code

D匹配任何非數字字符，它相當于類[^0-9]

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模塊
a = re.findall("D", "匹配規則這2個字符串3是否匹配規則5則則則7則")   #D匹配任何非數字字符，它相當于類[^0-9]
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹', '配', '規', '則', '這', '個', '字', '符', '串', '是', '否', '匹', '配', '規', '則', '則', '則', '則', '則']

View Code

s匹配任何空白字符，它相當于類[
fv]

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模塊
a = re.findall("s", "匹配規則   這2個字符串3是否匹
配規則5則則則7則")   #s匹配任何空白字符，它相當于類[	
fv]
print(a)  #以列表形式返回匹配到的字符串
#打印出[' ', ' ', ' ', '
']

View Code

S匹配任何非空白字符，它相當于類[^
fv]

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模塊
a = re.findall("S", "匹配規則   這2個字符串3是否匹
配規則5則則則7則")   #S匹配任何非空白字符，它相當于類[^	
fv]
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹', '配', '規', '則', '這', '2', '個', '字', '符', '串', '3', '是', '否', '匹', '配', '規', '則', '5', '則', '則', '則', '7', '則']

View Code

w匹配包括下劃線在內任何字母數字字符，它相當于類[a-zA-Z0-9_]

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re   #第一步，要引入re模塊
a = re.findall('w',"https://www.cnblogs.com/")  #w匹配包括下劃線在內任何字母數字字符，它相當于類[a-zA-Z0-9_]
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['h', 't', 't', 'p', 's', 'w', 'w', 'w', 'c', 'n', 'b', 'l', 'o', 'g', 's', 'c', 'o', 'm']

View Code

W匹配非任何字母數字字符包括下劃線在內，它相當于類[^a-zA-Z0-9_]

import re   #第一步，要引入re模塊
a = re.findall('W',"https://www.cnblogs.com/")  #w匹配包括下劃線在內任何字母數字字符，它相當于類[a-zA-Z0-9_]
print(a)  #以列表形式返回匹配到的字符串
#打印出[':', '/', '/', '.', '.', '/']

View Code

()元字符，分組

也就是分組匹配，()里面的為一個組也可以理解成一個整體

如果()后面跟的是特殊元字符如 (adc)* 那么*控制的前導字符就是()里的整體內容，不再是前導一個字符

列1

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re   #第一步，要引入re模塊
#也就是分組匹配，()里面的為一個組也可以理解成一個整體
a = re.search("(a4)+", "a4a4a4a4a4dg4g654gb")   #匹配一個或多個a4
b = a.group()
print(b)
#打印出 a4a4a4a4a4

View Code

列2

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re   #第一步，要引入re模塊
#也就是分組匹配，()里面的為一個組也可以理解成一個整體
a = re.search("a(d+)", "a466666664a4a4a4dg4g654gb")    #匹配 (a) (d0-9的數字) (+可以是1個到多個0-9的數字)
b = a.group()
print(b)
#打印出 a466666664

View Code

|元字符，或

|或，或就是前后其中一個符合就匹配

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re   #第一步，要引入re模塊
a = re.findall(r"你|好", "a4a4a你4aabc4a4dgg好dg4g654g")   #|或，或就是前后其中一個符合就匹配
print(a)
#打印出 ['你', '好']

View Code

r原生字符

將在python里有特殊意義的字符如，轉換成原生字符（就是去除它在python的特殊意義），不然會給正則表達式有沖突，為了避免這種沖突可以在規則前加原始字符r

re模塊中常用功能函數

正則表達式有兩種書寫方式，一種是直接在函數里書寫規則，

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模塊
a = re.findall("匹配規則", "這個字符串是否有匹配規則的字符")   #第二步，調用模塊函數
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹配規則']

View Code

match()函數（以后常用）

match，從頭匹配一個符合規則的字符串，從起始位置開始匹配，匹配成功返回一個對象，未匹配成功返回None
match(pattern, string, flags=0)
# pattern： 正則模型
# string ： 要匹配的字符串
# falgs ： 匹配模式

注意：match()函數 與search()函數基本是一樣的功能，不一樣的就是match()匹配字符串開始位置的一個符合規則的字符串，search()是在字符串全局匹配第一個合規則的字符串

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
#無分組
origin = "hello egon bcd egon lge egon acd 19"
r = re.match("hw+", origin)    #match，從起始位置開始匹配，匹配成功返回一個對象，未匹配成功返回None
print(r.group())     # 獲取匹配到的所有結果，不管有沒有分組將匹配到的全部拿出來
print(r.groups())    # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分的結果
print(r.groupdict()) # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分定義了key的組結果
#輸出結果
# hello     匹配到的全部拿出來
# ()        沒有分組所以為空
# {}        沒分組部分定義了key的組所以為空


# 有分組
# 為何要有分組？提取匹配成功的指定內容（先匹配成功全部正則，再匹配成功的局部內容提取出來）
r = re.match("h(w+)", origin)   #match，從起始位置開始匹配，匹配成功返回一個對象，未匹配成功返回None
print(r.group())     # 獲取匹配到的所有結果，不管有沒有分組將匹配到的全部拿出來
print(r.groups())    # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分的結果
print(r.groupdict()) # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分定義了key的組結果
#輸出結果
# hello         匹配到的全部拿出來
# ('ello',)     有分組，在匹配到的字符串中拿出分組的部分
# {}            沒分組部分定義了key的組所以為空


# 有兩個分組定義了key
# 為何要有分組？提取匹配成功的指定內容（先匹配成功全部正則，再匹配成功的局部內容提取出來）
r = re.match("(?P<n1>h)(?P<n2>w+)", origin)   #?P<>定義組里匹配內容的key(鍵)，<>里面寫key名稱，值就是匹配到的內容
print(r.group())     # 獲取匹配到的所有結果，不管有沒有分組將匹配到的全部拿出來
print(r.groups())    # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分的結果
print(r.groupdict()) # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分定義了key的組結果
#輸出結果
# hello                         匹配到的全部拿出來
# ('h', 'ello')                 有分組，在匹配到的字符串中拿出分組的部分
# {'n1': 'h', 'n2': 'ello'}     有定義了key的組所以，將定義了key的組里的內容以字典形式拿出來

View Code

?P<n1> #?P<>定義組里匹配內容的key(鍵)，<>里面寫key名稱，值就是匹配到的內容（只對正則函數返回對象的有用）

取出匹配對象方法

只對正則函數返回對象的有用

group() # 獲取匹配到的所有結果，不管有沒有分組將匹配到的全部拿出來，有參取匹配到的第幾個如2
groups() # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分的結果
groupdict() # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分定義了key的組結果

search()函數
search,瀏覽全部字符串，匹配第一符合規則的字符串，瀏覽整個字符串去匹配第一個，未匹配成功返回None
search(pattern, string, flags=0)
# pattern： 正則模型
# string ： 要匹配的字符串
# falgs ： 匹配模式

注意：match()函數 與search()函數基本是一樣的功能，不一樣的就是match()匹配字符串開始位置的一個符合規則的字符串，search()是在字符串全局匹配第一個合規則的字符串

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
#無分組
origin = "hello alex bcd alex lge alex acd 19"
r = re.search("aw+", origin)    #search瀏覽全部字符串，匹配第一符合規則的字符串，瀏覽整個字符串去匹配第一個，未匹配成功返回None
print(r.group())     # 獲取匹配到的所有結果，不管有沒有分組將匹配到的全部拿出來
print(r.groups())    # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分的結果
print(r.groupdict()) # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分定義了key的組結果
#輸出結果
# alex     匹配到的全部拿出來
# ()        沒有分組所以為空
# {}        沒分組部分定義了key的組所以為空


# 有分組
# 為何要有分組？提取匹配成功的指定內容（先匹配成功全部正則，再匹配成功的局部內容提取出來）
r = re.search("a(w+).*(d)", origin)
print(r.group())     # 獲取匹配到的所有結果，不管有沒有分組將匹配到的全部拿出來
print(r.groups())    # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分的結果
print(r.groupdict()) # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分定義了key的組結果
#輸出結果
# alex bcd alex lge alex acd 19       匹配到的全部拿出來
# ('lex', '9')     有分組，在匹配到的字符串中拿出分組的部分
# {}            沒分組部分定義了key的組所以為空


# 有兩個分組定義了key
# 為何要有分組？提取匹配成功的指定內容（先匹配成功全部正則，再匹配成功的局部內容提取出來）
r = re.search("a(?P<n1>w+).*(?P<n2>d)", origin)   #?P<>定義組里匹配內容的key(鍵)，<>里面寫key名稱，值就是匹配到的內容
print(r.group())     # 獲取匹配到的所有結果，不管有沒有分組將匹配到的全部拿出來
print(r.groups())    # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分的結果
print(r.groupdict()) # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分定義了key的組結果
#輸出結果
# alex bcd alex lge alex acd 19                         匹配到的全部拿出來
# ('lex', '9')                 有分組，在匹配到的字符串中拿出分組的部分
# {'n1': 'lex', 'n2': '9'}     有定義了key的組所以，將定義了key的組里的內容以字典形式拿出來

View Code

findall()函數（以后常用）

findall(pattern, string, flags=0)
# pattern： 正則模型
# string ： 要匹配的字符串
# falgs ： 匹配模式

瀏覽全部字符串，匹配所有合規則的字符串，匹配到的字符串放到一個列表中，未匹配成功返回空列表

注意：一旦匹配成，再次匹配，是從前一次匹配成功的，后面一位開始的，也可以理解為匹配成功的字符串，不在參與下次匹配

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
#無分組
r = re.findall("d+wd+", "a2b3c4d5")    #瀏覽全部字符串，匹配所有合規則的字符串，匹配到的字符串放到一個列表中
print(r)
#輸出結果
#['2b3', '4d5']
#注意：匹配成功的字符串，不在參與下次匹配,所以3c4也符合規則但是沒匹配到

View Code

注意：如果沒寫匹配規則，也就是空規則，返回的是一個比原始字符串多一位的，空字符串列表

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
#無分組
r = re.findall("", "a2b3c4d5")    #瀏覽全部字符串，匹配所有合規則的字符串，匹配到的字符串放到一個列表中
print(r)
#輸出結果
#['', '', '', '', '', '', '', '', '']
#注意：如果沒寫匹配規則，也就是空規則，返回的是一個比原始字符串多一位的，空字符串列表 

View Code

注意：正則匹配到空字符的情況，如果規則里只有一個組，而組后面是*就表示組里的內容可以是0個或者多過，這樣組里就有了兩個意思，一個意思是匹配組里的內容，二個意思是匹配組里0內容（即是空白）所以盡量避免用*否則會有可能匹配出空字符串

注意：正則只拿組里最后一位，如果規則里只有一個組，匹配到的字符串里在拿組內容是，拿的是匹配到的內容最后一位

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.findall("(a)*", origin)   
print(r)
#輸出結果 ['', '', '', '', '', '', 'a', '', '', '', '', '', '', '', '', 'a', '', '', '', '', '', '', '', '', 'a', '', '', '', '', 'a', '', '', '', '', '', '']

View Code

無分組：匹配所有合規則的字符串，匹配到的字符串放到一個列表中

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
#無分組
origin = "hello alex bcd alex lge alex acd 19"
r = re.findall("aw+", origin)    #瀏覽全部字符串，匹配所有合規則的字符串，匹配到的字符串放到一個列表中
print(r)
#輸出結果
#['alex', 'alex', 'alex', 'acd']
#匹配所有合規則的字符串，匹配到的字符串放到一個列表中

View Code

有分組：只將匹配到的字符串里，組的部分放到列表里返回，相當于groups()方法

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.findall("a(w+)", origin)    #有分組：只將匹配到的字符串里，組的部分放到列表里返回
print(r)
#輸出結果
#['lex', 'lex', 'lex', 'cd']

View Code

多個分組：只將匹配到的字符串里，組的部分放到一個元組中，最后將所有元組放到一個列表里返

相當于在group()結果里再將組的部分，分別，拿出來放入一個元組，最后將所有元組放入一個列表返回

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.findall("(a)(w+)", origin)    #多個分組：只將匹配到的字符串里，組的部分放到一個元組中，最后將所有元組放到一個列表里返回
print(r)
#輸出結果
#[('a', 'lex'), ('a', 'lex'), ('a', 'lex'), ('a', 'cd')]

View Code

分組中有分組：只將匹配到的字符串里，組的部分放到一個元組中，先將包含有組的組，看作一個整體也就是一個組，把這個整體組放入一個元組里，然后在把組里的組放入一個元組，最后將所有組放入一個列表返回

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.findall("(a)(w+(e))", origin)    #分組中有分組：只將匹配到的字符串里，組的部分放到一個元組中，先將包含有組的組，看作一個整體也就是一個組，把這個整體組放入一個元組里，然后在把組里的組放入一個元組，最后將所有組放入一個列表返回
print(r)
#輸出結果
#[('a', 'le', 'e'), ('a', 'le', 'e'), ('a', 'le', 'e')]

View Code

?:在有分組的情況下findall()函數，不只拿分組里的字符串，拿所有匹配到的字符串，注意?:只用于不是返回正則對象的函數如findall()

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
b = re.findall("a(?:w+)",origin) #?:在有分組的情況下，不只拿分組里的字符串，拿所有匹配到的字符串，注意?:只用于不是返回正則對象的函數如findall()
print(b)
#輸出
# ['alex', 'alex', 'alex', 'acd']

View Code

split()函數

根據正則匹配分割字符串，返回分割后的一個列表

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

# pattern： 正則模型
# string ： 要匹配的字符串
# maxsplit：指定分割個數
# flags ： 匹配模式

按照一個字符將全部字符串進行分割

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.split("a", origin) #根據正則匹配分割字符串
print(r)
#輸出結果 ['hello ', 'lex bcd ', 'lex lge ', 'lex ', 'cd 19']
#根據a進行分組

View Code

將匹配到的字符串作為分割標準進行分割

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex 2acd 19"
r = re.split("aw+", origin) #根據正則匹配分割字符串
print(r)
#輸出結果 ['hello ', ' bcd ', ' lge ', ' 2', ' 19']
#將匹配到的字符串作為分割標準進行分割

View Code

sub()函數

替換匹配成功的指定位置字符串

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

# pattern： 正則模型
# repl ： 要替換的字符串
# string ： 要匹配的字符串
# count ： 指定匹配個數
# flags ： 匹配模式

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.sub("a","替換",origin) #替換匹配成功的指定位置字符串
print(r)
#輸出
# hello 替換lex bcd 替換lex lge 替換lex 替換cd 19

View Code

subn()函數

替換匹配成功的指定位置字符串,并且返回替換次數，可以用兩個變量分別接受

subn(pattern, repl, string, count=0, flags=0)

# pattern： 正則模型
# repl ： 要替換的字符串
# string ： 要匹配的字符串
# count ： 指定匹配個數
# flags ： 匹配模式

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
a,b = re.subn("a","替換",origin) #替換匹配成功的指定位置字符串,并且返回替換次數，可以用兩個變量分別接受
print(a)
print(b)
#輸出
# hello 替換lex bcd 替換lex lge 替換lex 替換cd 19
# 4

View Code

元字符表

字符串開始位置與匹配規則符合就匹配，否則不匹配，匹配字符串開頭。在多行模式中匹配每一行的開頭，^元字符如果寫到[]字符集里就是反取

預定義字符集表，可以寫在字符集[...]中

特殊分組用法表：只對正則函數返回對象的有用

正則匹配模式表

正則表達式重點

一、

r原生字符

將在python里有特殊意義的字符如，轉換成原生字符（就是去除它在python的特殊意義），不然會給正則表達式有沖突，為了避免這種沖突可以在規則前加原始字符r

二、

正則表達式，返回類型為表達式對象的

如：<_sre.SRE_Match object; span=(6, 7), match='a'>

返回對象的，需要用正則方法取字符串，

方法有

group() # 獲取匹配到的所有結果，不管有沒有分組將匹配到的全部拿出來，有參取匹配到的第幾個如2
groups() # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分的結果
groupdict() # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分定義了key的組結果

三、

匹配到的字符串里出現空字符

注意：正則匹配到空字符的情況，如果規則里只有一個組，而組后面是*就表示組里的內容可以是0個或者多過，這樣組里就有了兩個意思，一個意思是匹配組里的內容，二個意思是匹配組里0內容（即是空白）所以盡量避免用*否則會有可能匹配出空字符串

四、

()分組

注意：分組的意義，就是在匹配成功的字符串中，在提取()里，組里面的字符串

五、

?:在有分組的情況下findall()函數，不只拿分組里的字符串，拿所有匹配到的字符串，注意?:只用于不是返回正則對象的函數如findall()

總結

以上是生活随笔為你收集整理的python正则表达式findall的使用的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。