java 正则首位8或者9的8位数字_Python 正则表达式re最完整的操作教程
本文來自Python 官方文檔，告訴大家一個好消息，官網(wǎng)有中文版的啦~~
re --- 正則表達(dá)式操作
源代碼: Lib/re.py
這個模塊提供了與 Perl 語言類似的正則表達(dá)式匹配操作。
模式和被搜索的字符串既可以是 Unicode 字符串 (str) ，也可以是8位字節(jié)串 (bytes)。 但是，Unicode 字符串與8位字節(jié)串不能混用：也就是說，你不能用一個字節(jié)串模式去匹配 Unicode 字符串，反之亦然；類似地，當(dāng)進(jìn)行替換操作時，替換字符串的類型也必須與所用的模式和搜索字符串的類型一致。
正則表達(dá)式使用反斜杠('\')來表示特殊形式，或者把特殊字符轉(zhuǎn)義成普通字符。 而反斜杠在普通的 Python 字符串里也有相同的作用，所以就產(chǎn)生了沖突。比如說，要匹配一個字面上的反斜杠，正則表達(dá)式模式不得不寫成 '\\\\'，因?yàn)檎齽t表達(dá)式里匹配一個反斜杠必須是 \\ ，而每個反斜杠在普通的 Python 字符串里都要寫成 \\ 。
解決辦法是對于正則表達(dá)式樣式使用 Python 的原始字符串表示法；在帶有 'r' 前綴的字符串字面值中，反斜杠不必做任何特殊處理。 因此 r"\n" 表示包含 '\' 和 'n' 兩個字符的字符串，而 "\n" 則表示只包含一個換行符的字符串。 樣式在 Python 代碼中通常都會使用這種原始字符串表示法來表示。
絕大部分正則表達(dá)式操作都提供為模塊函數(shù)和方法，在 編譯正則表達(dá)式. 這些函數(shù)是一個捷徑，不需要先編譯一個正則對象，但是損失了一些優(yōu)化參數(shù)。
參見 第三方模塊 regex , 提供了與標(biāo)準(zhǔn)庫 re 模塊兼容的API接口, 同時還提供了額外的功能和更全面的Unicode支持。
正則表達(dá)式語法
一個正則表達(dá)式(或RE)指定了一集與之匹配的字符串；模塊內(nèi)的函數(shù)可以讓你檢查某個字符串是否跟給定的正則表達(dá)式匹配(或者一個正則表達(dá)式是否匹配到一個字符串，這兩種說法含義相同)。
正則表達(dá)式可以拼接； 如果 A 和 B 都是正則表達(dá)式， 那么 AB 也是正則表達(dá)式。 通常， 如果字符串 p 匹配 A 并且另一個字符串 q 匹配 B, 那么 pq 可以匹配 AB。除非 A 或者 B 包含低優(yōu)先級操作，A 和 B 存在邊界條件；或者命名組引用。所以，復(fù)雜表達(dá)式可以很容易的從這里描述的簡單源語表達(dá)式構(gòu)建。 了解更多正則表達(dá)式理論和實(shí)現(xiàn)，參考the Friedl book [Frie09] ，或者其他編譯器構(gòu)建的書籍。
以下是正則表達(dá)式格式的簡要說明。更詳細(xì)的信息和演示，參考 正則表達(dá)式HOWTO。
正則表達(dá)式可以包含普通或者特殊字符。絕大部分普通字符，比如 'A', 'a', 或者 '0'，都是最簡單的正則表達(dá)式。它們就匹配自身。你可以拼接普通字符，所以 last 匹配字符串 'last'. (在這一節(jié)的其他部分，我們將用 this special style 這種方式表示正則表達(dá)式，通常不帶引號，要匹配的字符串用 'in single quotes' ，單引號形式。)
有些字符，比如 '|' 或者 '('，屬于特殊字符。 特殊字符既可以表示它的普通含義， 也可以影響它旁邊的正則表達(dá)式的解釋。
重復(fù)修飾符 (*, +, ?, {m,n}, 等) 不能直接嵌套。這樣避免了非貪婪后綴 ? 修飾符，和其他實(shí)現(xiàn)中的修飾符產(chǎn)生的多義性。要應(yīng)用一個內(nèi)層重復(fù)嵌套，可以使用括號。 比如，表達(dá)式 (?:a{6})* 匹配6個 'a' 字符重復(fù)任意次數(shù)。
特殊字符是：
.
(點(diǎn)) 在默認(rèn)模式，匹配除了換行的任意字符。如果指定了標(biāo)簽 DOTALL ，它將匹配包括換行符的任意字符。
^
(插入符號) 匹配字符串的開頭， 并且在 MULTILINE 模式也匹配換行后的首個符號。
$
匹配字符串尾或者換行符的前一個字符，在 MULTILINE 模式匹配換行符的前一個字符。 foo 匹配 'foo' 和 'foobar' , 但正則 foo$ 只匹配 'foo'。更有趣的是， 在 'foo1\nfoo2\n' 搜索 foo.$ ，通常匹配 'foo2' ，但在 MULTILINE 模式 ，可以匹配到 'foo1' ；在 'foo\n' 搜索 $ 會找到兩個空串：一個在換行前，一個在字符串最后。
*
對它前面的正則式匹配0到任意次重復(fù)， 盡量多的匹配字符串。 ab* 會匹配 'a'， 'ab'， 或者 'a'``后面跟隨任意個 ``'b'。
+
對它前面的正則式匹配1到任意次重復(fù)。 ab+ 會匹配 'a' 后面跟隨1個以上到任意個 'b'，它不會匹配 'a'。
?
對它前面的正則式匹配0到1次重復(fù)。 ab? 會匹配 'a' 或者 'ab'。
*?, +?, ??
'*', '+'，和 '?' 修飾符都是 貪婪的；它們在字符串進(jìn)行盡可能多的匹配。有時候并不需要這種行為。如果正則式 <.> 希望找到 ' b <c>'，它將會匹配整個字符串，而不僅是 ''。在修飾符之后添加 ? 將使樣式以 非貪婪`方式或者 :dfn:`最小 方式進(jìn)行匹配； 盡量 少 的字符將會被匹配。 使用正則式 <.> 將會僅僅匹配 ''。
"{m}"
對其之前的正則式指定匹配 m 個重復(fù)；少于 m 的話就會導(dǎo)致匹配失敗。比如， a{6} 將匹配6個 'a' , 但是不能是5個。
"{m, n}"
對正則式進(jìn)行 m 到 n 次匹配，在 m 和 n 之間取盡量多。 比如，a{3,5} 將匹配 3 到 5個 'a'。忽略 m 意為指定下界為0，忽略 n 指定上界為無限次。 比如 a{4,}b 將匹配 'aaaab' 或者1000個 'a' 尾隨一個 'b'，但不能匹配 'aaab'。逗號不能省略，否則無法辨別修飾符應(yīng)該忽略哪個邊界。
{m,n}?
前一個修飾符的非貪婪模式，只匹配盡量少的字符次數(shù)。比如，對于 'aaaaaa'， a{3,5} 匹配 5個 'a' ，而 a{3,5}? 只匹配3個 'a'。
\
轉(zhuǎn)義特殊字符(允許你匹配 '*', '?', 或者此類其他)，或者表示一個特殊序列；特殊序列之后進(jìn)行討論。
如果你沒有使用原始字符串( r'raw' )來表達(dá)樣式，要牢記Python也使用反斜杠作為轉(zhuǎn)義序列；如果轉(zhuǎn)義序列不被Python的分析器識別，反斜杠和字符才能出現(xiàn)在字符串中。如果Python可以識別這個序列，那么反斜杠就應(yīng)該重復(fù)兩次。這將導(dǎo)致理解障礙，所以高度推薦，就算是最簡單的表達(dá)式，也要使用原始字符串。
[]
用于表示一個字符集合。在一個集合中：
字符可以單獨(dú)列出，比如 [amk] 匹配 'a'， 'm'， 或者 'k'。
可以表示字符范圍，通過用 '-' 將兩個字符連起來。比如 [a-z] 將匹配任何小寫ASCII字符， [0-5][0-9] 將匹配從 00 到 59 的兩位數(shù)字， [0-9A-Fa-f] 將匹配任何十六進(jìn)制數(shù)位。 如果 - 進(jìn)行了轉(zhuǎn)義 (比如 [a\-z])或者它的位置在首位或者末尾(如 [-a] 或 [a-])，它就只表示普通字符 '-'。
特殊字符在集合中，失去它的特殊含義。比如 [(+*)] 只會匹配這幾個文法字符 '(', '+', '*', or ')'。
字符類如 \w 或者 \S (如下定義) 在集合內(nèi)可以接受，它們可以匹配的字符由 ASCII 或者 LOCALE 模式?jīng)Q定。
不在集合范圍內(nèi)的字符可以通過 取反 來進(jìn)行匹配。如果集合首字符是 '^' ，所有 不 在集合內(nèi)的字符將會被匹配，比如 [^5] 將匹配所有字符，除了 '5'， [^^] 將匹配所有字符，除了 '^'. ^ 如果不在集合首位，就沒有特殊含義。
在集合內(nèi)要匹配一個字符 ']'，有兩種方法，要么就在它之前加上反斜杠，要么就把它放到集合首位。比如， [()[\]{}] 和 []()[{}] 都可以匹配括號。
Unicode Technical Standard #18 里的嵌套集合和集合操作支持可能在未來添加。這將會改變語法，所以為了幫助這個改變，一個 FutureWarning 將會在有多義的情況里被 raise，包含以下幾種情況，集合由 '[' 開始，或者包含下列字符序列 '--', '&&', '~~', 和 '||'。為了避免警告，需要將它們用反斜杠轉(zhuǎn)義。
在 3.7 版更改: 如果一個字符串構(gòu)建的語義在未來會改變的話，一個 FutureWarning 會 raise 。
|
A|B， A 和 B 可以是任意正則表達(dá)式，創(chuàng)建一個正則表達(dá)式，匹配 A 或者 B. 任意個正則表達(dá)式可以用 '|' 連接。它也可以在組合(見下列)內(nèi)使用。掃描目標(biāo)字符串時， '|' 分隔開的正則樣式從左到右進(jìn)行匹配。當(dāng)一個樣式完全匹配時，這個分支就被接受。意思就是，一旦 A 匹配成功， B 就不再進(jìn)行匹配，即便它能產(chǎn)生一個更好的匹配。或者說，'|' 操作符絕不貪婪。 如果要匹配 '|' 字符，使用 \|， 或者把它包含在字符集里，比如 [|].
(...)
(組合)，匹配括號內(nèi)的任意正則表達(dá)式，并標(biāo)識出組合的開始和結(jié)尾。匹配完成后，組合的內(nèi)容可以被獲取，并可以在之后用 \number 轉(zhuǎn)義序列進(jìn)行再次匹配，之后進(jìn)行詳細(xì)說明。要匹配字符 '(' 或者 ')', 用 \( 或 \), 或者把它們包含在字符集合里: [(], [)].
(?…)
這是個擴(kuò)展標(biāo)記法 (一個 '?' 跟隨 '(' 并無含義)。 '?' 后面的第一個字符決定了這個構(gòu)建采用什么樣的語法。這種擴(kuò)展通常并不創(chuàng)建新的組合； (?P<name>...) 是唯一的例外。 以下是目前支持的擴(kuò)展。
(?aiLmsux)
( 'a', 'i', 'L', 'm', 's', 'u', 'x' 中的一個或多個) 這個組合匹配一個空字符串；這些字符對正則表達(dá)式設(shè)置以下標(biāo)記 re.A (只匹配ASCII字符), re.I (忽略大小寫), re.L (語言依賴), re.M (多行模式), re.S (點(diǎn)dot匹配全部字符), re.U (Unicode匹配), and re.X (冗長模式)。 (這些標(biāo)記在 模塊內(nèi)容 中描述) 如果你想將這些標(biāo)記包含在正則表達(dá)式中，這個方法就很有用，免去了在 re.compile() 中傳遞 flag 參數(shù)。標(biāo)記應(yīng)該在表達(dá)式字符串首位表示。
(?:…)
正則括號的非捕獲版本。 匹配在括號內(nèi)的任何正則表達(dá)式，但該分組所匹配的子字符串 不能 在執(zhí)行匹配后被獲取或是之后在模式中被引用。
(?aiLmsux-imsx:…)
('a', 'i', 'L', 'm', 's', 'u', 'x' 中的0或者多個， 之后可選跟隨 '-' 在后面跟隨 'i' , 'm' , 's' , 'x' 中的一到多個 .) 這些字符為表達(dá)式的其中一部分 設(shè)置 或者 去除 相應(yīng)標(biāo)記 re.A (只匹配ASCII), re.I (忽略大小寫), re.L (語言依賴), re.M (多行), re.S (點(diǎn)匹配所有字符), re.U (Unicode匹配), and re.X (冗長模式)。(標(biāo)記描述在 模塊內(nèi)容 .)
'a', 'L' and 'u' 作為內(nèi)聯(lián)標(biāo)記是相互排斥的， 所以它們不能結(jié)合在一起，或者跟隨 '-' 。 當(dāng)他們中的某個出現(xiàn)在內(nèi)聯(lián)組中，它就覆蓋了括號組內(nèi)的匹配模式。在Unicode樣式中， (?a:...) 切換為 只匹配ASCII， (?u:...) 切換為Unicode匹配 (默認(rèn)). 在byte樣式中 (?L:...) 切換為語言依賴模式， (?a:...) 切換為 只匹配ASCII (默認(rèn))。這種方式只覆蓋組合內(nèi)匹配，括號外的匹配模式不受影響。
3.6 新版功能.
在 3.7 版更改: 符號 'a', 'L' 和 'u' 同樣可以用在一個組合內(nèi)。
(?P<name>…)
(命名組合)類似正則組合，但是匹配到的子串組在外部是通過定義的 name 來獲取的。組合名必須是有效的Python標(biāo)識符，并且每個組合名只能用一個正則表達(dá)式定義，只能定義一次。一個符號組合同樣是一個數(shù)字組合，就像這個組合沒有被命名一樣。
命名組合可以在三種上下文中引用。如果樣式是 (?P<quote>['"]).*?(?P=quote) (也就是說，匹配單引號或者雙引號括起來的字符串)：
引用組合 "quote" 的上下文
引用方法
在正則式自身內(nèi)
(?P=quote) (如示)
\1
處理匹配對象 m
m.group('quote')
m.end('quote') (等)
傳遞到 re.sub() 里的 repl 參數(shù)中
\g<quote>
\g<1>
\1
(?P=name)
反向引用一個命名組合；它匹配前面那個叫 name 的命名組中匹配到的串同樣的字串。
(?#…)
注釋；里面的內(nèi)容會被忽略。
(?=…)
匹配 … 的內(nèi)容，但是并不消費(fèi)樣式的內(nèi)容。這個叫做 lookahead assertion。比如， Isaac (?=Asimov) 匹配 'Isaac ' 只有在后面是 'Asimov' 的時候。
(?!…)
匹配 … 不符合的情況。這個叫 negative lookahead assertion (前視取反)。比如說， Isaac (?!Asimov) 只有后面 不 是 'Asimov' 的時候才匹配 'Isaac ' 。
(?<=…)
匹配字符串的當(dāng)前位置，它的前面匹配 … 的內(nèi)容到當(dāng)前位置。這叫:dfn:positive lookbehind assertion (正向后視斷定)。 (?<=abc)def 會在 'abcdef' 中找到一個匹配，因?yàn)楹笠晻罂?個字符并檢查是否包含匹配的樣式。包含的匹配樣式必須是定長的，意思就是 abc 或 a|b 是允許的，但是 a* 和 a{3,4} 不可以。注意以 positive lookbehind assertions 開始的樣式，如 (?<=abc)def ，并不是從 a 開始搜索，而是從 d 往回看的。你可能更加愿意使用 search() 函數(shù)，而不是 match() 函數(shù)：
>>> import re
>>> m = re.search('(?<=abc)def', 'abcdef')
>>> m.group(0)
'def'
這個例子搜索一個跟隨在連字符后的單詞：
>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
在 3.5 版更改: 添加定長組合引用的支持。
(?
匹配當(dāng)前位置之前不是 … 的樣式。這個叫:dfn:negative lookbehind assertion (后視斷定取非)。類似正向后視斷定，包含的樣式匹配必須是定長的。由 negative lookbehind assertion 開始的樣式可以從字符串搜索開始的位置進(jìn)行匹配。
(?(id/name)yes-pattern|no-pattern)
如果給定的 id 或 name 存在，將會嘗試匹配 yes-pattern ，否則就嘗試匹配 no-pattern，no-pattern 可選，也可以被忽略。比如， (\.\w+)+)(?(1)>|$) 是一個email樣式匹配，將匹配 '' 或 'user@host.com' ，但不會匹配 '<user@host.com' ，也不會匹配 'user@host.com>'。
由 '\' 和一個字符組成的特殊序列在以下列出。 如果普通字符不是ASCII數(shù)位或者ASCII字母，那么正則樣式將匹配第二個字符。比如，\$ 匹配字符 '$'.
\number
匹配數(shù)字代表的組合。每個括號是一個組合，組合從1開始編號。比如 (.+) \1 匹配 'the the' 或者 '55 55', 但不會匹配 'thethe' (注意組合后面的空格)。這個特殊序列只能用于匹配前面99個組合。如果 number 的第一個數(shù)位是0， 或者 number 是三個八進(jìn)制數(shù)，它將不會被看作是一個組合，而是八進(jìn)制的數(shù)字值。在 '[' 和 ']' 字符集合內(nèi)，任何數(shù)字轉(zhuǎn)義都被看作是字符。
\A
只匹配字符串開始。
\b
匹配空字符串，但只在單詞開始或結(jié)尾的位置。一個單詞被定義為一個單詞字符的序列。注意，通常 \b 定義為 \w 和 \W 字符之間，或者 \w 和字符串開始/結(jié)尾的邊界， 意思就是 r'\bfoo\b' 匹配 'foo', 'foo.', '(foo)', 'bar foo baz' 但不匹配 'foobar' 或者 'foo3'。
默認(rèn)情況下，Unicode字母和數(shù)字是在Unicode樣式中使用的，但是可以用 ASCII 標(biāo)記來更改。如果 LOCALE 標(biāo)記被設(shè)置的話，詞的邊界是由當(dāng)前語言區(qū)域設(shè)置決定的，\b 表示退格字符，以便與Python字符串文本兼容。
\B
匹配空字符串，但 不 能在詞的開頭或者結(jié)尾。意思就是 r'py\B' 匹配 'python', 'py3', 'py2', 但不匹配 'py', 'py.', 或者 'py!'. \B 是 \b 的取非，所以Unicode樣式的詞語是由Unicode字母，數(shù)字或下劃線構(gòu)成的，雖然可以用 ASCII 標(biāo)志來改變。如果使用了 LOCALE 標(biāo)志，則詞的邊界由當(dāng)前語言區(qū)域設(shè)置。
\d
對于 Unicode (str) 樣式：
匹配任何Unicode十進(jìn)制數(shù)(就是在Unicode字符目錄[Nd]里的字符)。這包括了 [0-9] ，和很多其他的數(shù)字字符。如果設(shè)置了 ASCII 標(biāo)志，就只匹配 [0-9] 。
對于8位(bytes)樣式：
匹配任何十進(jìn)制數(shù)，就是 [0-9]。
\D
匹配任何非十進(jìn)制數(shù)字的字符。就是 \d 取非。 如果設(shè)置了 ASCII 標(biāo)志，就相當(dāng)于 [^0-9] 。
\s
對于 Unicode (str) 樣式：
匹配任何Unicode空白字符(包括 [ \t\n\r\f\v] ，還有很多其他字符，比如不同語言排版規(guī)則約定的不換行空格)。如果 ASCII 被設(shè)置，就只匹配 [ \t\n\r\f\v] 。
對于8位(bytes)樣式：
匹配ASCII中的空白字符，就是 [ \t\n\r\f\v] 。
\S
匹配任何非空白字符。就是 \s 取非。如果設(shè)置了 ASCII 標(biāo)志，就相當(dāng)于 [^ \t\n\r\f\v] 。
\w
對于 Unicode (str) 樣式：
匹配Unicode詞語的字符，包含了可以構(gòu)成詞語的絕大部分字符，也包括數(shù)字和下劃線。如果設(shè)置了 ASCII 標(biāo)志，就只匹配 [a-zA-Z0-9_] 。
對于8位(bytes)樣式：
匹配ASCII字符中的數(shù)字和字母和下劃線，就是 [a-zA-Z0-9_] 。如果設(shè)置了 LOCALE 標(biāo)記，就匹配當(dāng)前語言區(qū)域的數(shù)字和字母和下劃線。
\W
匹配任何非詞語字符。是 \w 取非。如果設(shè)置了 ASCII 標(biāo)記，就相當(dāng)于 [^a-zA-Z0-9_] 。如果設(shè)置了 LOCALE 標(biāo)志，就匹配當(dāng)前語言區(qū)域的 非 詞語字符。
\Z
只匹配字符串尾。
絕大部分Python的標(biāo)準(zhǔn)轉(zhuǎn)義字符也被正則表達(dá)式分析器支持。:
\a ? ? ?\b ? ? ?\f ? ? ?\n
\r ? ? ?\t ? ? ?\u ? ? ?\U
\v ? ? ?\x ? ? ?\\
(注意 \b 被用于表示詞語的邊界，它只在字符集合內(nèi)表示退格，比如 [\b] 。)
'\u' 和 '\U' 轉(zhuǎn)義序列只在 Unicode 樣式中支持。 在 bytes 算啊看會顯示錯誤。 未知的 ASCII 字符轉(zhuǎn)義序列保留在未來使用，會被當(dāng)作錯誤來處理。
八進(jìn)制轉(zhuǎn)義包含為一個有限形式。如果首位數(shù)字是 0， 或者有三個八進(jìn)制數(shù)位，那么就認(rèn)為它是八進(jìn)制轉(zhuǎn)義。其他的情況，就看作是組引用。對于字符串文本，八進(jìn)制轉(zhuǎn)義最多有三個數(shù)位長。
在 3.3 版更改: 增加了 '\u' 和 '\U' 轉(zhuǎn)義序列。
在 3.6 版更改: 由 '\' 和一個ASCII字符組成的未知轉(zhuǎn)義會被看成錯誤。
模塊內(nèi)容
模塊定義了幾個函數(shù)，常量，和一個例外。有些函數(shù)是編譯后的正則表達(dá)式方法的簡化版本(少了一些特性)。絕大部分重要的應(yīng)用，總是會先將正則表達(dá)式編譯，之后在進(jìn)行操作。
在 3.6 版更改: 標(biāo)志常量現(xiàn)在是 RegexFlag 類的實(shí)例，這個類是 enum.IntFlag 的子類。
re.compile(pattern, flags=0)
將正則表達(dá)式的樣式編譯為一個 正則表達(dá)式對象 (正則對象)，可以用于匹配，通過這個對象的方法 match(), search() 以及其他如下描述。
這個表達(dá)式的行為可以通過指定 標(biāo)記 的值來改變。值可以是以下任意變量，可以通過位的OR操作來結(jié)合( | 操作符)。
序列
prog = re.compile(pattern)
result = prog.match(string)
等價于
result = re.match(pattern, string)
如果需要多次使用這個正則表達(dá)式的話，使用 re.compile() 和保存這個正則對象以便復(fù)用，可以讓程序更加高效。
注解 通過 re.compile() 編譯后的樣式，和模塊級的函數(shù)會被緩存， 所以少數(shù)的正則表達(dá)式使用無需考慮編譯的問題。
re.A
re.ASCII
讓 \w, \W, \b, \B, \d, \D, \s 和 \S 只匹配ASCII，而不是Unicode。這只對Unicode樣式有效，會被byte樣式忽略。相當(dāng)于前面語法中的內(nèi)聯(lián)標(biāo)志 (?a) 。
注意，為了保持向后兼容， re.U 標(biāo)記依然存在(還有他的同義 re.UNICODE 和嵌入形式 (?u) ) ， 但是這些在 Python 3 是冗余的，因?yàn)槟J(rèn)字符串已經(jīng)是Unicode了(并且Unicode匹配不允許byte出現(xiàn))。
re.DEBUG
顯示編譯時的debug信息，沒有內(nèi)聯(lián)標(biāo)記。
re.I
re.IGNORECASE
進(jìn)行忽略大小寫匹配；表達(dá)式如 [A-Z] 也會匹配小寫字符。Unicode匹配(比如 ü 匹配 ü)同樣有用，除非設(shè)置了 re.ASCII 標(biāo)記來禁用非ASCII匹配。當(dāng)前語言區(qū)域不會改變這個標(biāo)記，除非設(shè)置了 re.LOCALE 標(biāo)記。這個相當(dāng)于內(nèi)聯(lián)標(biāo)記 (?i) 。
注意，當(dāng)設(shè)置了 IGNORECASE 標(biāo)記，搜索Unicode樣式 [a-z] 或 [A-Z] 的結(jié)合時，它將會匹配52個ASCII字符和4個額外的非ASCII字符： '?' (U+0130, 拉丁大寫的 I 帶個點(diǎn)在上面), '?' (U+0131, 拉丁小寫沒有點(diǎn)的 I ), '?' (U+017F, 拉丁小寫長 s) and 'K' (U+212A, 開爾文符號).如果使用 ASCII 標(biāo)記，就只匹配 'a' 到 'z' 和 'A' 到 'Z' 。
re.L
re.LOCALE
由當(dāng)前語言區(qū)域決定 \w, \W, \b, \B 和大小寫敏感匹配。這個標(biāo)記只能對byte樣式有效。這個標(biāo)記不推薦使用，因?yàn)檎Z言區(qū)域機(jī)制很不可靠，它一次只能處理一個 "習(xí)慣”，而且只對8位字節(jié)有效。Unicode匹配在Python 3 里默認(rèn)啟用，并可以處理不同語言。 這個對應(yīng)內(nèi)聯(lián)標(biāo)記 (?L) 。
在 3.6 版更改: re.LOCALE 只能用于byte樣式，而且不能和 re.ASCII 一起用。
在 3.7 版更改: 設(shè)置了 re.LOCALE 標(biāo)記的編譯正則對象不再在編譯時依賴語言區(qū)域設(shè)置。語言區(qū)域設(shè)置只在匹配的時候影響其結(jié)果。
re.M
re.MULTILINE
設(shè)置以后，樣式字符 '^' 匹配字符串的開始，和每一行的開始(換行符后面緊跟的符號)；樣式字符 '$' 匹配字符串尾，和每一行的結(jié)尾(換行符前面那個符號)。默認(rèn)情況下，’^’ 匹配字符串頭，'$' 匹配字符串尾。對應(yīng)內(nèi)聯(lián)標(biāo)記 (?m) 。
re.S
re.DOTALL
讓 '.' 特殊字符匹配任何字符，包括換行符；如果沒有這個標(biāo)記，'.' 就匹配 除了 換行符的其他任意字符。對應(yīng)內(nèi)聯(lián)標(biāo)記 (?s) 。
re.X
re.VERBOSE
這個標(biāo)記允許你編寫更具可讀性更友好的正則表達(dá)式。通過分段和添加注釋。空白符號會被忽略，除非在一個字符集合當(dāng)中或者由反斜杠轉(zhuǎn)義，或者在 *?, (?: or (?P 分組之內(nèi)。當(dāng)一個行內(nèi)有 # 不在字符集和轉(zhuǎn)義序列，那么它之后的所有字符都是注釋。
意思就是下面兩個正則表達(dá)式等價地匹配一個十進(jìn)制數(shù)字：
a = re.compile(r"""\d + ?# the integral part
\. ? ?# the decimal point
\d * ?# some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
對應(yīng)內(nèi)聯(lián)標(biāo)記 (?x) 。
re.search(pattern, string, flags=0)
掃描整個 字符串 找到匹配樣式的第一個位置，并返回一個相應(yīng)的 匹配對象。如果沒有匹配，就返回一個 None ； 注意這和找到一個零長度匹配是不同的。
re.match(pattern, string, flags=0)
如果 string 開始的0或者多個字符匹配到了正則表達(dá)式樣式，就返回一個相應(yīng)的 匹配對象 。 如果沒有匹配，就返回 None ；注意它跟零長度匹配是不同的。
注意即便是 MULTILINE 多行模式， re.match() 也只匹配字符串的開始位置，而不匹配每行開始。
如果你想定位 string 的任何位置，使用 search() 來替代(也可參考 search() vs. match() )
re.fullmatch(pattern, string, flags=0)
如果整個 string 匹配到正則表達(dá)式樣式，就返回一個相應(yīng)的 匹配對象 。 否則就返回一個 None ；注意這跟零長度匹配是不同的。
3.4 新版功能.
re.split(pattern, string, maxsplit=0, flags=0)
用 pattern 分開 string 。 如果在 pattern 中捕獲到括號，那么所有的組里的文字也會包含在列表里。如果 maxsplit 非零， 最多進(jìn)行 maxsplit 次分隔， 剩下的字符全部返回到列表的最后一個元素。
>>>
>>> re.split(r'\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split(r'(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split(r'\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
如果分隔符里有捕獲組合，并且匹配到字符串的開始，那么結(jié)果將會以一個空字符串開始。對于結(jié)尾也是一樣
>>>
>>> re.split(r'(\W+)', '...words, words...')
['', '...', 'words', ', ', 'words', '...', '']
這樣的話，分隔組將會出現(xiàn)在結(jié)果列表中同樣的位置。
樣式的空匹配將分開字符串，但只在不相臨的狀況生效。
>>> re.split(r'\b', 'Words, words, words.')
['', 'Words', ', ', 'words', ', ', 'words', '.']
>>> re.split(r'\W*', '...words...')
['', '', 'w', 'o', 'r', 'd', 's', '', '']
>>> re.split(r'(\W*)', '...words...')
['', '...', '', '', 'w', '', 'o', '', 'r', '', 'd', '', 's', '...', '', '', '']
在 3.1 版更改: 增加了可選標(biāo)記參數(shù)。
在 3.7 版更改: 增加了空字符串的樣式分隔。
re.findall(pattern, string, flags=0)
對 string 返回一個不重復(fù)的 pattern 的匹配列表， string 從左到右進(jìn)行掃描，匹配按找到的順序返回。如果樣式里存在一到多個組，就返回一個組合列表；就是一個元組的列表(如果樣式里有超過一個組合的話)。空匹配也會包含在結(jié)果里。
在 3.7 版更改: 非空匹配現(xiàn)在可以在前一個空匹配之后出現(xiàn)了。
re.finditer(pattern, string, flags=0)
pattern 在 string 里所有的非重復(fù)匹配，返回為一個迭代器 iterator 保存了 匹配對象 。 string 從左到右掃描，匹配按順序排列。空匹配也包含在結(jié)果里。
在 3.7 版更改: 非空匹配現(xiàn)在可以在前一個空匹配之后出現(xiàn)了。
re.sub(pattern, repl, string, count=0, flags=0)
返回通過使用 repl 替換在 string 最左邊非重疊出現(xiàn)的 pattern 而獲得的字符串。 如果樣式?jīng)]有找到，則不加改變地返回 string。 repl 可以是字符串或函數(shù)；如為字符串，則其中任何反斜杠轉(zhuǎn)義序列都會被處理。 也就是說，\n 會被轉(zhuǎn)換為一個換行符，\r 會被轉(zhuǎn)換為一個回車附，依此類推。 未知的 ASCII 字符轉(zhuǎn)義序列保留在未來使用，會被當(dāng)作錯誤來處理。 其他未知轉(zhuǎn)義序列例如 \& 會保持原樣。 向后引用像是 \6 會用樣式中第 6 組所匹配到的子字符串來替換。 例如:
>>>
>>> re.sub(r'def\s+([a-zA-Z_][a-zA-Z_0-9]*)\s*\(\s*\):',
... ? ? ? ?r'static PyObject*\npy_\1(void)\n{',
... ? ? ? ?'def myfunc():')
'static PyObject*\npy_myfunc(void)\n{'
如果 repl 是一個函數(shù)，那它會對每個非重復(fù)的 pattern 的情況調(diào)用。這個函數(shù)只能有一個 匹配對象 參數(shù)，并返回一個替換后的字符串。比如
>>>
>>> def dashrepl(matchobj):
... ? ? if matchobj.group(0) == '-': return ' '
... ? ? else: return '-'
>>> re.sub('-{1,2}', dashrepl, 'pro----gram-files')
'pro--gram files'
>>> re.sub(r'\sAND\s', ' & ', 'Baked Beans And Spam', flags=re.IGNORECASE)
'Baked Beans & Spam'
樣式可以是一個字符串或者一個 樣式對象 。
可選參數(shù) count 是要替換的最大次數(shù)；count 必須是非負(fù)整數(shù)。如果忽略這個參數(shù)，或者設(shè)置為0，所有的匹配都會被替換。空匹配只在不相臨連續(xù)的情況被更替，所以 sub('x*', '-', 'abxd') 返回 '-a-b--d-' 。
在字符串類型的 repl 參數(shù)里，如上所述的轉(zhuǎn)義和向后引用中，\g<name> 會使用命名組合 name，(在 (?P<name>…) 語法中定義) \g<number> 會使用數(shù)字組；\g<2> 就是 \2，但它避免了二義性，如 \g<2>0。 \20 就會被解釋為組20，而不是組2后面跟隨一個字符 '0'。向后引用 \g<0> 把 pattern 作為一整個組進(jìn)行引用。
在 3.1 版更改: 增加了可選標(biāo)記參數(shù)。
在 3.5 版更改: 不匹配的組合替換為空字符串。
在 3.6 版更改: pattern 中的未知轉(zhuǎn)義(由 '\' 和一個 ASCII 字符組成)被視為錯誤。
在 3.7 版更改: repl 中的未知轉(zhuǎn)義(由 '\' 和一個 ASCII 字符組成)被視為錯誤。
在 3.7 版更改: 樣式中的空匹配相鄰接時會被替換。
re.subn(pattern, repl, string, count=0, flags=0)
行為與 sub() 相同，但是返回一個元組 (字符串, 替換次數(shù)).
在 3.1 版更改: 增加了可選標(biāo)記參數(shù)。
在 3.5 版更改: 不匹配的組合替換為空字符串。
re.escape(pattern)
轉(zhuǎn)義 pattern 中的特殊字符。如果你想對任意可能包含正則表達(dá)式元字符的文本字符串進(jìn)行匹配，它就是有用的。比如
>>>
>>> print(re.escape('python.exe'))
python\.exe
>>> legal_chars = string.ascii_lowercase + string.digits + "!#$%&'*+-.^_`|~:"
>>> print('[%s]+' % re.escape(legal_chars))
[abcdefghijklmnopqrstuvwxyz0123456789!\#\$%\&'\*\+\-\.\^_`\|\~:]+
>>> operators = ['+', '-', '*', '/', '**']
>>> print('|'.join(map(re.escape, sorted(operators, reverse=True))))
/|\-|\+|\*\*|\*
這個函數(shù)不能被用于 sub() 和 subn() 的替換字符串，只有反斜杠應(yīng)該被轉(zhuǎn)義。 例如:
>>>
>>> digits_re = r'\d+'
>>> sample = '/usr/sbin/sendmail - 0 errors, 12 warnings'
>>> print(re.sub(digits_re, digits_re.replace('\\', r'\\'), sample))
/usr/sbin/sendmail - \d+ errors, \d+ warnings
在 3.3 版更改: '_' 不再被轉(zhuǎn)義。
在 3.7 版更改: 只有在正則表達(dá)式中可以產(chǎn)生特殊含義的字符會被轉(zhuǎn)義。
re.purge()
清除正則表達(dá)式緩存。
exception re.error(msg, pattern=None, pos=None)
raise 一個例外。當(dāng)傳遞到函數(shù)的字符串不是一個有效正則表達(dá)式的時候(比如，包含一個不匹配的括號)或者其他錯誤在編譯時或匹配時產(chǎn)生。如果字符串不包含樣式匹配，是不會被視為錯誤的。錯誤實(shí)例有以下附加屬性：
msg
未格式化的錯誤消息。
pattern
正則表達(dá)式樣式。
pos
編譯失敗的 pattern 的位置索引(可以是 None )。
lineno
對應(yīng) pos (可以是 None) 的行號。
colno
對應(yīng) pos (可以是 None) 的列號。
在 3.5 版更改: 添加了附加屬性。
正則表達(dá)式對象 (正則對象)
編譯后的正則表達(dá)式對象支持一下方法和屬性：
Pattern.search(string[, pos[, endpos]])
掃描整個 string 尋找第一個匹配的位置， 并返回一個相應(yīng)的 匹配對象。如果沒有匹配，就返回 None ；注意它和零長度匹配是不同的。
可選的第二個參數(shù) pos 給出了字符串中開始搜索的位置索引；默認(rèn)為 0，它不完全等價于字符串切片； '^' 樣式字符匹配字符串真正的開頭，和換行符后面的第一個字符，但不會匹配索引規(guī)定開始的位置。
可選參數(shù) endpos 限定了字符串搜索的結(jié)束；它假定字符串長度到 endpos ， 所以只有從 pos 到 endpos - 1 的字符會被匹配。如果 endpos 小于 pos，就不會有匹配產(chǎn)生；另外，如果 rx 是一個編譯后的正則對象， rx.search(string, 0, 50) 等價于 rx.search(string[:50], 0)。
>>>
>>> pattern = re.compile("d")
>>> pattern.search("dog") ? ? # Match at index 0
<re.Match object; span=(0, 1), match='d'>
>>> pattern.search("dog", 1) ?# No match; search doesn't include the "d"
Pattern.match(string[, pos[, endpos]])
如果 string 的 開始位置 能夠找到這個正則樣式的任意個匹配，就返回一個相應(yīng)的 匹配對象。如果不匹配，就返回 None ；注意它與零長度匹配是不同的。
可選參數(shù) pos 和 endpos 與 search() 含義相同。
>>>
>>> pattern = re.compile("o")
>>> pattern.match("dog") ? ? ?# No match as "o" is not at the start of "dog".
>>> pattern.match("dog", 1) ? # Match as "o" is the 2nd character of "dog".
<re.Match object; span=(1, 2), match='o'>
如果你想定位匹配在 string 中的位置，使用 search() 來替代(另參考 search() vs. match())。
Pattern.fullmatch(string[, pos[, endpos]])
如果整個 string 匹配這個正則表達(dá)式，就返回一個相應(yīng)的 匹配對象 。 否則就返回 None ； 注意跟零長度匹配是不同的。
可選參數(shù) pos 和 endpos 與 search() 含義相同。
>>>
>>> pattern = re.compile("o[gh]")
>>> pattern.fullmatch("dog") ? ? ?# No match as "o" is not at the start of "dog".
>>> pattern.fullmatch("ogre") ? ? # No match as not the full string matches.
>>> pattern.fullmatch("doggie", 1, 3) ? # Matches within given limits.
<re.Match object; span=(1, 3), match='og'>
3.4 新版功能.
Pattern.split(string, maxsplit=0)
等價于 split() 函數(shù)，使用了編譯后的樣式。
Pattern.findall(string[, pos[, endpos]])
類似函數(shù) findall() ， 使用了編譯后樣式，但也可以接收可選參數(shù) pos 和 endpos ，限制搜索范圍，就像 search()。
Pattern.finditer(string[, pos[, endpos]])
類似函數(shù) finiter() ， 使用了編譯后樣式，但也可以接收可選參數(shù) pos 和 endpos ，限制搜索范圍，就像 search()。
Pattern.sub(repl, string, count=0)
等價于 sub() 函數(shù)，使用了編譯后的樣式。
Pattern.subn(repl, string, count=0)
等價于 subn() 函數(shù)，使用了編譯后的樣式。
Pattern.flags
正則匹配標(biāo)記。這是可以傳遞給 compile() 的參數(shù)，任何 (?…) 內(nèi)聯(lián)標(biāo)記，隱性標(biāo)記比如 UNICODE 的結(jié)合。
Pattern.groups
捕獲組合的數(shù)量。
Pattern.groupindex
映射由 (?P<id>) 定義的命名符號組合和數(shù)字組合的字典。如果沒有符號組，那字典就是空的。
Pattern.pattern
編譯對象的原始樣式字符串。
在 3.7 版更改: 添加 copy.copy() 和 copy.deepcopy() 函數(shù)的支持。編譯后的正則表達(dá)式對象被認(rèn)為是原子性的。
匹配對象
匹配對象總是有一個布爾值 True。如果沒有匹配的話 match() 和 search() 返回 None 所以你可以簡單的用 if 語句來判斷是否匹配
match = re.search(pattern, string)
if match:
process(match)
匹配對象支持以下方法和屬性：
Match.expand(template)
對 template 進(jìn)行反斜杠轉(zhuǎn)義替換并且返回，就像 sub() 方法中一樣。轉(zhuǎn)義如同 \n 被轉(zhuǎn)換成合適的字符，數(shù)字引用(\1, \2)和命名組合(\g<1>, \g<name>) 替換為相應(yīng)組合的內(nèi)容。
在 3.5 版更改: 不匹配的組合替換為空字符串。
Match.group([group1, ...])
返回一個或者多個匹配的子組。如果只有一個參數(shù)，結(jié)果就是一個字符串，如果有多個參數(shù)，結(jié)果就是一個元組(每個參數(shù)對應(yīng)一個項(xiàng))，如果沒有參數(shù)，組1默認(rèn)到0(整個匹配都被返回)。 如果一個組N 參數(shù)值為 0，相應(yīng)的返回值就是整個匹配字符串；如果它是一個范圍 [1..99]，結(jié)果就是相應(yīng)的括號組字符串。如果一個組號是負(fù)數(shù)，或者大于樣式中定義的組數(shù)，一個 IndexError 索引錯誤就 raise。如果一個組包含在樣式的一部分，并被匹配多次，就返回最后一個匹配。:
>>>
>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
>>> m.group(0) ? ? ? # The entire match
'Isaac Newton'
>>> m.group(1) ? ? ? # The first parenthesized subgroup.
'Isaac'
>>> m.group(2) ? ? ? # The second parenthesized subgroup.
'Newton'
>>> m.group(1, 2) ? ?# Multiple arguments give us a tuple.
('Isaac', 'Newton')
如果正則表達(dá)式使用了 (?P<name>…) 語法， groupN 參數(shù)就也可能是命名組合的名字。如果一個字符串參數(shù)在樣式中未定義為組合名，一個 IndexError 就 raise。
一個相對復(fù)雜的例子
>>>
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
命名組合同樣可以通過索引值引用
>>>
>>> m.group(1)
'Malcolm'
>>> m.group(2)
'Reynolds'
如果一個組匹配成功多次，就只返回最后一個匹配
>>>
>>> m = re.match(r"(..)+", "a1b2c3") ?# Matches 3 times.
>>> m.group(1) ? ? ? ? ? ? ? ? ? ? ? ?# Returns only the last match.
'c3'
Match.__getitem__(g)
這個等價于 m.group(g)。這允許更方便的引用一個匹配
>>>
>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
>>> m[0] ? ? ? # The entire match
'Isaac Newton'
>>> m[1] ? ? ? # The first parenthesized subgroup.
'Isaac'
>>> m[2] ? ? ? # The second parenthesized subgroup.
'Newton'
3.6 新版功能.
Match.groups(default=None)
返回一個元組，包含所有匹配的子組，在樣式中出現(xiàn)的從1到任意多的組合。 default 參數(shù)用于不參與匹配的情況，默認(rèn)為 None。
例如
>>>
>>> m = re.match(r"(\d+)\.(\d+)", "24.1632")
>>> m.groups()
('24', '1632')
如果我們使小數(shù)點(diǎn)可選，那么不是所有的組都會參與到匹配當(dāng)中。這些組合默認(rèn)會返回一個 None ，除非指定了 default 參數(shù)。
>>>
>>> m = re.match(r"(\d+)\.?(\d+)?", "24")
>>> m.groups() ? ? ?# Second group defaults to None.
('24', None)
>>> m.groups('0') ? # Now, the second group defaults to '0'.
('24', '0')
Match.groupdict(default=None)
返回一個字典，包含了所有的 命名 子組。key就是組名。 default 參數(shù)用于不參與匹配的組合；默認(rèn)為 None。 例如
>>>
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.groupdict()
{'first_name': 'Malcolm', 'last_name': 'Reynolds'}
Match.start([group])
Match.end([group])
返回 group 匹配到的字串的開始和結(jié)束標(biāo)號。group 默認(rèn)為0(意思是整個匹配的子串)。如果 group 存在，但未產(chǎn)生匹配，就返回 -1 。對于一個匹配對象 m， 和一個未參與匹配的組 g ，組 g (等價于 m.group(g))產(chǎn)生的匹配是
m.string[m.start(g):m.end(g)]
注意 m.start(group) 將會等于 m.end(group) ，如果 group 匹配一個空字符串的話。比如，在 m = re.search('b(c?)', 'cba') 之后，m.start(0) 為 1, m.end(0) 為 2, m.start(1) 和 m.end(1) 都是 2, m.start(2) raise 一個 IndexError 例外。
這個例子會從email地址中移除掉 remove_this
>>>
>>> email = "tony@tiremove_thisger.net"
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
'tony@tiger.net'
Match.span([group])
對于一個匹配 m ， 返回一個二元組 (m.start(group), m.end(group)) 。 注意如果 group 沒有在這個匹配中，就返回 (-1, -1) 。group 默認(rèn)為0，就是整個匹配。
Match.pos
pos 的值，會傳遞給 search() 或 match() 的方法 a 正則對象 。這個是正則引擎開始在字符串搜索一個匹配的索引位置。
Match.endpos
endpos 的值，會傳遞給 search() 或 match() 的方法 a 正則對象 。這個是正則引擎停止在字符串搜索一個匹配的索引位置。
Match.lastindex
捕獲組的最后一個匹配的整數(shù)索引值，或者 None 如果沒有匹配產(chǎn)生的話。比如，對于字符串 'ab'，表達(dá)式 (a)b, ((a)(b)), 和 ((ab)) 將得到 lastindex == 1 ， 而 (a)(b) 會得到 lastindex == 2 。
Match.lastgroup
最后一個匹配的命名組名字，或者 None 如果沒有產(chǎn)生匹配的話。
Match.re
返回產(chǎn)生這個實(shí)例的 正則對象 ， 這個實(shí)例是由 正則對象的 match() 或 search() 方法產(chǎn)生的。
Match.string
傳遞到 match() 或 search() 的字符串。
在 3.7 版更改: 添加了對 copy.copy() 和 copy.deepcopy() 的支持。匹配對象被看作是原子性的。
正則表達(dá)式例子
檢查對子
在這個例子里，我們使用以下輔助函數(shù)來更好的顯示匹配對象：
def displaymatch(match):
if match is None:
return None
return '' % (match.group(), match.groups())
假設(shè)你在寫一個撲克程序，一個玩家的一手牌為五個字符的串，每個字符表示一張牌，"a" 就是 A, "k" K， "q" Q, "j" J, "t" 為 10, "2" 到 "9" 表示2 到 9。
要看給定的字符串是否有效，我們可以按照以下步驟
>>>
>>> valid = re.compile(r"^[a2-9tjqk]{5}$")
>>> displaymatch(valid.match("akt5q")) ?# Valid.
""
>>> displaymatch(valid.match("akt5e")) ?# Invalid.
>>> displaymatch(valid.match("akt")) ? ?# Invalid.
>>> displaymatch(valid.match("727ak")) ?# Valid.
""
最后一手牌，"727ak" ，包含了一個對子，或者兩張同樣數(shù)值的牌。要用正則表達(dá)式匹配它，應(yīng)該使用向后引用如下
>>>
>>> pair = re.compile(r".*(.).*\1")
>>> displaymatch(pair.match("717ak")) ? ? # Pair of 7s.
""
>>> displaymatch(pair.match("718ak")) ? ? # No pairs.
>>> displaymatch(pair.match("354aa")) ? ? # Pair of aces.
""
要找到對子包含的是哪一張牌，應(yīng)該按照下面的方式使用 group() 方法:
>>> pair.match("717ak").group(1)
'7'
# Error because re.match() returns None, which doesn't have a group() method:
>>> pair.match("718ak").group(1)
Traceback (most recent call last):
File "<pyshell#23>", line 1, in <module>
re.match(r".*(.).*\1", "718ak").group(1)
AttributeError: 'NoneType' object has no attribute 'group'
>>> pair.match("354aa").group(1)
'a'
模擬 scanf()
Python 目前沒有一個類似c函數(shù) scanf() 的替代品。正則表達(dá)式通常比 scanf() 格式字符串要更強(qiáng)大一些，但也帶來更多復(fù)雜性。下面的表格提供了 scanf() 格式符和正則表達(dá)式大致相同的映射。
scanf() 格式符
正則表達(dá)式
%c
.
%5c
.{5}
%d
[-+]?\d+
%e, %E, %f, %g
[-+]?(\d+(\.\d*)?|\.\d+)([eE][-+]?\d+)?
%i
[-+]?(0[xX][\dA-Fa-f]+|0[0-7]*|\d+)
%o
[-+]?[0-7]+
%s
\S+
%u
\d+
%x, %X
[-+]?(0[xX])?[\dA-Fa-f]+
從文件名和數(shù)字提取字符串
/usr/sbin/sendmail - 0 errors, 4 warnings
你可以使用 scanf() 格式化
%s - %d errors, %d warnings
等價的正則表達(dá)式是：
(\S+) - (\d+) errors, (\d+) warnings
search() vs. match()
Python 提供了兩種不同的操作：基于 re.match() 檢查字符串開頭，或者 re.search() 檢查字符串的任意位置(默認(rèn)Perl中的行為)。
例如
>>>
>>> re.match("c", "abcdef") ? ?# No match
>>> re.search("c", "abcdef") ? # Match
<re.Match object; span=(2, 3), match='c'>
在 search() 中，可以用 '^' 作為開始來限制匹配到字符串的首位
>>>
>>> re.match("c", "abcdef") ? ?# No match
>>> re.search("^c", "abcdef") ?# No match
>>> re.search("^a", "abcdef") ?# Match
<re.Match object; span=(0, 1), match='a'>
注意 MULTILINE 多行模式中函數(shù) match() 只匹配字符串的開始，但使用 search() 和以 '^' 開始的正則表達(dá)式會匹配每行的開始
>>>
>>> re.match('X', 'A\nB\nX', re.MULTILINE) ?# No match
>>> re.search('^X', 'A\nB\nX', re.MULTILINE) ?# Match
<re.Match object; span=(4, 5), match='X'>
建立一個電話本
split() 將字符串用參數(shù)傳遞的樣式分隔開。這個方法對于轉(zhuǎn)換文本數(shù)據(jù)到易讀而且容易修改的數(shù)據(jù)結(jié)構(gòu)，是很有用的，如下面的例子證明。
首先，這里是輸入。通常是一個文件，這里我們用三引號字符串語法
>>>
>>> text = """Ross McFluff: 834.345.1254 155 Elm Street
...
... Ronald Heathmore: 892.345.3428 436 Finley Avenue
... Frank Burger: 925.541.7625 662 South Dogwood Way
...
...
... Heather Albrecht: 548.326.4584 919 Park Place"""
條目用一個或者多個換行符分開。現(xiàn)在我們將字符串轉(zhuǎn)換為一個列表，每個非空行都有一個條目:
>>> entries = re.split("\n+", text)
>>> entries
['Ross McFluff: 834.345.1254 155 Elm Street',
'Ronald Heathmore: 892.345.3428 436 Finley Avenue',
'Frank Burger: 925.541.7625 662 South Dogwood Way',
'Heather Albrecht: 548.326.4584 919 Park Place']
最終，將每個條目分割為一個由名字、姓氏、電話號碼和地址組成的列表。我們?yōu)?split() 使用了 maxsplit 形參，因?yàn)榈刂分邪斜晃覀冏鳛榉指钅Ｊ降目崭穹?
>>> [re.split(":? ", entry, 3) for entry in entries][['Ross', 'McFluff', '834.345.1254', '155 Elm Street'],['Ronald', 'Heathmore', '892.345.3428', '436 Finley Avenue'],['Frank', 'Burger', '925.541.7625', '662 South Dogwood Way'],['Heather', 'Albrecht', '548.326.4584', '919 Park Place']]:? 樣式匹配姓后面的冒號，因此它不出現(xiàn)在結(jié)果列表中。如果 maxsplit 設(shè)置為 4 ，我們還可以從地址中獲取到房間號:
>>> [re.split(":? ", entry, 4) for entry in entries][['Ross', 'McFluff', '834.345.1254', '155', 'Elm Street'],['Ronald', 'Heathmore', '892.345.3428', '436', 'Finley Avenue'],['Frank', 'Burger', '925.541.7625', '662', 'South Dogwood Way'],['Heather', 'Albrecht', '548.326.4584', '919', 'Park Place']]文字整理
sub() 替換字符串中出現(xiàn)的樣式的每一個實(shí)例。這個例子證明了使用 sub() 來整理文字，或者隨機(jī)化每個字符的位置，除了首位和末尾字符
>>>>>> def repl(m):... inner_word = list(m.group(2))... random.shuffle(inner_word)... return m.group(1) + "".join(inner_word) + m.group(3)>>> text = "Professor Abdolmalek, please report your absences promptly.">>> re.sub(r"(\w)(\w+)(\w)", repl, text)'Poefsrosr Aealmlobdk, pslaee reorpt your abnseces plmrptoy.'>>> re.sub(r"(\w)(\w+)(\w)", repl, text)'Pofsroser Aodlambelk, plasee reoprt yuor asnebces potlmrpy.'找到所有副詞
findall() 匹配樣式 所有 的出現(xiàn)，不僅是像 search() 中的第一個匹配。比如，如果一個作者希望找到文字中的所有副詞，他可能會按照以下方法用 findall()
>>>>>> text = "He was carefully disguised but captured quickly by police.">>> re.findall(r"\w+ly", text)['carefully', 'quickly']找到所有副詞和位置
如果需要匹配樣式的更多信息， finditer() 可以起到作用，它提供了 匹配對象 作為返回值，而不是字符串。繼續(xù)上面的例子，如果一個作者希望找到所有副詞和它的位置，可以按照下面方法使用 finditer()
>>>>>> text = "He was carefully disguised but captured quickly by police.">>> for m in re.finditer(r"\w+ly", text):... print('%02d-%02d: %s' % (m.start(), m.end(), m.group(0)))07-16: carefully40-47: quickly原始字符記法
原始字符串記法 (r"text") 保持正則表達(dá)式正常。否則，每個正則式里的反斜杠('\') 都必須前綴一個反斜杠來轉(zhuǎn)義。比如，下面兩行代碼功能就是完全一致的
>>>
>>> re.match(r"\W(.)\1\W", " ff ")
<re.Match object; span=(0, 4), match=' ff '>
>>> re.match("\\W(.)\\1\\W", " ff ")
<re.Match object; span=(0, 4), match=' ff '>
當(dāng)需要匹配一個字符反斜杠，它必須在正則表達(dá)式中轉(zhuǎn)義。在原始字符串記法，就是 r"\\"。否則就必須用 "\\\\"，來表示同樣的意思
>>>
>>> re.match(r"\\", r"\\")
<re.Match object; span=(0, 1), match='\\'>
>>> re.match("\\\\", r"\\")
<re.Match object; span=(0, 1), match='\\'>
寫一個詞法分析器
一個 詞法器或詞法分析器 分析字符串，并分類成目錄組。 這是寫一個編譯器或解釋器的第一步。
文字目錄是由正則表達(dá)式指定的。這個技術(shù)是通過將這些樣式合并為一個主正則式，并且循環(huán)匹配來實(shí)現(xiàn)的
import collectionsimport reToken = collections.namedtuple('Token', ['type', 'value', 'line', 'column'])def tokenize(code):keywords = {'IF', 'THEN', 'ENDIF', 'FOR', 'NEXT', 'GOSUB', 'RETURN'}token_specification = [('NUMBER', r'\d+(\.\d*)?'), # Integer or decimal number('ASSIGN', r':='), # Assignment operator('END', r';'), # Statement terminator('ID', r'[A-Za-z]+'), # Identifiers('OP', r'[+\-*/]'), # Arithmetic operators('NEWLINE', r'\n'), # Line endings('SKIP', r'[ \t]+'), # Skip over spaces and tabs('MISMATCH', r'.'), # Any other character]tok_regex = '|'.join('(?P%s)' % pair for pair in token_specification)line_num = 1line_start = 0for mo in re.finditer(tok_regex, code):kind = mo.lastgroupvalue = mo.group()column = mo.start() - line_startif kind == 'NUMBER':value = float(value) if '.' in value else int(value)elif kind == 'ID' and value in keywords:kind = valueelif kind == 'NEWLINE':line_start = mo.end()line_num += 1continueelif kind == 'SKIP':continueelif kind == 'MISMATCH':raise RuntimeError(f'{value!r} unexpected on line {line_num}')yield Token(kind, value, line_num, column)statements = '''IF quantity THENtotal := total + price * quantity;tax := price * 0.05;ENDIF;'''for token in tokenize(statements):print(token)這個詞法器產(chǎn)生以下輸出
Token(type='IF', value='IF', line=2, column=4)Token(type='ID', value='quantity', line=2, column=7)Token(type='THEN', value='THEN', line=2, column=16)Token(type='ID', value='total', line=3, column=8)Token(type='ASSIGN', value=':=', line=3, column=14)Token(type='ID', value='total', line=3, column=17)Token(type='OP', value='+', line=3, column=23)Token(type='ID', value='price', line=3, column=25)Token(type='OP', value='*', line=3, column=31)Token(type='ID', value='quantity', line=3, column=33)Token(type='END', value=';', line=3, column=41)Token(type='ID', value='tax', line=4, column=8)Token(type='ASSIGN', value=':=', line=4, column=12)Token(type='ID', value='price', line=4, column=15)Token(type='OP', value='*', line=4, column=21)Token(type='NUMBER', value=0.05, line=4, column=23)Token(type='END', value=';', line=4, column=27)Token(type='ENDIF', value='ENDIF', line=5, column=4)Token(type='END', value=';', line=5, column=9)關(guān)注一下吧，也許哪天的文章真的被你用到呢~
加我微信帶你入群
與50位技術(shù)專家面對面20年技術(shù)見證，附贈技術(shù)全景圖總結(jié)
以上是生活随笔為你收集整理的java 正则首位8或者9的8位数字_Python 正则表达式re最完整的操作教程的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： zabbix cpu核数 windows
- 下一篇： nacos 配置_SpringCloud