python核心程式設計第三版（一）學習筆記：正則表示式

阿新 • • 發佈：2018-12-13

注：下面有些內容不全都來源於原著，這些都是通過各方面的資料收集合並的結果。

1、元字元

3、邊界詞

4、分組詞

一、正則表示式介紹

正則表示式為高階的文字模式匹配、抽取、與/或文字形式的搜尋和替換功能提供了基礎。

這裡主要講針對於python程式設計中的正則表示式內容，也就是講解re模組的應用，因為python是通過標準庫中的re模組來支援正則表示式的。

常見正則表示式符號和特殊字元（後面會針對這些做一些練習題）

符號	描述	示例
Literal	匹配文字字串的字面值literal	Foo
re1\| re2	匹配正則表示式re1或者re2	foo\|bal
.(點)	匹配任何字元(除了\n之外)	b.b
^	匹配字串的起始部分	^Dear
$	匹配字串的終止部分	/bin/*sh$
*	匹配0次或多次前面出現的正則表示式	[A-Za-z0-9]*
+	匹配1次或多次前面出現的正則表示式	[a-z]+\.com
?	匹配0次或1次前面出現的正則表示式	goo?
{N}	匹配N次前面出現的正則表示式	[0-9]{3}
{M,N}	匹配M~N次前面出現的正則表示式	[0-9]{3,5}
[...]	匹配來自字符集的任意單一字元	[aeiou]
[..x-y..]	匹配x~y範圍中的任意單一字元	[0-9],[a-z]
[^...]	不匹配此字符集中出現的任何一個字元，包括某一範圍內的字元(不包括此字符集中出現)	[^aeiou]
(*\|+\|?\|{})?	用於匹配上面頻繁出現/重複出現符號的非貪婪版本(*、+、?、{})	.*?[a-z]
(...)	匹配封閉的正則表示式然後另存為子組	([0-9]{3})?,f(oo\|u)bar
特殊字元
\d	匹配任何十進位制數字，與[0-9]一致(\D與\d相反，不匹配任何非數值型的數字)	data\d+.txt
\w	匹配任何字母數字字元，與[A-Za-z0-9]相同(\W與之相反)	[A-Za-z]\w+
\s	匹配任何空格字元，與[\n\t\r\v\f]相同(\S與之相反)	of\sthe
\b	匹配任何單詞邊界(\B與之相反)	\bThe\b
\N	匹配已儲存的子組N(參見上面的(...))	price:\14
\c	逐字匹配任何特殊字元c(即，僅按字面意思匹配，不匹配特殊含義)	\.,\\,\*
\A(\Z)	匹配字串的起始(結束)(另見上面的^和$)	\ADear
擴充套件表示法
(?iLmsux)	在正則表示式中嵌入一個或者多個特殊“標記“引數(或者通過函式/方法)	(?x),(? Im)
(?...)	表示一個匹配不用儲存的分組	(?:\w+\.)*
(?p<name>...)	像一個僅由name標識而不是數字ID標識的正則分組匹配	(?p<data>)
(?P=name)	在同一字串中匹配由(?p<name)分組的之前文字	(?p=data)
(?#...)	表示註釋，所有內容都被忽略	(?#comment)
(?=...)	匹配條件是如果...出現在之後的位置，而不適用輸入字串；稱作正向前視斷言	（？=.com）
(?!...)	匹配條件是如果...不出現之後的位置，而不使用輸入字串；稱作負向前視斷言	(?!.net)
(?<=...)	匹配條件是如果...出現在之前的位置；而不使用輸入字串；稱作正向後視斷言	(?<=800-)
(?<!...)	匹配條件是如果...不出現在之前的位置，而不使用輸入字串；稱作負向後視斷言	(?<!192\.168\.)
(?(id/name)Y\|N)	如果分組所提供的id或name存在，就返回正則表示式的條件匹配Y，如果不存在就返回N;\|N是可選項	(?(1)y\|x)

二、分類解析

1、元字元

字元	描述
.	除換行符外的任意字元
\	轉義字元
[...]	字元集合
\d	數字:[0-9]
\D	非數字[^0-9]
\s	空白字元[\t\r\n\f、空格]
\S	非空白字元[^\s]
\w	單詞字元[A-Za-z0-9]
\W	非單詞字元[^\w]

# "."萬用字元
>>> import re
>>> pat = re.compile(".")
>>> pat.match('abc')
<_sre.SRE_Match object; span=(0, 1), match='a'>
>>> pat.match("abc").group()
'a'     #匹配到了首個字元
>>> pat.match("abc").groups()
()   
>>> pat.search("abc").group()
'a'
>>> pat.search("abc").groups()
()
>>> pat.match("\n").group()
Traceback (most recent call last):    #換行符匹配出錯
  File "<pyshell#8>", line 1, in <module>
    pat.match("\n").group()
AttributeError: 'NoneType' object has no attribute 'group'
>>>

匹配物件以及group（）和groups（）方法

當處理正則表示式時。除了正則表示式物件之外，還有另一個物件型別：匹配物件（成功呼叫match或search返回的物件）。匹配物件有兩個重要的方法：group（）和groups（）。

group（）要麼返回整個匹配物件，要麼根據要求返回特定子組。

groups（）則僅返回一個包含唯一或者全部子組的元組。

如果沒有子組的要求，group（）仍然返回整個匹配物件，groups（）返回一個空元組。

# "\"轉義符
>>> import re
>>> pat = re.compile("\.")
>>> pat.search("ac.efg").group()
'.'     #匹配到.
>>> pat.findall("ac.efg")
['.']     #不用group,返回列表
>>>

關於re模組在建立模式物件（compile）後的常用函式會在後面詳細講解

# "[...]" : 集合，匹配裡面的任意一個元素
>>> import re
>>> pat = re.compile("[abc]") 
>>> pat.match("axbycz").group()
'a'
>>> pat.search("axbycz").group()
'a'
>>> pat.findall("axbycz")
['a', 'b', 'c']
>>>

# "\d" : 數字
>>> import re
>>> pat = re.compile("\d")
>>> pat.search("ax1by2cz3").group()
'1'    #搜尋到第一個數字:1，返回
>>> pat.match("ax1by2cz3").group()
Traceback (most recent call last):    #匹配不到（首個不是數字）返回None，報錯，match匹配字串頭
  File "<pyshell#4>", line 1, in <module>
    pat.match("ax1by2cz3").group()
AttributeError: 'NoneType' object has no attribute 'group'
>>>  
>>> pat.findall("ax1by2cz3")     #匹配所有的數字，列表返回
['1', '2', '3']

搜尋與匹配的比較

python主要有兩種方法完成模式匹配：搜尋、匹配

搜尋，search（）實現在字串任意部分中搜索匹配的模式

匹配，match（）實現判斷一個字串能否從起始處全部或者部分地匹配某個模式

# "\D" : 非數字
>>> import re
>>> pat = re.compile("\D")
>>> pat.match("ax1by2cz3").group()
'a'
>>> pat.search("ax1by2cz3").group()
'a'
>>> pat.findall("ax1by2cz3")
['a', 'x', 'b', 'y', 'c', 'z']

# "\s" :空白字元有4，包括： \t、\r、\n、空格
>>> import re
>>> pat = re.compile("\s")
>>> pat.findall("\rax1 \nby2 \tcz3")
['\r', ' ', '\n', ' ', '\t']
>>> pat.search("\rax1 \nby2 \tcz3").group()
'\r'
>>> pat.match("\rax1 \nby2 \tcz3").group()
'\r'

# "\S" :非空白字元
>>> import re
>>> pat = re.compile("\S")
>>> pat.search("\rax1 \nby2 \tcz3").group()
'a'
>>> pat.findall("\rax1 \nby2 \tcz3")
['a', 'x', '1', 'b', 'y', '2', 'c', 'z', '3']

# "\w" :單詞字元,數字和字母:[A-Za-z0-9]
>>> import re
>>> pat = re.compile("\w")
>>> pat.findall("1a2b3c")
['1', 'a', '2', 'b', '3', 'c']
>>> pat.search("1a2b3c").group()
'1'
>>> pat.match("1a2b3c").group()
'1'

# "\W":非單詞字元,除數字和字母外
>>> import re
>>> pat = re.compile("\W")
>>> pat.findall("1a2我b3c")
[]
>>> pat.findall("1a2我b3c,4essa.")
[',', '.']
>>> pat.search("1a2我b3c,4essa.").group()
','

2、數量詞：會出現貪婪模式

數量詞	描述
*	匹配前一個字元0次或則多次
+	匹配前一個字元1次或則多次
？	匹配前一個字元0次或則1次
{m}	匹配前一個字元m次
{m,n}	匹配前一個字元m次到n次
數量詞?	非貪婪模式

# "*" ：0次或則多次
>>> import re
>>> pat = re.compile("[abc]*")
>>> pat.match("abcabcdefabc").group()
'abcabc'    #2次
>>> pat.search("abcabcdefabc").group()
'abcabc'    #2次
>>> pat.findall("abcabcdefabc")
['abcabc', '', '', '', 'abc', '']   #2次和1次,因為有0次，所以匹配了''

# "+" ：1次或則多次
>>> import re
>>> pat = re.compile("[abc]+")
>>> pat.match("abcdefabcabc").group()
'abc'
>>> pat.search("abcdefabcabc").group()
'abc'
>>> pat.findall("abcdefabcabc")
['abc', 'abcabc']

# "?" ：0次或則1次，match,search 不會出現none，會出現''
>>> import re
>>> pat = re.compile("[abc]?")
>>> pat.match("defabc").group()
''     #0次
>>> pat.match('abcdefabc').group()
'a'    
>>> pat.search('defabc').group()
''     #0次
>>> pat.findall('defabc')
['', '', '', 'a', 'b', 'c', '']     #0次和1次

# "{m}" ：匹配字串出現m次
>>> import re
>>> pat = re.compile("[op]{2}")     #o或則p出現2次
>>> pat.search("abcooapp").group() 
'oo'      #匹配第一次出現的字串,o比p先出現
>>> pat.findall("abcooapp")
['oo', 'pp']     #匹配出現的所有字串，列表形式返回

# "{m,n}" ：匹配字串出現m到n次
>>> import re
>>> pat = re.compile("[op]{2,4}")     #o或則p出現2到4次
>>> pat.match("pppabcooapp").group()
'ppp'    #匹配開頭
>>> pat.match("ppabcooapp").group()
'pp'     #不連續，非貪婪模式只匹配2次
>>> pat.search("pppabcooapp").group()
'ppp'    #匹配第一次出現
>>> pat.findall("pppabcooapp")
['ppp', 'oo', 'pp']     #匹配所有

# "數量詞?" ：非貪婪模式：只匹配最少的（儘可能少）；預設貪婪模式：匹配最多的（儘可能多）
>>> import re
>>> pat = re.compile("[abc]+")   #貪婪模式
>>> pat.match("abcdefabcabc").group()   #匹配儘可能多的：abc
'abc'
>>> pat.match("bbabcdefabcabc").group()
'bbabc'
>>> pat.search("dbbabcdefabcabc").group()
'bbabc'
>>> pat.findall("abcdefabcabc")
['abc', 'abcabc']
>>>
>>> pat = re.compile("[abc]+?")    #非貪婪模式：+?
>>> pat.match("abcdefabcabc").group()   #匹配儘可能少的：a、b、c
'a'
>>> pat.search('dbbabcdefabcabc').group()
'b'
>>> pat.findall('abcdefabcabc')
['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']

3、邊界詞

邊界詞	描述
^	匹配字串開頭和行首
$	匹配字串結尾和行尾
\A	匹配字串開頭
\Z	匹配字串結尾
\b	匹配\w 和 \W 之間

# "^" ：匹配字串開頭或則行頭
>>> import re
>>> pat = re.compile("^[abc]")   #開頭是abc
>>> pat.search('defabc').group()  
Traceback (most recent call last):   #找不到
  File "<pyshell#2>", line 1, in <module>
    pat.search('defabc').group()
AttributeError: 'NoneType' object has no attribute 'group'
>>> pat.match('defabc').group()
Traceback (most recent call last):   #找不到
  File "<pyshell#3>", line 1, in <module>
    pat.match('defabc').group()
AttributeError: 'NoneType' object has no attribute 'group'
>>> pat.findall('defabc')
[]
>>> pat.search('adefabc').group()
'a'     #開頭是a、b、c中的任意一個
>>> pat.match('adefabc').group()
'a'
>>> pat.findall('adefabc')
['a']

>>> import re
>>> pat = re.compile("^[abc]+")   #開頭是a、b、c中的任意一個的一次或則多次，貪婪：匹配多個
>>> pat.findall("cbadefab")
['cba']
>>> pat = re.compile(r'^[abc]+?')  #開頭是a、b、c中的任意一個的一次或則多次，非貪婪：匹配一個
>>> pat.findall('cbadefab')
['c']

compile中的r表示其後的字串按原樣表示，不使用轉義字元，如： "\n" 表示換行符 r"\n" 表示一個斜槓加上字元n組成的字串

# "$" ：匹配字串結尾或則行尾
>>> import re
>>> pat = re.compile("[abc]$")   
>>> pat.match("adefAbc").group()
Traceback (most recent call last):   #match匹配的是字串開頭，所以查詢$的時總是返回None
  File "<pyshell#2>", line 1, in <module>
    pat.match("adefAbc").group()
AttributeError: 'NoneType' object has no attribute 'group'
>>> pat.search('adefAbc').group()
'c'
>>> pat.findall('adefAbc')
['c']
>>> 
>>> pat = re.compile('[abc]+$')
>>> pat.search('adefAbc').group() #結尾是a、b、c中的任意一個的一次或則多次，貪婪：匹配多個
'bc'
>>> pat.findall('adefAbc')
['bc']
>>>

# "\A"：匹配字串開頭
>>> import re
>>> pat = re.compile("\A[abc]+")
>>> pat.findall('cbadefab')
['cba']
>>> pat.search('cbadefab').group()
'cba'
>>>

# "\Z"：匹配字串結尾
>>> import re
>>> pat = re.compile('[abc]+\Z')
>>> pat.search('cbadefab').group()
'ab'
>>> pat.findall('cbadefab')
['ab']
>>>

4、分組詞

分組方法	描述
\|	左右表示式任意匹配一個，先匹配左邊一旦成功則跳過匹配右邊，如果\|沒有包含在()中,匹配整個正則表示式
(...)	分組匹配,從左到右,每遇到一個 ( 編號+1，分組後面可加數量詞
(?P<name>...)	除了分組序號外,指定一個 name的別名
\<number>	引用編號為<number>的分組匹配到的字串
(?P=name)	引用別名為<name>的分組匹配到的串

# "(...)" ：在模式裡面用()來表示分組（匿名分組）,適用於提取目標字串中的某一些部位。
>>> import re
>>> pat = re.compile(r"(a)\w(c)")  #\w:單詞字元[A-Za-z0-9]
>>> pat.match("abdddcccef").group()  
Traceback (most recent call last):  #一個\w只能匹配一次
  File "<pyshell#2>", line 1, in <module>
    pat.match("abdddcccef").group()
AttributeError: 'NoneType' object has no attribute 'group'
>>> pat.match("adcccef").group()
'adc'
>>> pat = re.compile("(a)b(c)")  #分2組，匿名分組
>>> pat.match("abcdef").group()
'abc'   #預設返回匹配的字串
>>> pat.match("adcdef").group()
Traceback (most recent call last):  #不匹配
  File "<pyshell#6>", line 1, in <module>
    pat.match("adcdef").group()
AttributeError: 'NoneType' object has no attribute 'group'
>>> pat.match('abcdef').group(1)   #取分組1，適用於search
'a'
>>> pat.match('abcdef').group(2)   #取分組2，適用於search
'c'
>>> pat.match('abcdef').groups()   #取所有分組，元組形式返回
('a', 'c')
>>> pat=re.compile(r'www\.(.*)\..{3}')
>>> pat.match('www.dxy.com').group(1)
'dxy'
>>> pat.match('www.dxy.com').groups()
('dxy',)

# "(?P<name>...)" 在模式裡面用()來表示分組（命名分組）,適用於提取目標字串中的某一些部位。
>>> import re
>>> pat = re.compile(r"(?P<K>a)\w(c)")  #分2組：命名分組+匿名分組
>>> pat.search('abcdef').groups()   #取所有分組，元組形式返回
('a', 'c')
>>> pat.search('abcdef').group(1)   #取分組1，適用於search
'a'
>>> pat.search('abcdef').group(2)   #取分組2，適用於search
'c'
>>> pat.search('abcdef').group()    #預設返回匹配的字串
'abc'
>>> pat.search('abcdef').groupdict()    #命名分組可以返回一個字典【專有】，匿名分組則沒有
{'K': 'a'}
>>> pat.search('abcdef').groupdict(2)
{'K': 'a'}
>>> pat.search('abcdef').groupdict(1)
{'K': 'a'}

# "(?P=name)" ：引用命名分組(別名)匹配：
>>> import re
>>> pat=re.compile(r'(?P<K>a)\w(c)(?P=K)')    #(?P=K)引用分組1的值，就是a
>>> pat.search('abcdef').group()
Traceback (most recent call last):     #匹配不到，因為完整'a\wca',模式的第4位是a
  File "<pyshell#3>", line 1, in <module>
    pat.search('abcdef').group()
AttributeError: 'NoneType' object has no attribute 'group'
>>> pat.search('abcadef').group()  #匹配到，模式的第4位和組1一樣,值是a
'abca'
>>> pat.search('abcadef').groups()
('a', 'c')
>>> pat.search('abcadef').group(1)
'a'
>>> pat.search('abcadef').group(2)
'c'

# "\<number>" ：引用分組編號匹配
>>> import re
>>> pat=re.compile(r'(?P<K>a)\w(c)(?P=K)\2')    #\2引用分組2的值，就是c
>>> pat.findall('Aabcadef')     #匹配不到，因為完整'a\wcac',模式的第5位是c
[] 
>>> pat.findall('Aabcacdef')    #匹配到，模式的第5位和組2一樣,值是c
[('a', 'c')]
>>> pat.search('Aabcacdef').groups()
('a', 'c')
>>> pat.search('Aabcacdef').group()
'abcac'
>>> pat.search('Aabcacdef').group(1)
'a'
>>> pat.search('Aabcacdef').group(2)
'c'

5、特殊構造

方法	描述
(?:...)	(...)不分組版本,用於使用 \| 或者後接數量詞
(?iLmsux)	iLmsux的每個字元代表一個匹配模式,只能用在正則表示式的開頭,可選多個
(?#...)	#號後的內容將作為註釋
(?=...)	之後的字串內容需要匹配表示式才能成功匹配
(?!...)	之後的字串不匹配表示式才能成功
(?<=...)	之前的字串需要匹配表示式才能成功
(?<!...)	之前的字串需要不匹配表示式才能成功
(?(id/name) yes \|no)	如果編號為id/名字為name的組匹配到字串,則需要匹配yes,否則匹配no,no可以省略

# "(?:...)" ：()裡面有?:表示該()不是分組
>>> import re
>>> pat = re.compile(r"a(?:bc)")
>>> pat.findall('abc')
['abc']
>>> pat.match('abc').groups()    #顯示不出分組
()

# "(?=...)"：匹配...表示式，返回。對後進行匹配，總是對後面進行匹配
>>> import re
>>> pat=re.compile(r'\w(?=\d)')  #匹配表示式\d，返回數字的前一位，\w：單詞字元[A-Za-z0-9]
>>> pat.findall('abc1 def1 xyz1')
['c', 'f', 'z']
>>> pat.findall('zhoujy20130628hangzhou')   #匹配數字的前一位，列表返回
['y', '2', '0', '1', '3', '0', '6', '2']
>>> 
>>> pat=re.compile(r'\w+(?=\d)')  
>>> pat.findall('abc1,def1,xyz1')    #匹配最末數字的前字串，列表返回
['abc', 'def', 'xyz'] 
>>> pat.findall('abc21,def31,xyz41')
['abc2', 'def3', 'xyz4']
>>> pat.findall('zhoujy20130628hangzhou')
['zhoujy2013062']

>>> import re
>>> pat=re.compile(r'[A-Za-z]+(?=\d)')   #[A-Za-z],匹配字母,可以用其他的正則方法
>>> pat.findall('zhoujy20130628hangzhou123')   #匹配後面帶有數字的字串，列表返回
['zhoujy', 'hangzhou']   
>>> pat.findall('abc21,def31,xyz41')
['abc', 'def', 'xyz']
>>>

# "(?!...)" 不匹配...表示式，返回。對後進行匹配
>>> import re
>>> pat=re.compile(r'[A-Za-z]+(?!\d)')    #[A-Za-z],匹配字母,可以用其他的正則方法
>>> pat.findall('zhoujy20130628hangzhou123,12,binjiang310')
['zhouj', 'hangzho', 'binjian']    #匹配後面不是數字的字串，列表返回
>>> pat.findall('abc21,def31,xyz41')
['ab', 'de', 'xy']
>>>

# "(?<=...)"：匹配...表示式，返回。對前進行匹配,總是對前面進行匹配
>>> import re
>>> pat=re.compile(r'(?<=\d)[A-Za-z]+')   #匹配前面是數字的字母
>>> pat.findall('abc21,def31,xyz41')
[]
>>> pat.findall('1abc21,2def31,3xyz41')
['abc', 'def', 'xyz']
>>> pat.findall('zhoujy20130628hangzhou123,12,binjiang310')
['hangzhou']
>>>

# "(?<!...)"：不匹配...表示式，返回。對前進行匹配,總是對前面進行匹配
>>> import re
>>> pat=re.compile(r'(?<!\d)[A-Za-z]+')   #匹配前面不是數字的字母
>>> pat.findall('abc21,def31,xyz41')
['abc', 'def', 'xyz']
>>> pat.findall('zhoujy20130628hangzhou123,12,binjiang310')
['zhoujy', 'angzhou', 'binjiang']
>>>

#"(?(id\name) yes |no)": 組是否匹配，匹配返回
>>> import re
#no省略了，完整的是a\dbc\d ==> a2bc3,總共5位，第2位是可有可無的數字，第5位是數字
>>> pat=re.compile(r'a(\d)?bc(?(1)\d)')
>>> pat.findall('abc9')
['']    #返回組1，但第2位（組1）沒有，即返回了''
>>> pat.findall('a8bc9')   #完整的模式，返回組1
['8']
>>> pat.match('a8bc9').group()   
'a8bc9'
>>> pat.match('a8bc9').group(1)
'8'
>>> pat.findall('a8bc')
[]
>>>

#"(?iLmsux)":這裡就介紹下i引數：大小寫區分匹配
>>> import re
>>> pat=re.compile(r'abc')
>>> pat.findall('abc')
['abc']
>>> pat.findall('ABC')
[]
>>> pat=re.compile(r'(?i)abc')  #(?i) 不區分大小寫
>>> pat.findall('ABC')
['ABC']
>>> pat.findall('abc')
['abc']
>>> pat.findall('aBc')
['aBc']
>>> pat.findall('aBC')
['aBC']
>>> 
>>> pat=re.compile(r'abc',re.I)   #re.I 作為引數使用，同上作用，推薦
>>> pat.findall('aBC')
['aBC']
>>> pat.findall('abc')
['abc']
>>> pat.findall('ABC')
['ABC']

三、re模組下的函式

函式	描述
compile(pattern)	建立模式物件
search(pattern,string)	在字串中尋找模式
match(pattern,string)	在字串開始處匹配模式
split(pattern,string)	根據模式分割字串
findall(pattern,string)	列表形式返回匹配項
sub(pat,repl,string)	pat匹配想用repl替換
escape(string)	特殊字元轉義

1、compile：

>>> import re
>>> pat = re.compile("A")
>>> m = pat.search("CBA")
>>> print(m)
#匹配到了，返回MatchObject（匹配物件）（True）
<_sre.SRE_Match object; span=(2, 3), match='A'>   
>>> m = pat.search("CBD")
>>> print(m)    #沒有匹配到，返回None（False）
None
>>> 
#上面的等價於，但推薦都用第一種方法，因為將正則表示式轉換為模式物件，實現更有效率的匹配，其他的函式會在內部進行轉換。
>>> re.search("A","CBA")
<_sre.SRE_Match object; span=(2, 3), match='A'>
>>>

2、search：

>>> import re
>>> m = re.search('asd','ASDasd')   
>>> print(m)
<_sre.SRE_Match object; span=(3, 6), match='asd'>   #匹配到了，返回MatchObject（True）
>>> m = re.search('asd','ASDASD')
>>> print(m)   #沒有匹配到，返回None（False）
None
>>>

3、match：

>>> import re
>>> m = re.match('a','Aasd')
>>> print(m)
None
>>> m = re.match('a','aASD')
>>> print(m)
<_sre.SRE_Match object; span=(0, 1), match='a'>

4、split：

>>> import re
>>> re.split(",","a,s,d,asd")
['a', 's', 'd', 'asd']    #返回列表
#等價於上
>>> pat = re.compile(',')
>>> pat.split('a,s,d,asd')
['a', 's', 'd', 'asd']
>>> 
>>> re.split("[, ]+","a ,  s  ,d     ,,,,,asd")  #正則匹配：[, ]+
['a', 's', 'd', 'asd']
>>> re.split("[, ]+","a ,  s  ,d     ,,,,,asd",maxsplit=2)   # maxsplit 最多分割次數
['a', 's', 'd     ,,,,,asd']
>>> 

#說明：根據模式的匹配項來分割字串，類似字串的split 的方法，但是字串的split只能用固定長度的分割符，而re.split允許用任意長度和個數的分割符。

5、findall：

>>> import re
>>> re.findall("a","ASDaDFGAa")
['a', 'a']    #列表形式返回匹配到的字串
>>> pat = re.compile('a')
>>> pat.findall('ASDaDFGAa')
['a', 'a']
>>> pat = re.compile('[A-Z]+')
>>> pat.findall('ASDcDFGAa')
['ASD', 'DFGA']

#說明：列表形式返回給定模式的匹配項。返回所有匹配的字串。

6、sub：

#通過組進行更新替換：
>>> import re
>>> re.sub("a","A","abcasd")
'AbcAsd'
>>> pat = re.compile("a")
>>> pat.sub("A","abcasd")
'AbcAsd'
>>> 
>>> pat=re.compile(r'www\.(.*)\..{3}')
>>> pat.match('www.dxy.com').group(1)
'dxy'
#通過正則匹配找到符合規則的”www.dxy.com“ ，取得組1字串 去替換 整個匹配得到字串。dxy -> www.dxy.com
>>> pat.sub(r'\1','hello,www.dxy.com')
'hello,dxy'
>>> pat=re.compile(r'(\w+) (\w+)')
>>> s='hello world ! hello hz !'
>>> pat.findall('hello world ! hello hz !')
[('hello', 'world'), ('hello', 'hz')]
#通過正則得到組1(hello)，組2(world)，再通過sub去替換。即組1替換組2，組2替換組1，調換位置。
>>> pat.sub(r'\2 \1',s)
'world hello ! hz hello !'

#說明：使用給定的內容替換掉找到的字串。a->A

7、escape：

#轉義
>>> import re
>>> re.escape("www.dxy.cn")
'www\\.dxy\\.cn'

#說明：對字串裡面的特殊字串進行轉義。

四、re模組下函式的方法

>>> import re
>>> pat = re.compile('a')
>>> dir(pat)
['__class__', '__copy__', '__deepcopy__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'findall', 'finditer', 'flags', 'fullmatch', 'groupindex', 'groups', 'match', 'pattern', 'scanner', 'search', 'split', 'sub', 'subn']
>>>

方法	描述
group	獲取子模式(組)的匹配項
start	給定組匹配項的開始位置
end	給定組匹配項的結束位置
span	給定組匹配項的開始結束位置

>>> import re
>>> pat = re.compile(r'www\.(.*)\.(.*)')    #用()表示一個組，2個組
>>> m = pat.match('www.dxy.com')
>>> m.group()   #預設為0，表示匹配整個字串
'www.dxy.com'
>>> m.group(1)  #返回給定組1匹配的子字串
'dxy'
>>> m.group(2)
'com'
>>> m.start(2)  #組2開始的索引
8
>>> m.end(2)    #組2結束的索引
11
>>> m.span(2)   #組2開始、結束的索引
(8, 11)
>>>

python核心程式設計第三版（一）學習筆記：正則表示式

注：下面有些內容不全都來源於原著，這些都是通過各方面的資料收集合並的結果。目錄 1、元字元 3、邊界詞 4、分組詞一、正則表示式介紹正則表示式為高階的文字模式匹配、抽取、與/或文字形式的搜尋和替換功

Python核心程式設計第三版練習參考（第一章：正則表示式）

1-1　識別後續的字串：“bat”、“bit”、“but”、“hat”、“hit”或者“hut”。答：'[bh][aiu]t' 1-2　匹配由單個空格分隔的任意單詞對，也就是姓和名。答：'\w+\s\w+' 1-3　匹配由單個逗號和單個空白符分隔的任何單詞和單個字

Python核心程式設計第三版第一章答案

包含了本人不斷嘗試更加嚴謹的過程： 1-1 re.match(’[bh][aiu]t’, ‘bat’).group() 1-2 re.match(’[A-Z][a-z]+ [A-Z][a-z]+’, ‘Xhen Fiagu’).group() 1-3 re.ma

python核心程式設計(第三版)網路程式設計錯誤修改

//伺服器端程式碼from socket import * from time import ctime host='localhost' port=3330 bufsize = 1024 addr = (host,port) tcpser = socket(AF_INET,SOCK_STREAM)

Python核心程式設計第三版——第一章練習題答案

1.6 練習正則表示式 1-1 [bh][aiu]t; 1-2 \w+ \w+; 1-3 \w+,\s\w+; 1-4 [A-Za-z_]+[\w_]+ python有效識

python進階（2）——re模組：正則表示式1

實驗結果輸出文件，包括多項引數（大約幾百個），想把所有的loss value對應的值提取出來，畫出曲線圖，這就需要用到正則表示式，基於此，開始學習正則表示式。正則表示式：可匹配文字片段的模式萬用字元：句點.(.ython與jpython與python與 ython都匹配，但不與ython

python進階（2）——re模組：正則表示式2

re.split 根據模式來分割字串 import re text='a, b,,,,c d' print(re.split('[, ]+', text)) #re.split:以空格和字串分割字元 re.findall 返回列表，包含所有與給定模式匹配的子串 import re

Python核心程式設計(第3版) pdf 下載

適讀人群：本書適合具有一定經驗的Python開發人員閱讀　　全面涵蓋當今應用開發中的眾多領域　　為中級Python開發人員提供實踐方法　　涵蓋大量實用的程式碼案例　　每章末尾的習題有助於鞏固所學知識　　想進一步提升Python程式設計水平？請深入分析真實應用程式中使用的大量相關主

TensroFlow學習——第三章（一）

MINIST數字識別問題全連線層實現手寫數字識別採用了L2正則化、滑動平均模型和指數衰減學習率訓練結果為：訓練集93%，驗證集95.36%，測試集95.01% 第一部分：前向傳播和網路引數 # 定義前向傳播和神經網路中的引數 import tensorflow as tf

Java第四天——核心技術第三章（2）

繼續第三章的學習。。。運算子運算子+、-、*、/表示加、減、乘、除運算 %求餘操作 /運算兩個運算元都是整數時，表示整數除法；否則，表示浮點數除法例：15/2=7 15%2=1 15.0/2=7.5 整數被0除會產生

Java核心技術--第三章（5）

控制流程條件語句+迴圈結構控制流程條件語句迴圈語句 switch語句（判斷多個值）塊用 { }括起來的若干條Java語句塊可巢狀在另一個塊中 public static void main(String[] args)

Java第四天——核心技術第三章（4）

字串 String類雙引號括起來的 String s = “Enjoy!” ""表示空串子串 String ss = s.substring(0,2); ss=“En” substring(a,b) 子串位

讀書筆記_演算法第四版（一）

演算法第四版（謝路雲譯）第1章基礎 1.1 基礎程式設計模型 l Java程式的基本結構；原始資料型別與表示式；語句；簡便記法；陣列；靜態方法；API；字串；輸入輸出；二分查詢。 l 以下為“答疑”和“練習”中的知識點： l Math.abs(-2147483

領略“軟體工程”之美（一）學習篇：

讀大學之前，我對“軟體工程”沒有一點概念，只是在填報志願的時候才瞭解到，學習好這個專業，需要紮實的數學和英語知識，就果斷地選擇了挑戰一下。軟體工程是一門研究工程化方法構建和維護有效的、實用的和高質量的軟體的學科。它涉

Django入門（一）——學習筆記

說明：該學習筆記是在windows上完成的，所以程式碼部分與linux有區別第一步：建立專案 1.1 建立虛擬環境要使用Django，首先需要建立一個虛擬工作環境。虛擬環境是系統的一個位置，可以在其中安裝包，與python的其他包隔離。我們需要新建一個目錄，命名為l

python學習筆記(四)-----正則表示式

import re xxRegex=re.compile(xxxxxxxxxx) result=xxRegex.search(onestring) print(result.group()) 1.用()分組，分組後可用result.group(int)區分 import

IP地址（IPv4）/IPv6地址的正則表示式

原地址:http://pfeishao.blog.163.com/blog/static/18162337020112113130453/ UUID驗證表示式 ^[0-9a-z]{8}-[0-9a-z]{4}-[0

python學習筆記之正則表示式1

正則表示式正則表示式即RE，我們可以使用正則表示式來匹配字串集，其實正則表示式是一個小型的程式語言。它可以方便我們對於文字任務的操作。對於python來說，re模組就是正則式操作模組。元字元：元字元是特殊的字元，普通的字元在正則表示式中都可以用來匹配自己，如正則表示

Python學習筆記之正則表示式

1、import re # 匯入python正則表示式模組2、正則匹配兩種方式：p = re.compile(r'imooc') # 生成Pattern物件 res = p.match('imooc python') # 呼叫 patern 物件的 matc

《JavaScript高階程式設計(第三版)》讀書筆記（一）

《JavaScript高階程式設計(第三版)》讀書筆記本文內容是關於《JavaScriptt高階程式設計(第三版)》的讀書筆記，而且只是提取個人認為每個章節比較重要或者需要注意的知識點。第一章 JavaScript簡介 1. 一個完整的JavaScipt

python核心程式設計第三版（一）學習筆記：正則表示式

一、正則表示式介紹

二、分類解析

1、元字元

匹配物件以及group（）和groups（）方法

搜尋與匹配的比較

2、數量詞：會出現貪婪模式

3、邊界詞

4、分組詞

5、特殊構造

三、re模組下的函式

1、compile：

2、search：

3、match：

4、split：

5、findall：

6、sub：

7、escape：

四、re模組下函式的方法

相關推薦