正規（regular），要使用正規表示式需要匯入Python中的re（regular正規表示的縮寫）模組。正規表示式是對字串的處理，我們知道，字串中有時候包含很多我們想要提取的信息，掌握這些處理字串的方法，能夠方便很多我們的操作。
正規表示式（regular），處理字串的方法。 http://www.cnblogs.com/alex3714/articles/5169958.html
正規是常用的方法，因為python中檔案處理很常見，檔案中包含的是字串，要處理字串，那麼就需要用到正規表示式。因而要掌握好正規表示式。下面下來看看正規表示式中包含的方法：
（1）match(pattern, string, flags=#0)
def match(pattern, string, flags=0):
"""Try to apply the pattern at at at the start of the string, returning
a match object, or None if no match was found.""
合 , 合
## 從上註：Try to apply the pattern at the start of the string,returning a match object,或 None if no match was found.從字串的開頭開始查找，返回一個match object對象，如果沒有找到，返回一個None。
重點：（1）從開頭開始找；（2）如果查找不到回None。
下面來看看幾個實例：
import re string =
"abcdef" m = re.match(
"abc",string) （1）匹配"abc"，並查看返回的結果是什麼
print(m)
print(m .group())
n = re.match(
"abcf",string)
print(n) l = re.match(
"bcd",string) （3）字串在清單中間找出情況
print(l)
## 運作結果如下：
## <_sre.SRE_Match object; span=(0, 3), match='abc'> （1）
abc （2）
None （3） None （4）
從上面輸出結果（1）可以看出，使用match()匹配，返回的是一個match object對象，要轉換為看得到的情況，要使用group()進行轉換（2）處所示；如果匹配的正規表示式不在字串中，則返回None（3）；match(pattern,string,flag)是從字串開始的地方匹配的，並且只能從字串的開始處進行匹配（4）所示。
（2）fullmatch(pattern, string, flags=0)
# def fullmatch(pattern, string, flags=0):
"""Try to apply the pattern to all of the string, returning
a match object, or None if no match was found.""" return _compile(pattern, flags).fullmatch(string)
從上註：Try to apply the pattern to all of the string,returning a match object,or None if no match was found...
（3）search(pattern,string,flags)
def search(pattern , string, flags=0):
"""Scan through string looking for a match to the pattern, returning """
return _compile(pattern, flags).search(string)
# search(pattern,
,flags)的註解是Scan throgh string looking for a match to the pattern,returning a match object,or None if no match was found.在字符串任意一個位置查找正則表達式，如果找到了則返回match object對象，如果查找不到則回傳None。 重點：（1）從字串中間任一個位置查找，不像match()是從開頭開始查找；（2）如果查找不到則回傳None; import re string =
"ddafsadadfadfafdafdadfasfdafafda" m = re.search(
"a"
m = re.search(
"a" （1）從中間開始符合
print(m)###### print(m.group())###### n = re.search(###"N", string) （2）匹配不到的情況###### print(n)############################## ###### 運作結果如下：############ <_sre.SRE_Match object; span=(2, 3), match='a'> # （1）## （1）## a （2）### None （3）###### 從上面結果(1）可以看出，search(pattern,string,flag=0)可以從中間任一個位置匹配，擴大了使用範圍，不像match()只能從開頭匹配，並且匹配到了返回的也是一個match_object對象；（2）要想展示一個match_object對象，那麼需要使用group()方法；（3）如果查找不到，則返回一個None。
（4）sub(pattern,repl,string,count=0,flags=0)
# def sub(pattern, repl, string, count=0, flags=0):
"""Return the string obtained by replacing the leftmost
non-overlapping occurrences of the pattern in string by the
〠 pl. if a string, backslash escapes in it are processed. If it is
a callable, it's passed the match object and must return
str place#string"#.
## return _compile(pattern, flags).sub(repl, string, count)
# sub(pattern,repl,string,count=0, flags=0)查找替換，就是先查找pattern是否在字串string中；repl是要把pattern匹配的對象，就要把正則表達式找到的字符替換為什麼；count可以指定匹配個數，匹配多少個。範例如下：
import re
string = "ddafsadadfadfafdafdadfasfdafafda"
m = re.sub(dafafda"
m = re.sub(
a.sub(##" a","A",string) #不指定替換個數（1）
print(m)
n = re.sub(
"a","A",string,2) ##指定替換個數（2）
print(n)
# l = re.sub(
"F","B",string) #未配對的情況（3）
print(l)
運作結果如下：
ddAfsAdAdfAdfAfdAfdAdfAsf -- (2） ddafsadadfadfafdafdadfasfdafafda --（3）
## 上面程式碼（1）是沒有指定配對的個數，那麼預設是將所有的都配對了；（2）處指定了符合的個數數，那麼只符合指定個數的；（3）處要符合的正則pattern不在字串中，則傳回原來的字串。
重點：（1）可以指定符合個數，不指定符合所有；（2）如果符合不到會回傳原來的字串；
(5)subn(pattern,repl,string,count=0,flags=0)
## def subn(pattern, repl ，字串，count = 0，flags = 0）：
“”“返回一個2個托盤包含（new_string，number）。
新_STRING是獲得的字串透過將來源
中最左邊的模式替換為替換repl。串，則處理其中的反斜線轉義。 return _compile(pattern, flags).subn(repl, string, count)
## 上註回傳一個2 元組，其中包含（new_string，number）：傳回一個元組，用於存放正規匹配後面的新的字串與符合的個數(new_string,number)。 #m = re.subn("a","A",string) #全部替換的情況（1）#【 print(m)】n = re.subn("a",
"A",string,3) 取代部分 （
2）
##取代部分 （2）
##取代部份 （2）
替換部分A",string)
#指定替換的字串不存在 （
3###）################################################# ##print(l)############ ################################ #################### ######################### 運作結果如下：## ########## ('ddAfsAdAdfAdfAfdAfdAdfAsfdAfAfdA', 11) （1 ）###（'ddAfsAdAdfadfdfdadfasfdafda, #（'ddAfsAdAdfadfdfdadfasfdafda, # dafdadfasfdafafda', 0） （3）## #### 從上面程式碼輸出的結果可以看出，sub()和subn(pattern,repl,string,count=0,flags=0)可以看出，兩者匹配的效果是一樣的，只是傳回的結果不同而已，sub()回傳的還是一個字串，而subn()回傳的是一個元組，用來存放正規之後新的字串，和替換的個數。
（6）split(pattern,string,maxsplit=0,flags=0)
# def split(pattern, string, maxsplit=0, flags=0):
"""Split the source string by the occurces # the pattern,
## returning a list containing the resulting substrings. If
capturing。 the pattern are also returned as part of the resulting
list. If maxsplit is nonzero, at most maxsplit splits occur,
and the remainder of the ing of the list."""
return _compile(pattern, flags).split(string, maxsplit)
split(pattern,string,maxsplit=0,flags=0)是字串的分割，依照某個正規要求pattern分割字串，回傳一個列表returning a list containing the resulting substrings.就是按照某種方式分割字串，並把字串放在一個列表中。實例如下：
import re string =
"ddafsadadfadfafdafdadfasfdafafda" m = re.split(dafafda"
## m = re.split(
" a",string)
#分割字串（1） print(m)
n = re.split(" a",string,
3)
##指定分割次數# print(n)
l = re.split("F",string )
#分割字串不存在清單中 print(l)
##################################### 執行結果如下：###### ####### ['dd', 'fs', 'd', 'df', 'df', 'fd', 'fd', 'df', 'sfd', 'f', 'fd ', ''] （1）### ['dd', 'fs', 'd', 'dfadfafdafdadfasfdafafda'] ['ddafsadadfadfafdafdadfasfdafafda'] 從（1）可以看出，如果字串開頭或結尾包含要分割的字串，後面元素會是一個""；（2）處我們可以指定要分割的次數；（3 ）處如果要分割的字串不存在清單中，則把原字串放在清單中。
（7）findall(pattern,string,flags=)
# def findall(pattern, string, flags=0):
"""Return a list of all non-overlapping matches in the string.
If one or more capturing groups are present in the pattern, return
a list of groups; this will be a list of tuples if the pattern# # 〠〠 >
## Empty matches are included in the result."""
return _#pile(pattern, flags).find return _#pattern(terntern, flags).find#return
all##pattern, flags)。
## findall(pattern,string,flags=)是傳回一個列表，包含所有符合的元素。存放在一個清單中。範例如下： import re string =
"dd12a32d46465fad1648fa1564fda127fd11ad30fa02fad1648fa1564fda127fd11ad30fa02fad1648fa1564fda127fd11ad30fa02fad1648fa1564fda127fd11ad30fa02fad1648fa1564fda127fd11ad30fa02fad1641. " [a-z]",string) #符合字母，並符合所有的字母，並傳回一個清單（1） print(m)
# n = re.findall(
"[0 -9]" 的術語string) #匹配不到的情況 （3）
print(l)
運行結果如下： ['d', 'd', 'a', 'd', 'f', 'a' , 'd', 'f', 'a', 'f', 'd', 'a', 'f', 'd', 'a', 'd', 'f', 'a', ' s', 'f', 'd', 'a', 'f', 'a', 'f', 'd', 'a'] （1） ['1', '2', '3', '2', '4', '6', '4', '6', '5', '1', '6', '4', '8', '1', '5 ', '6', '4', '1', '2', '7', '1', '1', '3', '0', '0', '2', '5', '8'] （2） [] （3)## )處符合了字串中的數字，回到一個清單中；（3）處符合不存在的情況，並傳回一個空列表。
重點：（1）符合不到的時候回傳一個空的清單；（2）如果沒有指定符合次數，則只單一符合。
（8）finditer(pattern,string,flags=0)
defdef finditer(pattern ) , string, flags=0):
"""返回
字串中所有非重疊匹配的迭代器。對於每個個匹配，迭代器返回一個匹配對象。 ，flags）.finditer（string）
finditer(pattern,string ) 尋找模式，傳回遍歷模式中所有不重疊匹配項的迭代器字串。 import re
"dd12a32d46465fad1648fa1564fda127fd11ad30fa02sfd58afafda"
;
##a>Sf; ",string)"AB",string)
列印(n)
#
運作結果如下： （1） （2） 從上面運作結果可以看出，finditer(pattern,string,flags=0)回傳一個iterator物件。
# (9) compile(pattern,flags=0)
defcompile(pattern,flags=
0) : "編譯一個正規表示模式，傳回一個模式物件。"
return _compile(pattern, flags)
# （10）pruge()
# def purge (): "清除正規表示式快取" _cache.＠ clear()
# (11)template(pattern,flags=0)
def template(pattern, flags =
0): "編譯一個範本模式，傳回一個模式物件"
return _compile(pattern, flags|T) ## 正規表達式：
# 正規表示式：
# 文法: import re
string = "dd12a32d46465fad1648fa1564fda127fd11ad30fa02) #先使用compile(pattern)進行編譯
m = p.match(string) #然後進行匹配
print(m.group())
上面的第2 和第3行也可以合併成一行來寫：
m = p.match("^[0-9]",'14534Abc'#) <span style="font-family: 宋体"></span>
# 效果是相同的，差異在於，第一種方式是事先對要匹配的格式進行了編譯（對匹配公式進行解析）
，這樣再去匹配的時候就不用在編譯匹配的格式，第2種簡寫是每次匹配的時候都要進行一次匹配公式的編譯，所以，如果你需要從一個5w行的檔案中匹配出所有以數字開頭的行，建議先把正規公式進行編譯再匹配，這樣速度會快點。 符合的格式：
（1）^ 符合字串的開頭
# import re
string = "dd12a32d41648f27fd11a0sfdda"
]## search()
來符合以數字開始的 m = re.search(
"^[0-9]",string) #符合字串開頭以數字開始 1） print(m)
n = re.search("^[a-z]+",string)
##符合字串開頭以字母為字母開頭以字母為字母開頭以字母為開頭以字母開頭以字母為開頭以字母。開始，如果是從開頭匹配，就與search()
沒有太多的區別了 （2）
# print(n.group())
運作結果如下：
None
dd
在上面（1）處我們使用^從字串開頭開始匹配，匹配開始是否是數字，由於字串前面是字母，不是數字，所以匹配失敗，返回None；（2）處我們以字母開始匹配，由於開頭是字母，匹配正確，返回正確的結果；這樣看，其實^類似match()從開頭開始匹配。
（2）$ 符合字串的結尾# import re
string = "15111252598"
# #^符合字串的開頭，現在我們使用## #^
#search()來符合以數字開始的
m = re.match("^[0-9]{11}$",string) print(m. group())
# 運作結果如下：
15111252598
re.match("^[0-9]{11}$",string)意思是符合以數字開頭，長度為11，結尾為數字的格式； （3）點（·） 符合任意字符，除了換行符。當re.DoTALL標記被指定時，則可以匹配包含換行符的任意字元
# import re string = "1511
\n1252598"
#點（
·）是符合除了換行符號以外所有的字元 m = re. match(".",string) #點
(·)是符合任意字符，沒有指定個數就符合單一 （1）
print (m.group()) n = re.match(".+",string)
#.+是符合多個任一字符，除了換行符 )
print(n.group())
#################################### ######################### 運作結果如下：############ 1### 1511##### 1#### 1511###### ######## 從上面程式碼運行結果可以看出，（1）處點（·）是匹配任意字元；（2）處我們匹配任意多個字符，但是由於字串中間包含了空格，結果就只符合了字串中換行符前面的內容，後面的內容沒有符合。 ############ 重點：（1）點（·）符合除了換行符之外任意字元；（2）.+可以符合多個除了換行符的字元。 ############### （4）[...] 如[abc]符合"a","b"或"c"############ #### [object]符合括號中的包含的字元。 [A-Za-z0-9]表示匹配A-Z或a-z或0-9。 ###### import re
string = "1511\n125dadfadf2598"
#[]匹配相符包含括號中的字元
m = re.findall("[5fd]",string) #符合字串中的5,f,d
# print(m)
運作結果如下：
['5', '5', 'd', 'd', 'f', 'd', 'f', '5' ]
上面程式碼，我們是要符合字串中的5,f,d並回傳一個清單。
（5）[^...] [^abc]符合除了abc之外的任一字元
import re
string = "1511\n125dadfadf2598"
# #[^]包含編號中的符合編號中的符合編號中的符合編號中的符合編號中的符合編號字元
m = re.findall("[^5fd]",string) #符合字串除5,f,d之外的字元
print(m)
# 運作如下：
['1', '1', '1', '\n', '1', '2', 'a', 'a ', '2', '9', '8']
上面程式碼，我們匹配除了5,f,d之外的字符，[^]是匹配非中括號內字符之外的字符。
（6）* 符合0個或多個的表達式
import re
string = "1511\n125dadfadf2598"
## #*是符合#0個或多個的表達式 m = re.findall(
"\d*",string) #符合0個或多個數字## print(m)
運作結果如下：
['1511', '', '125', '', '', '', '', '', '', '' , '2598', '']
### 從上面運行結果可以看出(*)是匹配0個或多個字元的表達式，我們匹配的是0個或多個數字，可以看出，如果匹配不到返回的是空，最後位置哪裡回傳的是一個空("")。
（7）+ 符合1個或多個的表達式
import re
import re
## import re string = "1511
\n125dadfadf2598"
#（+）是符合#1個或多個的表達式 m = re.findall("\d+",string) #符合1個或多個數字 print(m)
運作如下： ['1511', '125', '2598']
加（＋）是符合1個或多個表達式，上面\d+是符合1個或多個數字表達式，至少符合一個數字。
（8）? 配對0或1個的表達式，非貪婪方式
import re string = "1511\n125dadfadf2598"
##（?
## ##（?#）是符合##0個或1個的表達式 m = re.findall("\d?",string)
## 0個或1個的表達式
print(m)
######################################### ######################################## ########## ## 運作結果如下：############ ['1', '5', '1', '1', '', '1', '2', '5', '', '', '', '', '', '', '', '2', '5', '9', '8', '']########## ## 上面問號（？）是符合0個或1個表達式，上面是符合0個或1個的表達式，如果符合不到則回傳空("")###### （9）{n} 配對n次，定義一個字串符合的次數
## m} 配對n到m次表達式
（11）\w ## \w是符合字串中的字母和數字，程式碼如下：
import re string = "1511
\n 125dadfadf2598"
#（?
）是符合0
個或1個的表達式 m = re.findall("\w",string) #符合0個或
1個的表達式 print(m)
# 運作如下：
['1' , '5', '1', '1', '1', '2', '5', 'd', 'a', 'd', 'f', 'a', 'd', ' f', '2', '5', '9', '8']
從上面程式碼可以看出，\w是用來配對字串中的字母數字的。我們使用正規匹配字母和數字。
（12）\W \W大寫的W是用來匹配非字母和數字的，與小寫w正好相反
# 實例如下：
import re string = "1511
\n125dadfadf2598"
# #\W用來符合字串中的非字母和數字 m = re.findall(
"\W",string) #\W
用來匹配字串中的非字母和數字 print(m)
########################################################################################################################################################### ###### ############ 運作如下：############ ['\n']########################################################################## # 上面程式碼中，\W是用來配對非字母和數字的，結果把換行符號配對出來了。 ############### （13）\s 符合任一空白字符，以[\n\t\f]########## 實例如下：
import re
string = "1511\n125d\t a\rdf\fadf2598"
#\s是用來匹配字串中的任意空白字符，等價於[\n\t\r\f]
m = re.findall("\s",string) #\s#用來符合字串中任一空白字元
print(m)
# 運作如下：
['\n' , '\t', '\r', '\x0c'] 從上面程式碼運行結果可以看出:\s是用來匹配任意空的字符，我們把空的字元符合出來了
（14）\S 比對任一非空白字元
實例如下：
import re string = "1511\n125d\ta\ rdf\fadf2598"# #\S是用來符合任意非空白字元 m = re.findall(
"\S",string) #\S用來符合每日任意非空白字元
print(m)
############### ########### ## 運作如下：############ ['1', '5', '1', '1', '1', '2', '5', 'd', 'a', 'd', 'f', 'a', 'd', 'f', '2', '5', '9', '8']########### ## 從上面程式碼可以看出，\S是用來匹配任意非空字符，結果中，我們匹配了任意非空的字符。 ############### （15）\d 符合任一數字，等價於[0-9]####################################################### （16）\D 符合任意非數字############### 總結：findall()，split()產生的都是列表，一個是以某個為分隔符，一個是以查找中所有的值。正好相反。 ######
以上是正規表示式（regular）的詳細內容。更多資訊請關注PHP中文網其他相關文章！
