爬蟲--正則表達式

什么是正則表達式？

正則表達式是對字符串操作的一種邏輯公式，就是用事先定義好的一些特定字符、及這些特定字符的組合，組成一個“規則字符串”，這個“規則字符串”用來表達對字符串的一種過濾邏輯。

常見匹配表達式：

 re.match

 re.match 嘗試從字符串的起始位置匹配一個模式，如果不是起始位置匹配成功的話，match0就返回none.

re.match(pattern,string,flags=0)
# 第一個為你寫的正則表達式，第二個為匹配的目標字符串，第三個為匹配模式

import re
content = "Hello 123 4567 World_This is a Regex Demo"
result = re.match("^Hello\s\d\d\d\s\d{4}\s\w{10}.*Demo$", content)
print(result)
print(result.group()) # 返回匹配結果
print(result.span()) # 輸出匹配結果的范圍

<_sre.SRE_Match object; span=(0, 41), match='Hello 123 4567 World_This is a Regex Demo'>
Hello 123 4567 World_This is a Regex Demo
(0, 41)

泛匹配

import re
content = "Hello 123 4567 World_This is a Regex Demo"
result = re.match("^Hello.*Demo$", content)
print(result)
print(result.group()) # 返回匹配結果
print(result.span()) # 輸出匹配結果的范圍

<_sre.SRE_Match object; span=(0, 41), match='Hello 123 4567 World_This is a Regex Demo'>
Hello 123 4567 World_This is a Regex Demo
(0, 41)

匹配目標

import re
content = "Hello 1234567 World_This is a Regex Demo"
result = re.match("^Hello\s(\d+).*Demo$", content)
print(result)
print(result.group(1)) # group(1)就是把第一個括號里的內容打印出來
print(result.span()) # 輸出匹配結果的范圍

<_sre.SRE_Match object; span=(0, 40), match='Hello 1234567 World_This is a Regex Demo'>
1234567
(0, 40)

貪婪匹配

import re
content = "Hello 1234567 World_This is a Regex Demo"
result = re.match("^He.*(\d+).*Demo$", content)
print(result)
print(result.group(1)) # group(1)就是把第一個括號里的內容打印出來
print(result.span()) # 輸出匹配結果的范圍

<_sre.SRE_Match object; span=(0, 40), match='Hello 1234567 World_This is a Regex Demo'>
7
(0, 40)
#為什么group(1)打印出來得時7呢？而不是上面的1234567？
#因為result = re.match("^He.*(/d+).*Demo$")這句里是是在^He的后面.*這里匹配最大化，而(\d+)這里可以匹配最少的數字，像后面的數字7，所以后面的使7而不是1234567

非貪婪問題

import re
content = "Hello 1234567 World_This is a Regex Demo"
result = re.match("^He.*?(\d+).*Demo$", content)
print(result)
print(result.group(1)) # group(1)就是把第一個括號里的內容打印出來
print(result.span()) # 輸出匹配結果的范圍

<_sre.SRE_Match object; span=(0, 40), match='Hello 1234567 World_This is a Regex Demo'>
1234567
(0, 40)
# 為什么使1234567而不是7呢？
# result = re.match("^He.*?(\d+).*Demo$", content).在^He的后面是.*?是非貪婪匹配，匹配最少的元素，而后面有個(\d+)所以在這里停止了，所以輸出的是1234567

轉義

import re
content ="price is $5.00"
result = re.match("price is $5.00", content)
print(result)

None

import re
content ="price is $5.00"
result = re.match("price is \$5\.00", content)
print(result)

<_sre.SRE_Match object; span=(0, 14), match='price is $5.00'>

總結：盡量使用泛匹配模式，使用括號得到匹配目標、盡量使用非貪婪模式，有換行符就用re.S

re.search

re.search掃描整個字符串返回第一次成功的匹配

import re
content ="Extra strings Hello 1234567 World_This is a Regex Demo Extra strings"
result = re.search("Hello.*?(\d+).*?strings", content)
print(result)

<_sre.SRE_Match object; span=(14, 68), match='Hello 1234567 World_This is a Regex Demo Extra st>

總結：為匹配方便，能用哪個search就不用match

re.findall

搜索字符串，以列表形式返回全部能匹配的字符串。

string="豬  狗  雞  鴨"

#當正則表達式中有兩個括號時，其輸出是一個list 中包含2個 tuple,從輸出的結果可以看出，有兩個元組，每一個元組中有兩個字符串 : 其中第一個字符串"豬 狗"是最外面的括號輸出的結果，第二個是里面括號(/w+)輸出的結果 "豬", 第二個元組是  第二次匹配的結果 -- 詳解同第一次匹配。
regex=re.compile("((\w+)\s+\w+)")
print(regex.findall(string))

#正則表達式中有一個括號時,其輸出的內容就是括號匹配到的內容，而不是整個表達式所匹配到的結果,但是整個正則表達式執行了只不過只輸出括號匹配到的內容, 在第一次匹配時跟上述沒有括號時一樣，匹配到 "豬 狗" ,只不過只輸出(/w+)匹配     到的結果 即"豬",第二次匹配同理從"雞" 開始，匹配到"雞 鴨",但是還是只是輸出"雞"
regex1=re.compile("(\w+)\s+\w+")
print(regex1.findall(string))

#正則表達式中當沒有括號時，就是正常匹配，在本例中"/w+/s+/w+"第一次匹配到的字符為"豬 狗",由於是貪婪模式會繼續匹配,第二次從"雞"開始匹配匹配到的結果為字符串"雞 鴨"
regex2=re.compile("\w+\s+\w+")
print(regex2.findall(string))

[('豬  狗', '豬'), ('雞  鴨', '雞')]
['豬', '雞']
['豬  狗', '雞  鴨']

re.sub

替換字符串中每一個匹配的子串后返回替換后的字符串。

import re

content = "Extra things Hello 1234567 World_This is a Regex Demo"
result = re.sub('\d+','7654321',content)
print(result)

Extra things Hello 7654321 World_This is a Regex Demo

如果要替換的字符串是原字符串本身呢？或者包含圓字符串呢？ 

import re

content = "Extra things Hello 1234567 World_This is a Regex Demo"
result = re.sub('(\d+)',r'\1 7654321',content)    #"\1"是一個轉義的字符，為了要保證他的原生的字符，所以在前面加了一個r
print(result)

Extra things Hello 1234567 7654321 World_This is a Regex Demo

re.compile

將一個正則表達式編譯成正則對象，以便復用該匹配模式