正則表達式和re模塊

時間  2019-11-08
標籤 正則 表達式 模塊 欄目 正則表達式 简体版
原文   原文鏈接

正則表達式html

re模塊python

 

正則表達式：正則表達式

正則表達式自己也和python沒有什麼關係，就是匹配字符串內容的一種規則。官方定義：正則表達式是對字符串操做的一種邏輯公式，就是用事先定義好的一些特定字符、及這些特定字符的組合，組成一個「規則字符串」，這個「規則字符串」用來表達對字符串的一種過濾邏輯。json

正則表達式的驗證網站：http://tool.chinaz.com/regex/ide

 正則表達式負號解釋網站

正則表達式的基本用法url

字符組：spa

正則
 
匹配字符
 
匹配
結果
 
說明
 
[0123456789]
 
8
 
True
 
在一個字符組裏枚舉合法的全部字符，字符組裏的任意一個字符
和"待匹配字符"相同都視爲能夠匹配
 
[0123456789]
 
a
 
False
 
因爲字符組中沒有"a"字符，因此不能匹配
  
[0-9]
   
7
 
True
 
也能夠用-表示範圍,[0-9]就和[0123456789]是一個意思
  
[a-z]
   
s
   
True
   
一樣的若是要匹配全部的小寫字母，直接用[a-z]就能夠表示
  
[A-Z]
   
B
   
True
   
[A-Z]就表示全部的大寫字母
  
[0-9a-fA-F]
   
e
   
True
   
能夠匹配數字，大小寫形式的a～f，用來驗證十六進制字符

 

字符：.net

  
元字符
   
匹配內容
.  匹配除換行符之外的任意字符
\w 匹配字母或數字或下劃線
\s 匹配任意的空白符
\d 匹配數字
\n 匹配一個換行符
\t 匹配一個製表符
\b 匹配一個單詞的結尾
^ 匹配字符串的開始
$ 匹配字符串的結尾
\W 
匹配非字母或數字或下劃線
\D 
匹配非數字
\S 
匹配非空白符
a|b 
匹配字符a或字符b
() 
匹配括號內的表達式，也表示一個組
[...] 
匹配字符組中的字符
[^...] 
匹配除了字符組中字符的全部字符

 

量詞：code

量詞
 
用法說明
* 重複零次或更屢次
+ 重複一次或更屢次
? 重複零次或一次
{n} 重複n次
{n,} 重複n次或更屢次
{n,m} 重複n到m次

 

正則表達式實例：

【. ^ $】

正則 待匹配字符 匹配
結果		 說明
海. 海燕海嬌海東 海燕海嬌海東   匹配全部"海."的字符
^海. 海燕海嬌海東 海燕 只從開頭匹配"海."
  海.$   海燕海嬌海東 海東 只匹配結尾的"海.$"

 

【 * + ? { } 】

正則 待匹配字符 匹配
結果		 說明
李.? 李傑和李蓮英和李二棍子

李傑
李蓮
李二

   
?表示重複零次或一次，即只匹配"李"後面一個任意字符
 
李.* 李傑和李蓮英和李二棍子 李傑和李蓮英和李二棍子 
*表示重複零次或屢次，即匹配"李"後面0或多個任意字符
李.+ 李傑和李蓮英和李二棍子 李傑和李蓮英和李二棍子 
+表示重複一次或屢次，即只匹配"李"後面1個或多個任意字符
李.{1,2} 李傑和李蓮英和李二棍子

李傑和
李蓮英
李二棍

 
{1,2}匹配1到2次任意字符

 注意：前面的*,+,?等都是貪婪匹配，也就是儘量匹配，後面加?號使其變成惰性匹配

正則 待匹配字符 匹配
結果		 說明
李.*? 李傑和李蓮英和李二棍子 李
李
李		 惰性匹配

 

字符集［］［^］

正則 待匹配字符 匹配
結果		 說明
李[傑蓮英二棍子]* 李傑和李蓮英和李二棍子

李傑
李蓮英
李二棍子

   
表示匹配"李"字後面[傑蓮英二棍子]的字符任意次
 
李[^和]* 李傑和李蓮英和李二棍子

李傑
李蓮英
李二棍子

 
表示匹配一個不是"和"的字符任意次
[\d] 456bdha3

4
5
6
3

 
表示匹配任意一個數字，匹配到4個結果
[\d]+ 456bdha3

456
3

 
表示匹配任意個數字，匹配到2個結果

 

分組 ()與 或 ｜［^］

#分組 ([abc][123])+  在正則表達式裏，須要對一個總體的式子，進行量詞約束的時候就須要分組
                     #由於正則表達式的量詞只能約束前面一個字符組，所以若是要約束多個字符組就須要用分組

身份證號碼是一個長度爲15或18個字符的字符串，若是是15位則所有🈶️數字組成，首位不能爲0；若是是18位，則前17位所有是數字，末位多是數字或x，下面咱們嘗試用正則來表示：

正則 待匹配字符 匹配
結果		 說明
^[1-9]\d{13,16}[0-9x]$ 110101198001017032

110101198001017032

    表示能夠匹配一個正確的身份證號
^[1-9]\d{13,16}[0-9x]$ 1101011980010170

1101011980010170

 
表示也能夠匹配這串數字，但這並非一個正確的身份證號碼，它是一個16位的數字
^[1-9]\d{14}(\d{2}[0-9x])?$ 1101011980010170

False

 
如今不會匹配錯誤的身份證號了
()表示分組，將\d{2}[0-9x]分紅一組，就能夠總體約束他們出現的次數爲0-1次
^([1-9]\d{16}[0-9x]|[1-9]\d{14})$ 110105199812067023

110105199812067023

 
表示先匹配[1-9]\d{16}[0-9x]若是沒有匹配上就匹配[1-9]\d{14}

 

轉義符 \

在正則表達式中，有不少有特殊意義的是元字符，好比\d和\s等，若是要在正則中匹配正常的"\d"而不是"數字"就須要對"\"進行轉義，變成'\\'。

在python中，不管是正則表達式，仍是待匹配的內容，都是以字符串的形式出現的，在字符串中\也有特殊的含義，自己還須要轉義。因此若是匹配一次"\d",字符串中要寫成'\\d'，那麼正則裏就要寫成"\\\\d",這樣就太麻煩了。這個時候咱們就用到了r'\d'這個概念，此時的正則是r'\\d'就能夠了。

正則 待匹配字符 匹配
結果		 說明
\d \d  False 
由於在正則表達式中\是有特殊意義的字符，因此要匹配\d自己，用表達式\d沒法匹配
\\d \d  True 
轉義\以後變成\\，便可匹配
"\\\\d" '\\d'  True 
若是在python中，字符串中的'\'也須要轉義，因此每個字符串'\'又須要轉義一次
r'\\d' r'\d'  True 
在字符串以前加r，讓整個字符串不轉義

 

貪婪匹配

貪婪匹配：在知足匹配時，匹配儘量長的字符串，默認狀況下，採用貪婪匹配

正則 待匹配字符 匹配
結果		 說明
<.*>

<script>...<script>

 <script>...<script> 
默認爲貪婪匹配模式，會匹配儘可能長的字符串
<.*?> r'\d'  

<script>
<script>

 
加上？爲將貪婪匹配模式轉爲非貪婪匹配模式，會匹配儘可能短的字符串

 

 

非貪婪匹配：

*? 重複任意次，但儘量少重複
+? 重複1次或更屢次，但儘量少重複
?? 重複0次或1次，但儘量少重複
{n,m}? 重複n到m次，但儘量少重複
{n,}? 重複n次以上，但儘量少重複
# .*? 的用法 
. 是任意字符
* 是取 0 至 無限長度
? 是非貪婪模式。
何在一塊兒就是 取儘可能少的任意字符，通常不會這麼單獨寫，他大多用在：
.*?x

就是取前面任意長度的字符，直到一個x出現

 

正則表達式碎碎念：

#1 正則表達式是從左到右依次匹配   好比 ab|abc  匹配了ab abc就不會匹配了，因此匹配長度較長的要放前面

#2 [A-Z]一箇中括號表示只匹配一個值， 好比  [0-9] 只匹配0到9，能夠匹配不少次，可是每次匹配都只匹配一個值，

#\d{3} 匹配三個數字，這三數字必定要連在一塊兒的

#  ^[0-9][A-Z]$這樣只匹配兩個值，    不加起止符號  [0-9][A-Z]  這樣會匹配全部的數字和大寫字母，但每次只匹配兩個值

# .*  默認算匹配到一次

#量詞     都是先規則再量詞，且這個量詞僅匹配左邊最近的規則，好比 [a-z]\d+ 只針對/b進行一次或 屢次匹配

#^  開始符  好比 ^a 就只匹配整篇文檔的開頭部分，有點像 startswith

#$  （在英文狀態下打出來） 海.$  只匹配以 海%  結尾的字符，  海$.這樣是匹配不到東西的

# a.  匹配全部相似  a.的字符串  相似 a%   沒加量詞其只能匹配 兩個字符

#^([1-9]\d{16}[0-9x]|[1-9]\d{14})$  此處十八位必定要放前面，否則會出錯

#其實正則表達式有個順序   【匹配規則】【次數】【？惰性與否】  次數的話有【*  +  ?  {}  {n,}  {n,m}】 不寫就是一次

#<.*>   貪婪匹配，會把 < 日後的值所有找到，直到最後一個，而後再往回找  >  這中間的值就是咱們這條正則表達式找到的，回溯匹配
#<.*?>  惰性匹配  它把 > 捏在手裏，而後從 < 日後開始找，一旦找到 >  就立刻返回

#寫正則的時候，要注意別加空格，加空格正則覺得你要匹配空格

#？ 問號的集中意思  1表示量詞  2表示惰性匹配  3,python中 ?P的使用  4,python中取消分組優先
import re
s = '350524199903280533'
res = re.search('(?P<province>\d{6})(?P<Birth>\d{8})(?P<ID>\d{4})',s).groupdict()
print(res)   #>>>>> {'province': '350524', 'Birth': '19990328', 'ID': '0533'}

#取消分組優先
ret = re.findall('www.(baidu|oldboy).com','www.oldboy.com')
print(ret)
ret = re.findall('www.(?:baidu|oldboy).com','www.oldboy.com')
print(ret)

#關於轉義，對於正則表達式中，若是須要匹配 元字符，量詞 這些特殊字符就須要 用 \ 進行轉義  好比 \* 表示單純要尋找 星號
#可是若是是在字符組中 [*] 這樣子直接表示匹配 * 號，由於字符組裏不放量詞，可是元字符則仍是要轉義的
#在python中  re.findall(r'*',str) 能夠直接在前面加個小寫 r 就表明轉義
正則表達式碎碎念：

 減號 [-]寫在字符組首位，表示減號自己，[0-9]寫成這樣表示範圍

 

re模塊

re模塊經常使用實例

import re

# ret = re.findall('c','eva egon gka') #查找字符串中全部的a，並返回爲一個列表，第一個參數中爲正則，第二個參數爲字符串
# print(ret)                             #若查找爲空，返回空列表
 ret2 = re.search('e','eva egon1 gka') #從前日後，匹配到一個就返回，返回一個對象，須要用group()方法才能調用
print(ret2)   #>>>>>> <_sre.SRE_Match object; span=(0, 1), match='e'>   #沒找到返回none，可是None不能調用group，會報錯
ret2_2 = ret2.group()
print(ret2_2)   #>>>>> e
#通常這麼用：
# if ret2:
#     print(ret2.group())
 ret3 = re.match('[a-z]+','eva egon1 gka')  #從頭開始匹配，必須是從頭，知道到一個就返回，返回一個對象，須要用group()方法才能調用
if ret3:                               #沒找到返回none，可是None不能調用group，會報錯
    print(ret3.group())    #>>>>> eva
 ret4 = re.split('[ab]','abcd') #先按a分割獲得 ['','bcd']  ，再按b分割獲得['','','cd']
print(ret4)   #>>>>>>> ['', '', 'cd']
 ret5 = re.sub('\d','H','sldjfoi12sdg54sdfa',1) #相似字符串的replace
print(ret5)   #>>>> sldjfoiH2sdg54sdfa
 ret6 = re.subn('\d','H','sldjfoi12sdg54sdfa')  #把替換了幾回標出來
print(ret6)    #>>>>>> ('sldjfoiHHsdgHHsdfa', 4)  【（替換的結果，替換了幾回）】
 obj = re.compile('\d{3}')  #將正則表達式編譯成爲一個 正則表達式對象，規則要匹配的是3個數字
ret = obj.search('abc123eeee') #正則表達式對象調用search，參數爲待匹配的字符串
print(ret.group())

# ?P<> 給分組命名
s = '350524199903280533'
res = re.search('(?P<province>\d{6})(?P<Birth>\d{8})(?P<ID>\d{4})',s)
print(res.groupdict())  #>>>>> {'province': '350524', 'Birth': '19990328', 'ID': '0533'}
print(res.group('province')) #也能夠這樣取值
 ret7 = re.finditer('\d','ds3sy4784a')  #finditer 返回一個存放匹配結果的迭代器
print(ret7)    #<callable_iterator object at 0x0000022D51A1D7F0> 迭代器
print(next(ret7).group())
print(next(ret7).group())
print([i.group() for i in ret7])

小結：匹配完須要用group調用的方法有：search，match，finditer


#1 findall的優先級查詢：
ret = re.findall('www.(baidu|oldboy).com', 'www.oldboy.com')
print(ret)  # ['oldboy']     這是由於findall會優先把匹配結果組裏內容返回,若是想要匹配結果,取消權限便可

ret = re.findall('www.(?:baidu|oldboy).com', 'www.oldboy.com') #取消分組優先
print(ret)  # ['www.oldboy.com']


#2 split的優先級查詢
ret=re.split("\d+","eva3egon4yuan")
print(ret) #結果 ： ['eva', 'egon', 'yuan']

ret=re.split("(\d+)","eva3egon4yuan")
print(ret) #結果 ： ['eva', '3', 'egon', '4', 'yuan']

#在匹配部分加上（）以後所切出的結果是不一樣的，
#沒有（）的沒有保留所匹配的項，可是有（）的卻可以保留了匹配的項，
#這個在某些須要保留匹配部分的使用過程是很是重要的。

#分組用group提取
ret = re.search('^[1-9](\d{14})(\d{2}[0-9x])?$','350524199908280522')
print(ret.group())
print(ret.group(1))
print(ret.group(2))

 

關於這些方法中的flags【注意split的坑】

flags有不少可選值：

re.I(IGNORECASE)忽略大小寫，括號內是完整的寫法
re.M(MULTILINE)多行模式，改變^和$的行爲
re.S(DOTALL)點能夠匹配任意字符，包括換行符
re.L(LOCALE)作本地化識別的匹配，表示特殊字符集 \w, \W, \b, \B, \s, \S 依賴於當前環境，不推薦使用
re.U(UNICODE) 使用\w \W \s \S \d \D使用取決於unicode定義的字符屬性。在python3中默認使用該flag
re.X(VERBOSE)冗長模式，該模式下pattern字符串能夠是多行的，忽略空白字符，並能夠添加註釋

#其中re.S是最經常使用的
import re
a = 'my \nname \nis gkx'
ret = re.findall('.+',a,re.S)  
# 對於findall,search,match,finditer來講 flags在第三個參數，故能夠用位置參數傳值，對於sub，subn，split falgs不在第三個參數，須要用關鍵字參數傳值 flags=re.S
print(ret) #>>>>> ['my \nname \nis gkx'] #由於加了flags因此此處會把換行符也匹配出來，整個字符串就是一個元素
ret2 = re.findall('.+',a)
print(ret2) #>>>>> ['my ', 'name ', 'is gkx'] #由於【.】匹配換行符之外全部元素，因此換行符不匹配，這個str就變爲匹配了三個元素

 

re模塊的一些練習：

對於用 ?P<> 命名後的匹配組，能夠在另外一個組引用這個命名，從而來匹配如出一轍的值。好比能夠用在網頁源代碼 匹配 <div> </div>

import re
ret = re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>")
#還能夠在分組中利用?P<name>的形式給分組起名字
#獲取的匹配結果能夠直接用group('名字')拿到對應的值
#此處後面的(?P=tag_name)意思是在這裏匹配和前面tag_name如出一轍的值
print(ret.group('tag_name'))  #結果 ：h1
print(ret.group())  #結果 ：<h1>hello</h1>

ret = re.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>")
#若是不給組起名字，也能夠用\序號來找到對應的組，表示要找的內容和前面的組內容一致
#獲取的匹配結果能夠直接用group(序號)拿到對應的值
print(ret.group(1))
print(ret.group())  #結果 ：<h1>hello</h1>
匹配標籤

 

咱們在作正則表達式的時候，有時候匹配完，咱們還須要利用字符串的操做，列表的操做等，對結果進行完善

import re

ret=re.findall(r"\d+","1-2*(60+(-40.35/5)-(-4*3))")
print(ret) #['1', '2', '60', '40', '35', '5', '4', '3']
ret=re.findall(r"-?\d+\.\d*|(-?\d+)","1-2*(60+(-40.35/5)-(-4*3))")
print(ret) #['1', '-2', '60', '', '5', '-4', '3']
ret.remove("")
print(ret) #['1', '-2', '60', '5', '-4', '3']
匹配整數

 

1、 匹配一段文本中的每行的郵箱
      http://blog.csdn.net/make164492212/article/details/51656638

二、 匹配一段文本中的每行的時間字符串，好比：‘1990-07-12’；

   分別取出1年的12個月（^(0?[1-9]|1[0-2])$）、
   一個月的31天：^((0?[1-9])|((1|2)[0-9])|30|31)$

三、 匹配qq號。(騰訊QQ號從10000開始)  ［1,9］[0,9]{4,}

四、 匹配一個浮點數。       ^(-?\d+)(\.\d+)?$   或者  -?\d+\.?\d*

五、 匹配漢字。             ^[\u4e00-\u9fa5]{0,}$ 

六、 匹配出全部整數
數字匹配 
import requests

import re
import json

def getPage(url):

    response=requests.get(url)
    return response.text

def parsePage(s):
    
    com=re.compile('<div class="item">.*?<div class="pic">.*?<em .*?>(?P<id>\d+).*?<span class="title">(?P<title>.*?)</span>'
                   '.*?<span class="rating_num" .*?>(?P<rating_num>.*?)</span>.*?<span>(?P<comment_num>.*?)評價</span>',re.S)

    ret=com.finditer(s)
    for i in ret:
        yield {
            "id":i.group("id"),
            "title":i.group("title"),
            "rating_num":i.group("rating_num"),
            "comment_num":i.group("comment_num"),
        }

def main(num):

    url='https://movie.douban.com/top250?start=%s&filter='%num
    response_html=getPage(url)
    ret=parsePage(response_html)
    print(ret)
    f=open("move_info7","a",encoding="utf8")

    for obj in ret:
        print(obj)
        data=json.dumps(obj,ensure_ascii=False)
        f.write(data+"\n")

if __name__ == '__main__':
    count=0
    for i in range(10):
        main(count)
        count+=25
複製代碼
 簡化版

複製代碼
flags有不少可選值：

re.I(IGNORECASE)忽略大小寫，括號內是完整的寫法
re.M(MULTILINE)多行模式，改變^和$的行爲
re.S(DOTALL)點能夠匹配任意字符，包括換行符
re.L(LOCALE)作本地化識別的匹配，表示特殊字符集 \w, \W, \b, \B, \s, \S 依賴於當前環境，不推薦使用
re.U(UNICODE) 使用\w \W \s \S \d \D使用取決於unicode定義的字符屬性。在python3中默認使用該flag
re.X(VERBOSE)冗長模式，該模式下pattern字符串能夠是多行的，忽略空白字符，並能夠添加註釋
爬蟲練習

 

re模塊中的轉義字符

import re
 obj = re.compile(r'\d{3}')    此處去掉轉義字符r結果也是123
 ret = obj.search('abc123eeee') 
 print(ret.group())  #>>>  123


w = re.findall('\btina','tian tinaaaa')    #未匹配到相關字符
print(w)
s = re.findall(r'\btina','tian tinaaaa')   #加了轉義字符 ‘r’ 匹配到了想要的字符串
print(s)
v = re.findall(r'\btina','tian#tinaaaa')   # \b是匹配單詞的邊界，通常是指空格或者換行符，可是此處 特殊字符 # @ ！ 好像也算是邊界 print(v)
a = re.findall(r'\btina\b','tian#tina@aaa')
print(a)
執行結果以下：
[]
['tina']
['tina']
['tina']

總結以下：
對於 compile,findall,search,match,sub,subn,finditer,split來講 在正則表達式前加轉義字符 ‘r’都是不會報錯的
若是不加轉義字符 'r'，對於\d \w \s 這些在python中沒特殊含義的字符，也不會報錯
可是若是是 相似 \b python中已經有含義（表示空格），那麼在用re模塊的時候，要先進行轉義才能正常使用正則表達式

 

https://www.cnblogs.com/tina-python/p/5508402.html  很詳細的re模塊

http://www.cnblogs.com/Eva-J/articles/7228075.html#_label10  摘抄自景老師博客

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程