目錄
正則表達式的簡單入門
正則表達式(regular expression)描述了一種字符串匹配的模式（pattern），可以用來檢查一個串是否含有某種子串、將匹配的子串替換或者從某個串中取出符合某個條件的子串等。
正則表達式是由普通字符（例如字符 a 到 z）以及特殊字符（稱爲"元字符"）組成的文字模式。模式描述在搜索文本時要匹配的一個或多個字符串。正則表達式作爲一個模板，將某個字符模式與所搜索的字符串進行匹配。
我儘量的在捋明白當下內容時不涉及還沒學到的內容。當然我在寫博客的時候已經稍微明白一些了，無法客觀地站在一個完全的小白的角度來逐層分解。
普通字符
普通字符包括沒有顯式指定爲元字符的所有可打印和不可打印字符。這包括所有大寫和小寫字母、所有數字、所有標點符號和一些其他符號。
非打印字符
|
字符 |
描述 |
|
\cx |
匹配由x指明的控制字符。例如， \cM 匹配一個 Control-M 或回車符。x 的值必須爲 A-Z 或 a-z 之一。否則，將 c 視爲一個原義的 'c' 字符。 |
|
\f |
匹配一個換頁符。等價於 \x0c 和 \cL。 |
|
\n |
匹配一個換行符。等價於 \x0a 和 \cJ。 |
|
\r |
匹配一個回車符。等價於 \x0d 和 \cM。 |
|
\s |
匹配任何空白字符，包括空格、製表符、換頁符等等。等價於 [ \f\n\r\t\v]。注意 Unicode 正則表達式會匹配全角空格符。 |
|
\S |
匹配任何非空白字符。等價於 [^ \f\n\r\t\v]。 |
|
\t |
匹配一個製表符。等價於 \x09 和 \cI。 |
|
\v |
匹配一個垂直製表符。等價於 \x0b 和 \cK。 |
特殊字符
即在正則表達式中不能單純作爲普通字符，而擁有特定功能或者可以替代其他字符的某些字符
對於這些字符如果我們想取他們的字面意思應在其之前使用轉義字符反斜槓“\”
|
特別字符 |
描述 |
|
$ |
匹配輸入字符串的結尾位置。如果設置了 RegExp 對象的 Multiline 屬性，則 $ 也匹配 '\n' 或 '\r'。要匹配 $ 字符本身，請使用 \$。 |
|
( ) |
標記一個子表達式的開始和結束位置。子表達式可以獲取供以後使用。要匹配這些字符，請使用 \( 和 \)。 |
|
* |
匹配前面的子表達式零次或多次。要匹配 * 字符，請使用 \*。 |
|
+ |
匹配前面的子表達式一次或多次。要匹配 + 字符，請使用 \+。 |
|
. |
匹配除換行符 \n 之外的任何單字符。要匹配 . ，請使用 \. 。 |
|
[ |
標記一箇中括號表達式的開始。要匹配 [，請使用 \[。 |
|
? |
匹配前面的子表達式零次或一次，或指明一個非貪婪限定符。要匹配 ? 字符，請使用 \?。 |
|
\ |
將下一個字符標記爲或特殊字符、或原義字符、或向後引用、或八進制轉義符。例如， 'n' 匹配字符 'n'。'\n' 匹配換行符。序列 '\\' 匹配 "\"，而 '\(' 則匹配 "("。 |
|
^ |
在一個表達式開頭中時，表示匹配輸入字符串的開始位置；在方括號表達式中時，表示除了該方括號表達式中的字符集合，即“非”。要匹配 ^ 字符本身，請使用 \^。 |
|
{ |
標記限定符表達式的開始。要匹配 {，請使用 \{。 |
|
| |
指明兩項之間的一個選擇。要匹配 |，請使用 \|。 |
限定符
限定符用來指定正則表達式的一個給定組件必須要出現多少次才能滿足匹配。
|
字符 |
描述 |
|
* |
匹配前面的子表達式零次或多次。例如，'zo*' （zo需至少出現0次）能匹配 "z"（因爲"z"中出現了0次"zo"） 以及 "zoo"。* 等價於{0,}。 |
|
+ |
匹配前面的子表達式一次或多次。例如，'zo+'（zo需至少出現一次）能匹配 "zo" 以及 "zoo"，但不能匹配 "z"，因爲"z"中並沒有出現至少一次 "zo"。+ 等價於 {1,}。 |
|
? |
匹配前面的子表達式零次或一次。例如，'do(es)?'（匹配do後面出現一次es或出現0次es的字符串，即匹配do或does） 可以匹配 "do" 、 "does" 中的 "does" 、 "doxy"（出現了do） 中的 "do" 。? 等價於 {0,1}。 |
|
{n} |
n 是一個非負整數。匹配確定的 n 次。例如，'o{2}' （匹配"oo"）不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的兩個 o。 |
|
{n,} |
n 是一個非負整數。至少匹配n 次。例如，'o{2,}' （匹配至少出現兩次"o"的字符串，如"oo"、"ooo"、"oooo"……）不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等價於 'o+'。'o{0,}' 則等價於 'o*'。 |
|
{n,m} |
m 和 n 均爲非負整數，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，"o{1,3}" （匹配"o"、"oo"、"ooo"）將匹配 "fooooood" 中的前三個 o。'o{0,1}' 等價於 'o?'。請注意在逗號和兩個數之間不能有空格。 |
PS：關於小括號()、中括號[]、花括號{}做一下總結
() 一個子表達式，在該範圍內單獨表達某種字符串。表達式中有幾個()就有幾個相應的匹配子字符串。()本身不匹配任何東西，也不限制匹配任何東西，只是把括號內的內容作爲同一個表達式來處理。
例如(ab){1,3}，就表示ab一起連續出現最少1次，最多3次。如果沒有括號的話，ab{1,3},就表示a，後面緊跟的b出現最少1次，最多3次。
[]是定義匹配的字符範圍。比如[abcde]匹配abcde中的任意一個，[abcdefghijklmnopqrstuvwxyz]匹配任意小寫字母，等價於[a-z]，即"-"段橫槓表示在某某範圍內，[1-9]表示匹配數字1到9一次， [a-zA-Z0-9] 表示相應位置的字符要匹配一個英文字符或一個數字。特殊字符寫在[]會被當成普通字符來匹配。例如[(a)]，會匹配(、a、)、這三個字符。
{}一般用來表示匹配的長度，比如 \s{3} 表示匹配三個空格，\s{1,3}表示匹配一到三個空格。
(0-9) 匹配 '0-9′ 本身。 [0-9]* 匹配數字（注意後面有 *，可以爲空，即零個或多個）[0-9]+ 匹配數字（注意後面有 +，不可以爲空，即至少出現一次）{1-9} 寫法錯誤。
[0-9]{0,9} 表示長度爲 0 到 9 的數字字符串。
一些例子：
[1-9][0-9]* //匹配一串數字，第一個數字不可以是0，即匹配大於1的所有整數
[1-9][0-9]+ //匹配一串數字，至少是一個兩位數，且開頭第一個數字不可以是0，即匹配大於10的所有整數
[1-9][0-9]？//匹配1~99的數字
[1-9][0-9]{0,1} //匹配1~99的數字
[0-9]{1,2} //匹配0~99的數字
關於貪婪匹配和非貪婪匹配
貪婪匹配：匹配儘可能多的內容
非貪婪匹配：只要出現第一個符合的內容即停止匹配
例子：
<H1>Chapter 1 - 介紹正則表達式</H1>
針對上面一行字符串，如果我們要匹配"<"和">"中的內容，則
貪婪匹配：“<H1>Chapter 1 - 介紹正則表達式</H1>”
非貪婪匹配：“<H1>”
*、+ 限定符都是貪婪的，因爲它們會盡可能多的匹配文字，在它們的後面加上一個?就可以實現非貪婪或最小匹配。
如同樣一上面的字符串舉例，匹配"<"">"之間內容的代碼爲
<.*> //此時爲貪婪匹配，會得到<H1>Chapter 1 - 介紹正則表達式</H1>，因爲會盡可能多的匹配所有符合條件的內容，即字面意思的貪婪
<.*?> //此時爲非貪婪匹配，會得到<H1>，當第一次出現代表結束的符號">"時即停止匹配，因爲已經滿足條件了
" .* "： "."即匹配除換行符 \n 之外的任何單字符，
"*"即匹配前面的字符或子表達式零次或多次
所以".*"是以貪婪模式匹配任意多個除了換行符以外的字符。但".*？"是以非貪婪模式匹配任意多個除了換行符以外的字符。
Cats are smarter than dogs and humans
(.*) smarter (.*?) .*
上面的例子中（.*）是貪婪模式，而且後面有【空格】smarter【空格】……，所以他會一直匹配直到出現第一次【空格】smarter【空格】，然後後面是 （.*?）【空格】.* ，此時（.*?）爲非貪婪模式進行匹配，所以當她後面出現第一個【空格】時即停止匹配，所以（.*?）匹配了smarter【空格】後面的than，而再後面的【空格】dogs……由 .* 匹配。如果此時把表達式換爲
(.*) smarter (.*) .*
則【空格】smarter【空格】後面的（.*）將匹配到最後一個空格之前的所有內容，即他將匹配than dogs and，因爲and後面的空格是本句中最後一個空格。
定位符
定位符用來描述字符串或單詞的邊界，能夠將正則表達式的查找目標固定到行首或行尾。
|
字符 |
描述 |
|
^ |
匹配輸入字符串開始的位置。如果設置了 RegExp 對象的 Multiline 屬性，^ 還會與 \n 或 \r 之後的位置匹配。 |
|
$ |
匹配輸入字符串結尾的位置。如果設置了 RegExp 對象的 Multiline 屬性，$ 還會與 \n 或 \r 之前的位置匹配。 |
|
\b |
匹配一個單詞邊界，即字與空格間的位置。 |
|
\B |
非單詞邊界匹配。 |
注意！限定符和定位符不能一起使用，即不能將兩者搭配。
關於上面定位符的使用實例：
^Chapter [1-9][0-9]{0,1}$ //查找以Chapter爲開頭，以1~99數字爲結尾的字符串，中間有空格
^Chapter$ //精確匹配，只匹配單詞Chapter，就不匹配包含該單詞的句子了，因爲該句子中並不僅僅包含該單詞
關於單詞邊界的描述：
單詞的邊界即每個“單詞”（無論是不是一個完整的單詞只要是一連串的無空格的字符串）與兩邊空格之間的位置；非單詞邊界即其他任意位置。
例如：
\bCha //可以匹配Cha開頭的所有單詞
ter\b //可以匹配以ter爲結尾的所有單詞
\Bapt //可以匹配不處在單詞邊界上的所有apt，比如chapter的apt，但無法匹配aptitude中的apt，因爲他在邊界上
運算符的優先級：
正則表達式從左到右進行計算，並遵循優先級順序，這與算術表達式非常類似。
相同優先級的從左到右進行運算，不同優先級的運算先高後低。下表從最高到最低說明了各種正則表達式運算符的優先級順序：
|
運算符 |
描述 |
|
\ |
轉義符 |
|
(), (?:), (?=), [] |
圓括號和方括號 |
|
*, +, ?, {n}, {n,}, {n,m} |
限定符 |
|
^, $, \+任何元字符、任何字符 |
定位點和序列（即：位置和順序） |
|
| |
替換，"或"操作 字符具有高於替換運算符的優先級，使得"m|food"匹配"m"或"food"。若要匹配"mood"或"food"，請使用括號創建子表達式，從而產生"(m|f)ood"。 |
匹配規則：
模式：是一組描述字符串特徵的字符，是正則表達式最基本的元素，往往用特殊的字符表示一個範圍內的字符、重複出現，或上下文。上面的匹配例子（大概）都是模式（吧？）
字符簇：（好像）就是一箇中括號包括裏面的東西
一些小例子：
|
字符簇 |
描述 |
|
^[^0-9][0-9]$ |
第一個字符不能是數字第二個字符必須是數字的兩字符字符串 |
|
[^a-z] |
除了小寫字母以外的所有字符 |
|
[^\\\/\^] |
除了(\)(/)(^)之外的所有字符，"\\"表示轉義後的"\"，"\/"表示轉義後的"/"，"\^"表示轉義後的"^" |
|
[^\"\'] |
除了雙引號(")和單引號(')之外的所有字符 |
|
^[a-zA-Z_]$ |
所有的字母和下劃線 |
|
^a$ |
字母a |
|
^a{4}$ |
aaaa |
|
^a{2,4}$ |
aa,aaa或aaaa |
|
^a{1,3}$ |
a,aa或aaa |
|
^a{2,}$ |
包含多於兩個a的字符串 |
|
^a{2,} |
如：aardvark和aaab，但apple不行 |
|
a{2,} |
如：baad和aaa，但Nantucket不行 |
|
\t{2} |
兩個製表符 |
|
.{2} |
任意的兩個字符 |
|
^[a-zA-Z0-9_]{1,}$ |
所有包含一個以上的字母、數字或下劃線的字符串 |
|
^[1-9][0-9]{0,}$ |
所有的正整數 |
|
^\-{0,1}[0-9]{1,}$ |
所有的整數 |
還有一個比較麻煩的例子：
^[-]?[0-9]+\.?[0-9]+$
表示所有浮點數。"^[-]?"表示開頭出現一次或零次"-"負號（正數和負數），"[0-9]+"表示是匹配至少一次數字（小數點前面必須要有一位數字的，不然怎麼是浮點數），"\.?"轉義後的"."出現一次或零次（畢竟整數從某種意義上也算浮點數），"[0-9]+$"匹配小數點後面的任意位數字，並且以該任意個數字結尾。
PS：
"？"與{0，1}等價
"* "與{0，}等價
"+ "與{1，}等價
替換和分組：
所謂替換即“或”，具體表現是就是在兩者中間匹配任意一個都可以，例如：
Chapter|Section //匹配 Chapter 或 Section
但是注意
^Chapter|Section [1-9][0-9]{0,1}$
並不會如大家所願匹配成"Chapter [數字]"或"Session [數字]"，而是Chapter或Session [數字]，
如果要匹配成理想的亞子，應該這樣寫
^(Chapter|Section) [1-9][0-9]{0,1}$
所謂分組
@@@asd090***
1、@@@[a-z]{3}[0-9]{3}\*\*\*
2、(@@@)([a-z]{3})([0-9]{3})(\*\*\*)
上面兩個表達式匹配的內容完全相同，只不過第二句多了幾個括號將“@@@”、“字母”、“數字”、“***”分割開了但是小括號將匹配後的字符串進行了分組，每個小括號爲一組，即上面有小括號那一次匹配中共有四組，而沒有使用小括號的表達式沒有分組情況。我個人覺得只有在後面需要用group、groups時這個分組的功能纔有用。
(@@@)、(asd)、(090)、(***)
當然如果表達式是這樣的，即只在最兩邊加了括號，則只有一個分組即它本身
(@@@[a-z]{3}[0-9]{3}\*\*\*)
此外，Python等語言還有自己的分組命名機制，可以對各個分組進行命名，後面會涉及。
其他例子：
|
正則表達式 |
描述 |
|
/\b([a-z]+) \1\b/gi |
一個單詞連續出現的位置。 |
|
/(\w+):\/\/([^/:]+)(:\d*)?([^# ]*)/ |
將一個URL解析爲協議、域、端口及相對路徑。 |
|
/^(?:Chapter|Section) [1-9][0-9]{0,1}$/ |
定位章節的位置。 |
|
/[-a-z]/ |
a至z共26個字母再加一個-號。 |
|
/ter\b/ |
可匹配chapter，而不能匹配terminal。 |
|
/\Bapt/ |
可匹配chapter，而不能匹配aptitude。 |
|
/Windows(?=95 |98 |NT )/ |
可匹配Windows95或Windows98或WindowsNT，當找到一個匹配後，從Windows後面開始進行下一次的檢索匹配。 |
|
/^\s*$/ |
匹配空行。 |
|
/\d{2}-\d{5}/ |
驗證由兩位數字、一個連字符再加 5 位數字組成的 ID 號。 |
|
/<\s*(\S+)(\s[^>]*)?>[\s\S]*<\s*\/\1\s*>/ |
匹配 HTML 標記。 |
綜上所述，無論是分析一個正則表達式要匹配什麼內容還是寫一個正則表達式，要點就是從淺到深由小到大，一層一層的分析或者寫。
元字符
沒啥可說的，看看就行，因爲我覺得常用的在前面都介紹了，剩下的的瞄幾眼就OK
|
字符 |
描述 |
|
\ |
將下一個字符標記爲一個特殊字符、或一個原義字符、或一個 向後引用、或一個八進制轉義符。例如，'n' 匹配字符 "n"。'\n' 匹配一個換行符。序列 '\\' 匹配 "\" 而 "\(" 則匹配 "("。 |
|
^ |
匹配輸入字符串的開始位置。如果設置了 RegExp 對象的 Multiline 屬性，^ 也匹配 '\n' 或 '\r' 之後的位置。 |
|
$ |
匹配輸入字符串的結束位置。如果設置了RegExp 對象的 Multiline 屬性，$ 也匹配 '\n' 或 '\r' 之前的位置。 |
|
* |
匹配前面的子表達式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等價於{0,}。 |
|
+ |
匹配前面的子表達式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等價於 {1,}。 |
|
? |
匹配前面的子表達式零次或一次。例如，"do(es)?" 可以匹配 "do" 或 "does" 。? 等價於 {0,1}。 |
|
{n} |
n 是一個非負整數。匹配確定的 n 次。例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的兩個 o。 |
|
{n,} |
n 是一個非負整數。至少匹配n 次。例如，'o{2,}' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等價於 'o+'。'o{0,}' 則等價於 'o*'。 |
|
{n,m} |
m 和 n 均爲非負整數，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，"o{1,3}" 將匹配 "fooooood" 中的前三個 o。'o{0,1}' 等價於 'o?'。請注意在逗號和兩個數之間不能有空格。 |
|
? |
當該字符緊跟在任何一個其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 後面時，匹配模式是非貪婪的。非貪婪模式儘可能少的匹配所搜索的字符串，而默認的貪婪模式則儘可能多的匹配所搜索的字符串。例如，對於字符串 "oooo"，'o+?' 將匹配單個 "o"，而 'o+' 將匹配所有 'o'。 |
|
. |
匹配除換行符（\n、\r）之外的任何單個字符。要匹配包括 '\n' 在內的任何字符，請使用像"(.|\n)"的模式。 |
|
(pattern) |
匹配 pattern 並獲取這一匹配。所獲取的匹配可以從產生的 Matches 集合得到，在VBScript 中使用 SubMatches 集合，在JScript 中則使用 $0…$9 屬性。要匹配圓括號字符，請使用 '\(' 或 '\)'。 |
|
(?:pattern) |
匹配 pattern 但不獲取匹配結果，也就是說這是一個非獲取匹配，不進行存儲供以後使用。這在使用 "或" 字符 (|) 來組合一個模式的各個部分是很有用。例如， 'industr(?:y|ies) 就是一個比 'industry|industries' 更簡略的表達式。 |
|
(?=pattern) |
正向肯定預查（look ahead positive assert），在任何匹配pattern的字符串開始處匹配查找字符串。這是一個非獲取匹配，也就是說，該匹配不需要獲取供以後使用。例如，"Windows(?=95|98|NT|2000)"能匹配"Windows2000"中的"Windows"，但不能匹配"Windows3.1"中的"Windows"。預查不消耗字符，也就是說，在一個匹配發生後，在最後一次匹配之後立即開始下一次匹配的搜索，而不是從包含預查的字符之後開始。 |
|
(?!pattern) |
正向否定預查(negative assert)，在任何不匹配pattern的字符串開始處匹配查找字符串。這是一個非獲取匹配，也就是說，該匹配不需要獲取供以後使用。例如"Windows(?!95|98|NT|2000)"能匹配"Windows3.1"中的"Windows"，但不能匹配"Windows2000"中的"Windows"。預查不消耗字符，也就是說，在一個匹配發生後，在最後一次匹配之後立即開始下一次匹配的搜索，而不是從包含預查的字符之後開始。 |
|
(?<=pattern) |
反向(look behind)肯定預查，與正向肯定預查類似，只是方向相反。例如，"(?<=95|98|NT|2000)Windows"能匹配"2000Windows"中的"Windows"，但不能匹配"3.1Windows"中的"Windows"。 |
|
(?<!pattern) |
反向否定預查，與正向否定預查類似，只是方向相反。例如"(?<!95|98|NT|2000)Windows"能匹配"3.1Windows"中的"Windows"，但不能匹配"2000Windows"中的"Windows"。 |
|
x|y |
匹配 x 或 y。例如，'z|food' 能匹配 "z" 或 "food"。'(z|f)ood' 則匹配 "zood" 或 "food"。 |
|
[xyz] |
字符集合。匹配所包含的任意一個字符。例如， '[abc]' 可以匹配 "plain" 中的 'a'。 |
|
[^xyz] |
負值字符集合。匹配未包含的任意字符。例如， '[^abc]' 可以匹配 "plain" 中的'p'、'l'、'i'、'n'。 |
|
[a-z] |
字符範圍。匹配指定範圍內的任意字符。例如，'[a-z]' 可以匹配 'a' 到 'z' 範圍內的任意小寫字母字符。 |
|
[^a-z] |
負值字符範圍。匹配任何不在指定範圍內的任意字符。例如，'[^a-z]' 可以匹配任何不在 'a' 到 'z' 範圍內的任意字符。 |
|
\b |
匹配一個單詞邊界，也就是指單詞和空格間的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。 |
|
\B |
匹配非單詞邊界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。 |
|
\cx |
匹配由 x 指明的控制字符。例如， \cM 匹配一個 Control-M 或回車符。x 的值必須爲 A-Z 或 a-z 之一。否則，將 c 視爲一個原義的 'c' 字符。 |
|
\d |
匹配一個數字字符。等價於 [0-9]。 |
|
\D |
匹配一個非數字字符。等價於 [^0-9]。 |
|
\f |
匹配一個換頁符。等價於 \x0c 和 \cL。 |
|
\n |
匹配一個換行符。等價於 \x0a 和 \cJ。 |
|
\r |
匹配一個回車符。等價於 \x0d 和 \cM。 |
|
\s |
匹配任何空白字符，包括空格、製表符、換頁符等等。等價於 [ \f\n\r\t\v]。 |
|
\S |
匹配任何非空白字符。等價於 [^ \f\n\r\t\v]。 |
|
\t |
匹配一個製表符。等價於 \x09 和 \cI。 |
|
\v |
匹配一個垂直製表符。等價於 \x0b 和 \cK。 |
|
\w |
匹配字母、數字、下劃線。等價於'[A-Za-z0-9_]'。 |
|
\W |
匹配非字母、數字、下劃線。等價於 '[^A-Za-z0-9_]'。 |
|
\xn |
匹配 n，其中 n 爲十六進制轉義值。十六進制轉義值必須爲確定的兩個數字長。例如，'\x41' 匹配 "A"。'\x041' 則等價於 '\x04' & "1"。正則表達式中可以使用 ASCII 編碼。 |
|
\num |
匹配 num，其中 num 是一個正整數。對所獲取的匹配的引用。例如，'(.)\1' 匹配兩個連續的相同字符。 |
|
\n |
標識一個八進制轉義值或一個向後引用。如果 \n 之前至少 n 個獲取的子表達式，則 n 爲向後引用。否則，如果 n 爲八進制數字 (0-7)，則 n 爲一個八進制轉義值。 |
|
\nm |
標識一個八進制轉義值或一個向後引用。如果 \nm 之前至少有 nm 個獲得子表達式，則 nm 爲向後引用。如果 \nm 之前至少有 n 個獲取，則 n 爲一個後跟文字 m 的向後引用。如果前面的條件都不滿足，若 n 和 m 均爲八進制數字 (0-7)，則 \nm 將匹配八進制轉義值 nm。 |
|
\nml |
如果 n 爲八進制數字 (0-3)，且 m 和 l 均爲八進制數字 (0-7)，則匹配八進制轉義值 nml。 |
|
\un |
匹配 n，其中 n 是一個用四個十六進制數字表示的 Unicode 字符。例如， \u00A9 匹配版權符號 (?)。 |
Python中的正則表達式
上面的內容讓門學會了正則表達式本身的用法和基本的匹配規則。我們可以在任何支持正則表達式的語言中使用。
我主要介紹一下Python中的基本用法。
Python自從1.5版本之後引入了正則表達式模塊“re”，使用時需要先
import re
下面逐一介紹在python中常用的幾種函數。
re.match函數
re.match 嘗試從字符串的起始位置匹配一個模式，如果不是起始位置匹配成功的話，match()就返回none；如果在起始位置匹配成功，則返回_sre.SRE_Match object這樣一個對象，其中包含所匹配字符串的起止位置和該目標字符串。
函數語法：
re.match(pattern, string, flags=0)
函數參數說明：
| 參數 | 描述 |
|---|---|
| pattern | 匹配的正則表達式 |
| string | 要匹配的字符串。 |
| flags | 標誌位，用於控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等等。在最後一小節由詳細介紹 |
匹配成功re.match方法返回一個匹配的對象，否則返回None。
例如：
text1 = "f123"
text2 = "123f"
print(re.match("[a-z]", text1)) # 匹配成功，打印 <_sre.SRE_Match object; span=(0, 1), match='f'>
print(re.match("[a-z]", text2)) # 匹配失敗，打印 None。因爲小寫字母並不位於起始位置
對於match返回的匹配對象，span表示匹配到的定位（對於match永遠是span=(0, *)，*爲字符串長度），match表示匹配成功的字符是什麼。
我們可以使用group(number) 或 groups() 來獲取匹配成功後返回的對象中的內容。
| 匹配對象方法 | 描述 |
|---|---|
| group(number) |
如果正則表達式中使用了（）小括號則該方法中的number有效。該方法可以根據小括號獲得分組，number中的數字表示取第幾組。如果不填參數或填“0”，則返回整個匹配對象，此時表達式中有沒有用小括號分組無所謂都可以使用。group() 可以一次輸入多個組號，在這種情況下它將返回一個包含那些組所對應值的元組。 |
| groups() | 返回一個包含所有小組字符串的元組，從 1 到 所含的小組號，即groups()=(group(1), group(2), group(3)……)。 |
js_def = "@@@asd090***"
print(re.match("@@@[a-z]{3}[0-9]{3}\*\*\*", js_def).group())
print(re.match("(@@@)([a-z]{3})([0-9]{3})(\*\*\*)", js_def).group())
print(re.match("(@@@)([a-z]{3})([0-9]{3})(\*\*\*)", js_def).group(1,2))
print(re.match("(@@@)([a-z]{3})([0-9]{3})(\*\*\*)", js_def).groups())
re.search方法
re.search 掃描整個字符串並返回第一個成功的匹配。
函數語法：
re.search(pattern, string, flags=0)
函數參數說明：
| 參數 | 描述 |
|---|---|
| pattern | 匹配的正則表達式 |
| string | 要匹配的字符串。 |
| flags | 標誌位，用於控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等等。在最後一小節由詳細介紹 |
匹配成功re.search方法返回一個匹配的對象，跟re.match一樣都是_sre.SRE_Match object，否則返回None。
我們可以使用group(num) 或 groups() 匹配對象函數來獲取匹配表達式。
| 匹配對象方法 | 描述 |
|---|---|
| group(num=0) | 匹配的整個表達式的字符串，group() 可以一次輸入多個組號，在這種情況下它將返回一個包含那些組所對應值的元組。 |
| groups() | 返回一個包含所有小組字符串的元組，從 1 到 所含的小組號。 |
換句話說就是用法和match方法幾乎完全相同，只是match只能從字符串的起始位置匹配，search纔是真正意義上我們平時理解的的在字符串中任意位置匹配。
例子：
1、
text = "Cats are smarter than dogs and humans"
print(re.search("are", text))
打印結果：
2、上面那個探索貪婪模式的例子（注意空格）
text = "Cats are smarter than dogs and humans"
print(re.search("(.*) smarter (.*) (.*)", text).groups())
print(re.search("(.*) smarter (.*?) (.*)", text).groups())
打印結果：
3、可以在匹配的結果後面直接調用span來查看匹配的長度。
print(re.search('www', 'www.runoob.com').span()) #(0, 3)
print(re.search('com', 'www.runoob.com').span()) #(11, 14)
接下來填一個之前留下的坑
Python命名分組機制
(?P<name>正則表達式) #name是一個合法的標識符
在一般的正則表達式中，一個括號內的內容作爲一個小組。
([a-z]*)(23333)
可以通過下面的語句爲其在python語言中命名並取出
(?P<letter>[a-z]*)(?P<number>23333)
group("letter")
group("number")
看一個例子
s = "ip='230.192.168.78',version='1.0.0'"
print(re.search(r"ip='(?P<ip_address>\d+\.\d+\.\d+\.\d+).*", s).group('ip_address')) #'230.192.168.78'
phone = "123-719796895"
res=re.search(r"(?P<quhao>\d+)-(?P<num>\d+)", phone)
print(res.group('quhao')) #'123'
print(res.group('num')) #'719796895'
re.findall方法
re.findall 掃描整個字符串並以列表的形式返回所有匹配成功的子串。
函數語法：
re.findall(pattern, string, flags=0)
函數參數說明：
| 參數 | 描述 |
|---|---|
| pattern | 匹配的正則表達式 |
| string | 要匹配的字符串。 |
| flags | 標誌位，用於控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等等。在最後一小節由詳細介紹 |
匹配成功re.search方法返回一個list，其中包含了所有匹配成功的子串。但是，沒有group可以用了。
還有另一種findall的用法後面學完compile再說
檢索和替換
Python 的 re 模塊提供了re.sub用於替換字符串中的匹配項。
語法：
re.sub(pattern, repl, string, count=0, flags=0)
函數參數說明：
| 參數 | 描述 |
|---|---|
| pattern | 匹配的正則表達式 |
| repl | 替換的字符串，也可爲一個函數 |
| string | 要匹配的字符串。 |
| count | 模式匹配後替換的最大次數，默認 0 表示替換所有的匹配 |
實例：
phone = "2004-959-559 # 這是一個國外電話號碼"
# 刪除字符串中的 Python註釋
num = re.sub("\#.*$", "", phone)
print(num) # 2004-959-559
# 刪除非數字(-)的字符串
num = re.sub('\D', "", phone)
print(num) # 2004959559
此處需要額外說一下參數pattern：
在正則表達式中反斜槓加數字（\N）對應着該表達式中使用小括號分好的組（我不知道在別的函數中是不是也可以這麼用）
比如\6，表示匹配本表達式中的第6個group
意味着，pattern中，前面肯定是存在對應的，第6個group，然後你後面也才能去引用
比如，想要處理：
this is tonysure's blog and he is not a famous bloger.
現在要把is is tonysure's blog and he is not換成tonysure is
則就可以這樣的re.sub實現替換：
text = "this is tonysure's blog and he is not a famous bloger."
replacedStr = re.sub(r"th(is)(.*)\1 not", "tonysure is", text )
#此句中 r 表示去掉反斜槓的轉移機制
print (replacedStr) #tonysure is a famous bloger.
表達式pattern中使用小括號分了兩組，第一組是（is），第二組是第一個is到not的所有內容，\1取了第一組的內容，也就是說如果不適用\1，則句子變爲
replacedStr = re.sub(r"th(is)(.*)(is) not", "tonysure is", text )
同樣如果換爲
replacedStr = re.sub(r"(th)(is)(.*)\2 not", "tonysure is", text )
與原句表達相同。
參數repl：
如果repl是字符串的話，其中的任何反斜槓轉義字符，都會被處理的。
即：
\n：會被處理爲對應的換行符；
\r：會被處理爲回車符；
其他不能識別的轉移字符，則只是被識別爲普通的字符。比如\j，會被處理爲j這個字母本身；
雙反斜槓\\加數字表示默認分組（也可以在前面加r，只用單反斜槓就夠了）；
反斜槓加g以及尖括號<>內一個名字，即：\g<named group>，匹配命了名的組，
text = "this is tonysure's blog and he is not a famous bloger."
replacedStr = re.sub(r"th(is)(.*)\1 not", "\\1", text )
replacedStr = re.sub(r"th(is)(.*)\1 not", r"\1", text )
replacedStr = re.sub(r"th(?P<test_name>is)(.*)\1 not", "\g<test_name>", text )
#全都打印 is a famous bloger.
print (replacedStr) #
如果被匹配的是個函數：
# 將匹配的數字乘以 2
def double(matched):
value = int(matched.group('value'))
return str(value * 2)
s = 'A23G4HFD567'
print(re.sub('(?P<value>\d+)', double, s))
#A46G8HFD1134
這是菜鳥上給的例子，確實可以跑，但是之前不知道(?P<value>\d+)可以一次性把句子中所有的數字匹配出來而且統一分組命名爲value
re.compile 函數
compile 函數用於編譯正則表達式，生成一個正則表達式（ Pattern ）對象，供 match() 和 search() 這兩個函數使用。
語法格式爲：
re.compile(pattern[, flags])
函數參數說明：
| 參數 | 描述 |
|---|---|
| pattern | 匹配的正則表達式 |
| flags | 標誌位，用於控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等等。在最後一小節由詳細介紹 |
將上面使用過的大部分例子使用compile函數進行改寫
patter = re.compile("(@@@)([a-z]{3})([0-9]{3})(\*\*\*)")
print(patter.match("@@@asd090***").groups())
patter = re.compile("(.*) smarter (.*) (.*)")
print(patter.match("Cats are smarter than dogs and humans").groups())
patter = re.compile("(.*) smarter (.*?) (.*)")
print(patter.match("Cats are smarter than dogs and humans").groups())
patter = re.compile("\#.*$")
number1 = patter.sub("" ,"2004-959-559 # 這是一個國外電話號碼")
print(number1)
patter = re.compile('\D')
number2 = patter.sub("", str(number1))
print(number2)
inputStr = "hello crifan, nihao crifan"
patter = re.compile(r"([a-z].*) (\w+), nihao \2")
replacedStr = patter.sub("crifanli", inputStr)
print (replacedStr) #crifanli
text = "this is tonysure's blog and he is not a famous bloger."
patter = re.compile(r"th(?P<test_name>is)(.*)\1 not",)
replacedStr = patter.sub("\g<test_name>", text )
#此句中 r 表示去掉反斜槓的轉移機制
print (replacedStr) #
patter = re.compile('(?P<value>\d+)')
s = 'A23G4HFD567'
print(patter.sub(double, s))
打印結果如下：
re.compile.findall函數：
回來填之前埋下的另一個坑，findall的另一個版本。其實使用效果差不多。
語法格式爲：
findall(string[, pos[, endpos]])
函數參數說明：
| 參數 | 描述 |
|---|---|
| string | 待匹配的字符串。 |
| pos | 可選參數，指定字符串的起始位置，默認爲 0。 |
| endpos | 可選參數，指定字符串的結束位置，默認爲字符串的長度。 |
直接貼例子吧我覺得到現在應該算挺簡單的了
pattern = re.compile(r'\d+') # 查找數字
result1 = pattern.findall('runoob 123 google 456')
result2 = pattern.findall('run88oob123google456', 0, 10)
print(result1)
print(result2)
#['123', '456']
#['88', '12']
re.finditer
和 findall 類似，在字符串中找到正則表達式所匹配的所有子串，並把它們作爲一個迭代器返回。
re.finditer(pattern, string, flags=0)
函數參數說明：
| 參數 | 描述 |
|---|---|
| pattern | 匹配的正則表達式 |
| string | 要匹配的字符串。 |
| flags | 標誌位，用於控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等等。在最後一小節由詳細介紹 |
it = re.finditer(r"\d+","12a32bc43jf3")
for match in it:
print (match.group() )
#12
#32
#43
#3
re.split
split 方法按照能夠匹配的子串將字符串分割後返回列表，它的使用形式如下：
re.split(pattern, string[, maxsplit=0, flags=0])
參數：
| 參數 | 描述 |
|---|---|
| pattern | 匹配的正則表達式 |
| string | 要匹配的字符串。 |
| maxsplit | 分隔次數，maxsplit=1 分隔一次，默認爲 0，不限制次數。 |
| flags | 標誌位，用於控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等等。在最後一小節由詳細介紹 |
正則表達式修飾符 - 可選標誌
就是之前說的flag標誌位，正則表達式可以包含一些可選標誌修飾符來控制匹配的模式。修飾符被指定爲一個可選的標誌。多個標誌可以通過按位 OR(|) 它們來指定。如 re.I | re.M 被設置成 I 和 M 標誌：
| 修飾符 | 描述 |
|---|---|
| re.I | 使匹配對大小寫不敏感 |
| re.L | 做本地化識別（locale-aware）匹配 |
| re.M | 多行匹配，影響 ^ 和 $ |
| re.S | 使 . 匹配包括換行在內的所有字符 |
| re.U | 根據Unicode字符集解析字符。這個標誌影響 \w, \W, \b, \B. |
| re.X | 該標誌通過給予你更靈活的格式以便你將正則表達式寫得更易於理解。 |
我把我需要學的東西寫的差不多了，可能不是很全可能很淺薄不深刻，但是希望對看完的你有所幫助。感謝閱讀。