㈠ 在python中如何匹配一個存在多個相同的正則表達式模式的字元串中的所有正則表達式模式
你的正則表達式使用了貪婪模式的匹配(.*),應該用非貪婪模式,正則表達式應該為<a href="/(.*?)-desktop-wallpapers.html
完整的python語言程序如下
#!/usr/bin/python3 import re a = '<html><body><p>[<a href="/aero-desktop-wallpapers.html" title="Aero HD Wallpapers">Aero</a>, <a href="/animals-desktop-wallpapers.html" title="Animals HD Wallpapers">Animals</a>, <a href="/architecture-desktop-wallpapers.html" title="Architecture HD Wallpapers">Architecture</a>,Wallpapers">Artistic</a>, ........(省略)......... <a href="/vintage-desktop-wallpapers.html" title="Vintage HD Wallpapers">Vintage</a>]</p></body></html>'titles = re.findall('<a href="/(.*?)-desktop-wallpapers.html',str(a))print (titles) 運行結果['aero', 'animals', 'architecture', 'vintage']
㈡ python 正則表達式 斷言解釋
>>>re.findall(r'(?<=ab).*?(?=d)',s)#非貪婪模式，先找左邊有ab，再開始0個字元，
#查看是否右邊有d，不滿足再向後獲取一個字元，直到滿足右邊有字元d；
#剩餘字元串dddd再開始查找ab，搜索到字元串結尾，未找到，退出
['c']
>>>re.findall(r'(?<=ab).*(?=d)',s)#貪婪模式，先找到ab，
#再匹配後面所有字元，查看後面有沒有d，如果不滿足再拋出右面一個字元
#倒退查找後面有沒有d，直到找到；剩餘字元串d中繼續查找ab，不能找到，退出
['cddd']
>>>re.findall(r'(?<=ab).*?',s)#左邊有ab，非貪婪模式【先找到ab，後面0個字元，
#滿足整個匹配；從剩餘的dddd中再次查找，沒找到ab，退出】
['']
>>>re.findall(r'(?<=ab).*',s)##左邊有ab，貪婪模式【找到ab，匹配後面整個
#字元串，滿足條件；沒有剩餘字元串，退出】
['cdddd']
>>>re.findall(r'.*(?=d)',s)#先是貪婪模式匹配所有字元，依次倒退找右邊是d的
#下次查找位置在本次位置的後面開始，即剩餘一個d字元串中找，能夠匹配，但匹配的是空串
['aabcddd','']
>>>re.findall(r'.*?(?=d)',s)#從0個字元串開始，判斷後面有沒有d，如果沒有向右
#取得一個字元繼續判斷，直到找到d{故第一次aabc}；下一次從剩餘的dddd找，仍然是從0個字元
#判斷，後面有d，返回空串；下次從剩餘的ddd中……故四個空串
['aabc','','','','']
>>>re.findall(r'(d)',s)#單個字元的捕獲，有幾個d返回共多少個元素的列表
['d','d','d','d']
㈢ python正則表達式指定開始匹配的敵方
一. 簡介
正則表達式又叫規則表達式，是處理字元串的強大工具。在python中通過調用re模塊，可以實現正則匹配，正則表達式模式被編譯成一系列的位元組碼，然後由C編寫的匹配引擎執行
二. python常用字元含義(匹配模式)
1186367-20180604115644788-1913251705.png
三. re模塊
1. re.match(pattern, string, flags=0) | match(string, [pos, endpos]) (這個用於編譯後返回的正則表達式對象Pattern.match())
1)作用：嘗試從字元串的起始位置匹配一個模式，如果起始位置匹配成功，返回一個match對象，否則返回None
pattern：匹配的正則表達式
string：要匹配的字元串
flags：標志位，用於控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等
2) 正則表達式可以包含一些可選標志修飾符來控制匹配模式。修飾符被指定為一個可選的標志，多個修飾符可以通過 | 來指定，如re.I | re.M表示對大小寫不敏感和多行匹配物卜空
1186367-20180604123302464-360465156.png
3) 實例
importreprint(re.match('www', 'www.runoob.com').span()) #在起始位置匹配
print(re.match('com', 'www.runoob.com')) #不在起始位置匹配
運行結果為：
(0, 3)
None
為什麼第一個起始位置匹配要加span()?
span()的作用是：返回一個元組包含匹配 (開始,結束) 的位置，如果不加span(),我們獲得的只是一個match obj，只有加了span()，我們才能獲得匹配罩瞎對象的位置。不信請看：
#在命令行輸出
print(re.match('www', 'www.runoob.com'))<_sre.SRE_Match object; span=(0, 3), match='www'>
print(re.match('com', 'www.runoob.com'))
None
為什麼第二個非起始位置匹配不加span()?
不在起始位置匹配，默認返回的None，而None對象是沒有span()方法的，這時候就會報錯：
importreprint(re.match('com', 'www.runoob.com').span())
Traceback (most recent call last):
File"", line 1, in
print(re.match('com', 'www.runoob.com').span())
AttributeError: 'NoneType' object has no attribute 'span'
2. re.search(pattern, string, flags=0) | search(string, [pos, endpos])(這個用於編譯後返回的正則表達式對象Pattern.search())
1) 作用：在字元串內查找匹配模式，只要找到第一個匹配則返回一個match對象，如果沒有找到，則返回None
importre#不加span()返回一個match對象
print(re.search('www', 'www.runoob.com'))<_sre.SRE_Match object; span=(0, 3), match='www'>
print(re.search('www', 'www.runoob.com').span())
(0,3)print(re.search('com', 'www.runoob.com').span())
(11, 14)
3. re.match和re.search一旦匹配成功，就會返回一個match object對象，而match object對象有以下方法：
group(num) num代表組號，表示匹配第num組的字元串，不寫時默認是0，表示匹配整個表達式的字元串。group()也可以一次輸入多弊悄個組號，如group(1, 2, 3)，這種情況下它將返回一個包含那些組所對應的元組
groups() 返回一個包含所有小組字元串的元組，從1到所含的小組號
span() 返回一個元組包含匹配(開始、結束)的位置
start() 返回匹配開始的位置
end() 返回匹配結束的位置
1) 實例
importre
line= "Cats are smarter than dogs"searchObj= re.search( r'(.*) are (.*?) .*', line, re.M|re.I)print(searchObj.group())
Cats are smarter than dogsprint(searchObj.group(0))
Cats are smarter than dogsprint(searchObj.group(1))
Catsprint(searchObj.group(2))
smarterprint(searchObj.group(1, 2))
('Cats', 'smarter')
print(searchObj.groups())
('Cats', 'smarter')
為什麼第二組匹配是 (.*?) 而不是 (.*)
我們做個試驗，嘗試一下 (.*)
importre
line= "Cats are smarter than dogs"searchObj= re.search( r'(.*) are (.*) .*', line, re.M|re.I)print(searchObj.group())
Cats are smarter than dogsprint(searchObj.group(1))
Catsprint(searchObj.group(2))
smarter thanprint(searchObj.group(1, 2))
('Cats', 'smarter than')
注意到group(2)的數據是不同的，這個是為什麼呢？這就涉及到貪婪匹配和非貪婪匹配
貪婪匹配： 在整個表達式匹配成功的情況下，盡可能多的匹配。比如上面的 .*
.表示除換行之外的所有字元， *表示匹配前面的字元0次或無數次
非貪婪匹配：在整個表達式匹配成功的情況下，盡可能少的匹配。比圖上面的 .*?
?表示匹配前面字元0次或1次
注意前面 are () .* 中，()前後是兩個空格，而are之後兩個空格之間有兩種情況，1. "smarter than"， 2. "smarter"，具體選擇哪種是由匹配模式決定的，當()里是貪婪匹配時，.*可以匹配smarter，可以匹配空格，可以匹配than，當()里是非貪婪模式時， .*?只會匹配smarter，因為它最多匹配一次
為什麼要用前綴 r 呢？
我們知道在python中, \ 表示轉義字元，如果需要匹配一個 \ 本身呢？我們就要用\\， 而分別對每個 \ 進行轉義，就需要用 \\\\
注意：如果字元串中有字元*需要匹配，可以使用\*或字元集[*]
4. re.compile(pattern, [flags])
1) 作用：用於編譯正則表達式，生成一個正則表達式對象(Pattern，這個Pattern不能直接實例化，必須由re.compile()進行構造)，供match()和search()這兩個函數使用
pattern：一個字元串形式的正則表達式
flags：編譯標志位，用於控制正則表達式的匹配方式，如：是否區分大小寫、多行匹配等
2) 實例1
importre#用於匹配至少一個數字
pattern = re.compile(r'\d+')#從開始位置匹配
m = pattern.match('one12twothree34four')#沒有匹配，返回None
print(m)
None#從"1"的位置開始匹配
m = pattern.match('one12twothree34four', 3, 10)#正好匹配返回一個match對象
print(m)<_sre.SRE_Match object; span=(3, 5), match='12'>
print(m.group())12
print(m.start())3
print(m.end())5
print(m.span())
(3, 5)
實例2
importre#re.I表示忽略大小寫
pattern = re.compile(r'([a-z]+) ([a-z]+)', re.I)
m= pattern.match('Hello World Wide Web')#匹配成功返回一個match對象
print(m)<_sre.SRE_Match object; span=(0, 11), match='Hello World'>
#返回匹配成功的整個子串
print(m.group(0))
Hello World#返回匹配成功的整個子串的索引
print(m.span(0))
(0,11)#返回第一個分組匹配成功的子串
print(m.group(1))
Hello#返回第一個分組匹配成功的子串的索引
print(m.span(1))
(0,5)#返回第二個分組匹配成功的子串
print(m.group(2))
World#返回第二個分組匹配成功的子串的索引
print(m.span(2))
(6, 11)#等價於(m.group(1), m.group(2), ...)
print(m.groups())
('Hello', 'World')#不存在第三個分組
print(m.group(3))
Traceback (most recent call last):
File"", line 1, in
print(m.group(3))
IndexError: no such group
5. re.findall(pattern, string, flags=0) | findall(string, [pos, endpos])
1) 作用：遍歷匹配，以列表形式返回所有能匹配的子串，如果沒找到匹配的，則返回空列表
string：待匹配的字元串
pos：可選參數，指定字元串的起始位置，默認為0
endpos：可選參數，指定字元串的結束位置，默認為字元串的長度
2) 實例
importre#查找數字
pattern = re.compile(r'\d+')
result1= pattern.findall('runoob 123 google 456')print(result1)
['123', '456']
result2= pattern.findall('run88oob123google456', 0, 10)print(result2)
['88', '12']
6. re.finditer(pattern, string, flags=0) | finditer(string, [pos, endpos])
1) 作用：搜索string，返回一個順序訪問每一個匹配結果(match對象)的迭代器。找到匹配的所有子串，並把它們作為一個迭代器返回。
2) 實例
importre
pattern= re.compile(r'\d+')print(pattern.finditer('one1two2three3four4'))
for m in pattern.finditer('one1two2three3four4'):print(m)print(m.group())<_sre.SRE_Match object; span=(3, 4), match='1'>
1
<_sre.SRE_Match object; span=(7, 8), match='2'>
2
<_sre.SRE_Match object; span=(13, 14), match='3'>
3
<_sre.SRE_Match object; span=(18, 19), match='4'>
4
7. re.split(pattern, string, [maxsplit=0, flags=0]) | split(string, [maxsplit])
1) 作用：按照能夠匹配的子串將字元串分割後返回列表
pattern：匹配的正則表達式
string：要匹配的字元串
maxsplit：分割次數，maxsplit=1 分割一次，默認為0，不限制次數
flags：標志位，用於控制正則表達式的匹配方式，如：是否區分大小寫、多行匹配等
2) 實例1
importre
pattern= re.compile(r'\d+')print(pattern.split('one1two2three3four4'))
['one', 'two', 'three', 'four', ''] #注意後面沒有內容，是一個''字元
實例2
importre#匹配\W+表示非單詞字元一次或無數次
pattern = re.compile(r'\W+')#用非單詞字元分割
print(pattern.split('hello, world'))
['hello', 'world']
使用帶括弧的正則表達式則可以將正則表達式匹配的內容也添加到列表內
importre#帶括弧的正則表達式則可以將正則表達式匹配的內容也添加到列表內
pattern = re.compile(r'(\W+)')print(pattern.split('hello, world'))
['hello', ', ', 'world']
㈣ python 正則表達式 （.*）
groups()返回所有捕獲組構成的tuple。你的正則表達式中有唯一一個捕獲組(.*?)，而?在此處表示非貪婪匹配，即在整個正則表達式成立的前提下匹配盡可能少的字元，此處最少的情況是什麼也不匹配，整個正則表達式匹配Python中的Py，而捕獲組自然為空字元串。
㈤ python裡面什麼是貪婪
Python裡面的貪婪演算法（又稱貪心演算法）是指，在對問題求解時，總是做出在當前看來是最好的選擇。也就是說，/不從整體最優上加以考慮，他所做出的是在某種意義上的局部最優解。
貪心演算法不是搏孫對所有問題都能得到整體最優解，關鍵是貪心策略的選擇，選擇的貪心策略必須具備無後效性，即某個狀態以前的過程不會影響以後的狀態，只與當前狀態有關。
基本思路
貪心演算法的基本思路是從問題的某一個初始解出發一步一步地進行，根據某個優化測度，每一步都要確保能獲得局部最優解。每一步只考慮一個數據，他的選取應該滿足局部優化的條件。若下一個數據和部分最優解連在一起不再是可行解時，就不把該數據添加到部分解中，直到把所有數據枚舉完，或者不能再添加演算法停止 。貪心演算法（又稱貪婪演算法）是指，在對問題求解時，總是做出在當前看來是最好的選擇。也就是說，不從整體最優上加以考慮，他所做出的是在某種意義上的局部最優解。
貪心演算法不是對所有問題都能得到整體最優解，關鍵是貪心策略的選擇，選擇的貪心策略必須具備無後效性，即某個狀態以前的過程不會影響以後的狀態，只與當前狀態有關。
基本思路
貪心演算法的基本思路是從問題的某一個初始解出發一步一步地進行，根據某個優化測度，每一步都要確保能獲得局部最優解。每一步只考慮一個數據，他的選取應該滿足局部優化的條件。若下一個數據和部分最優解連在一起不再是可行解時，就不把該數據添加到部分解中，直到把所有數據枚舉完，或者不能再添加演算法停止 。貪心演算法彎銀鎮（又稱貪婪演算法）是指，在對問題求解時，總是做出在當前看來是最好的選擇。也就是說，不從整體最優上加以考慮，他所做出的是在某種意義上的局部最優解。
貪心演算法不是對所有問題都能得到整體最優解，關鍵是貪心策略的選擇，選擇的貪心策略必須具備無後效性，即某個狀態以前的過程不會影響以後的狀態，只與當前狀態有關。
基本思路
貪心演算法的基本思路埋粗是從問題的某一個初始解出發一步一步地進行，根據某個優化測度，每一步都要確保能獲得局部最優解。每一步只考慮一個數據，他的選取應該滿足局部優化的條件。若下一個數據和部分最優解連在一起不再是可行解時，就不把該數據添加到部分解中，直到把所有數據枚舉完，或者不能再添加演算法停止 。
㈥ python 正則表達式.* 是什麼意思 詳細解釋
分開來說：
1、. 匹配任意除換行符「\n」外的字元；
2、*表示匹配前一個字元0次或無限次；
3、+或*後跟？表示非貪婪匹配，即盡可能少的匹配，如*？重復任意次，但盡可能少重復；
4、 .*? 表示匹配任意數量的重復，但是在能使整個匹配成功的前提下使用最少的重復。
如：a.*?b匹配最短的，以a開始，以b結束的字元串。如果把它應用於aabab的話，它會匹配aab和ab。
㈦ Python 正則表達式（完整版）
注意點：
以上量詞都是貪婪模式，會盡可能多的匹配，如果要改為非貪婪模式，通過在量詞後面跟隨一個 ? 來實現
斷言不會匹配任何文本，只是對斷言所在的文本施加某些約束
前瞻 ： exp1(?=exp2) exp1 後面的內容要匹配exp2
負前瞻 : exp1(?!exp2) exp1 後面的內容不能匹配exp2
後顧: (?<=exp2)exp1 exp1 前面的內容要匹配exp2
負後顧 : (?<!exp2)exp1 exp1 前面的內容不能匹配exp2
例如：我們要查找hello，但是hello後面必須是world，正則表達式可以這樣寫： "(hello)s+(?=world)" ,用來匹配 "hello wangxing" 和 "hello world" 只能匹配到後者的hello
(?(id)yes_exp|no_exp) ：對應id的子表達式如果匹配到內容，則這里匹配yes_exp，否則匹配no_exp
㈧ Python中正則表達式的匹配規則總結
其他關於Python的總結文章請訪問： https://www.jianshu.com/nb/47435944
正則表達式用來匹配字元串，在python中可以使用 re 模塊來完成，本篇做一個對正則表達式的匹配規則的總結
在上述的精確匹配後可以跟上一些符號來進行模糊的匹配：
可以使用中括弧的形式進行范圍匹配，中括弧表達式後邊可以跟上上述模糊匹配的符號來表示數量
多個條件可以 緊跟著寫在同一個中括弧中 ，比如：
[a-zA-Z] ：匹配一個大、小寫字母