re模塊的高級用法

search

re.search(pattern, string[, flags])  

? 若string中包含pattern子串，則返回Match對象，否則返回None，註意，如果string中存在多個pattern子串，只返回第一個。

re.search()：方法用來精確匹配並提取第一個符合規律的對象，而對象內容的提取則使用search方法的屬性group()來實現；

group(0)：則是整個匹配的內容，返回一個實體對象；group(1)則是匹配第一個括號裏面的內容，取出括號裏匹配的實體對象；

group(2)：則是匹配第二個括號裏面的內容，取出括號裏匹配的實體對象；group(0,1,2)則返回一個實體對象的元組；

? 需求：匹配出文章閱讀的次數

#coding=utf-8
import re

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

search兩種情況

有分組：

>>> origin = "hello alex alix bcd dsfa lefg abc 199"
>>> ret= re.search("a(\w+)",origin)
>>>
 
 ret
<_sre.SRE_Match object; span=(6, 10), match='alex'>
>>> ret.group()
'alex'
>>> ret.groups()
('lex',)
>>> ret = re.search("(?P<key1>a)(?P<key2>(\w+))",origin)
>>> ret.groupdict()
{'key1': 'a', 'key2'
 
: 'lex'}

無分組：

>>> origin = "hello alex alix bcd dsfa lefg abc 199"
>>> ret = re.search("ali\w+",origin)
>>> ret.group()
'alix'
>>> ret.groups()
()
>>> ret.groupdict()
{}

findall

re.findall(pattern, string[, flags])  

返回string中所有與pattern相匹配的全部字串，返回形式為數組。

• group()：母串中與模式pattern匹配的子串；
• group(0)：結果與group()一樣；
• groups()：所有group組成的一個元組，group(1)是與patttern中第一個group匹配成功的子串，group(2)是第二個，依次類推，如果index超了邊界，拋出IndexError；
• findall()：返回的就是所有groups的數組，就是group組成的元組的數組，母串中的這一撮組成一個元組，那一措組成一個元組，這些元組共同構成一個list，就是findall()的返回結果。另，如果groups是只有一個元素的元組，findall的返回結果是子串的list，而不是元組的list了。

需求：統計出python、c、c++相應文章閱讀的次數

#coding=utf-8

>>> ret = re.findall(r"\d+", "python = 9999, c = 7890, c++ = 12345")
>>> ret
['9999', '7890', '12345']

>>> re.findall("",'abc')
['', '', '', '']
#   如果正則能有空的匹配的話，那麽匹配字符串最後還會匹配到一個空

1.當給出的正則表達式中帶有多個括號時，列表的元素為多個字符串組成的tuple，tuple中字符串個數與括號對數相同，字符串內容與每個括號內的正則表達式相對應，並且排放順序是按括號出現的順序。

2.當給出的正則表達式中帶有一個括號時，列表的元素為字符串，此字符串的內容與括號中的正則表達式相對應（不是整個正則表達式的匹配內容）。

3.當給出的正則表達式中不帶括號時，列表的元素為字符串，此字符串為整個正則表達式匹配的內容。

sub 將匹配到的數據進行替換

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

• pattern，表示正則中的模式字符串

• repl，就是replacement，被替換的字符串;repl可以是字符串，也可以是函數。

• 當repl是字符串時，其中的任何反斜杠轉義字符，都會被處理的。\n：會被處理為對應的換行符；

  \r：會被處理為回車符； 反斜杠加g以及中括號內一個名字，即：\g，對應著命了名的組，named group

• 當repl是函數時，函數會被匹配的對象調用，並且它的返回值會被插入到文本中，如方法2

• string，即表示要被處理，要被替換的那個string字符串。

• count，模式匹配後替換的最大次數；count必須是非負整數。缺省值是0表示替換所有的匹配。

需求：將匹配到的閱讀次數加1

方法1：

#coding=utf-8

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

方法2：

#coding=utf-8

>>> def add(temp):
    strNum = temp.group()
    num = int(strNum) + 1
    return str(num)
... ... ... ... 
>>> ret = re.sub(r"\d+", add, "python = 997")
>>> ret
'python = 998'

>>> ret = re.sub(r"\d+", add, "python = 99")
>>> ret
'python = 100'

split 根據匹配進行切割字符串，並返回一個列表

str.split(str="", num=string.count(str))

通過指定分隔符對字符串進行切片，如果參數num 有指定值，則僅分隔 num 個子字符串

• str -- 分隔符，默認為所有的空字符，包括空格、換行(\n)、制表符(\t)等。
• num -- 分割次數。

需求：切割字符串“info:xiaoZhang 33 shandong”

#coding=utf-8

>>> ret = re.split(r":| ","info:xiaoZhang 33 shandong")
>>> ret
['info', 'xiaoZhang', '33', 'shandong']

python貪婪和非貪婪

　　Python裏數量詞默認是貪婪的（在少數語言裏也可能是默認非貪婪），總是嘗試匹配盡可能多的字符；

　　非貪婪則相反，總是嘗試匹配盡可能少的字符。

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

>>> s="This is a number 234-235-22-423"
>>> r=re.match(".+(\d+-\d+-\d+-\d+)",s)
>>> r.group(1)
'4-235-22-423'
>>> r=re.match(".+?(\d+-\d+-\d+-\d+)",s)
>>> r.group(1)
'234-235-22-423'

　　　正則表達式模式中使用到通配字，那它在從左到右的順序求值時，會盡量“抓取”滿足匹配最長字符串，在我們上面的例子裏面，“.+”會從字符串的啟始處抓取滿足模式的最長字符，其中包括我們想得到的第一個整型字段的中的大部分，“\d+”只需一位字符就可以匹配，所以它匹配了數字“4”，而“.+”則匹配了從字符串起始到這個第一位數字4之前的所有字符。

　　解決方式：非貪婪操作符“？”，這個操作符可以用在"*","+","?"的後面，要求正則匹配的越少越好。

>>> 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'

Python 正則表達式提高