元字符（Meta Characters）是正則表達式中具有特殊意義的專用字符，Python中是用來指明前導字符（位于元字符前的字符）在目標對象中的出現模式。
元字符是正則表達式最核心和基本的概念
整套學習自學教程中應用的數據都是《三國志》、《真·三國無雙》系列游戲中的內容。
在正則表達式中，方括號 ( [] ) 中指定的一組字符組成一個字符類。
元字符序列匹配類中的任何單個字符。
s = 'Dynasty123Dynasty'# 3個任意連續字符匹配re.search('[0-9][0-9][0-9]', s)<_sre.SRE_Match object; span=(7, 10), match='123'>re.search('[0-9][0-9][0-9]', 'Dynasty456Dynasty')<_sre.SRE_Match object; span=(7, 10), match='456'>re.search('[0-9][0-9][0-9]', '234baz')<_sre.SRE_Match object; span=(0, 3), match='234'>re.search('[0-9][0-9][0-9]', 'qux678')<_sre.SRE_Match object; span=(3, 6), match='678'># 匹配不上的情況print(re.search('[0-9][0-9][0-9]', '12Dynasty34'))None通配符點 ( . ) 元字符匹配除換行符以外的任何字符。
s = 'Dynasty123Dynasty're.search('1.3', s)<_sre.SRE_Match object; span=(7, 10), match='123'>s = 'Dynasty13Dynasty'print(re.search('1.3', s))None
下面列表都是元字符的描述，對元字符進行分類描述方便記憶。 這個要是看不懂直接跳過看下面的例子。
字符 | 描述 |
\ | 將下一個字符標記為一個特殊字符、或一個原義字符、或一個 向后引用、獲得一個八進制轉義符。例如，'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'，但是能匹配 'Dynastyd' 中的兩個 o。 |
{n,} | n 是一個非負整數。至少匹配n 次。例如，'o{2,}' 不能匹配 'Bob' 中的 'o'，但能匹配 'Dynastyoood' 中的所有 o。'o{1,}' 等價于 'o+'。'o{0,}' 則等價于 'o*'。 |
{n,m} | m 和 n 均為非負整數，其中n <= m。最少匹配 n 而且最多匹配 m 次。例如，'o{1,3}' 將匹配 'Dynastyooood' 中的前三個 o。'o{0,1}' 等價于 'o?'。請注意在逗號和兩個數字之間不能有空格。 |
? | 當該字符緊跟在任何一個其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面時，匹配模式是非常貪婪的。非貪婪模式盡可能少的匹配所搜索的字符串，而默認的貪婪模式則盡可能多地匹配所搜索的字符串。例如，對于字符串 'oooo'，'o+?' 將匹配單個 'o'，而 'o+' 將匹配所有 'o'。 |
. | 匹配除換行符（\n、\r）之外的任何單個字符。要匹配包括 '\n' 在內的任何字符，請使用像'(. |
x|y | 匹配 x 或 y。例如，'z |
[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 匹配版權符號 (?)。 |
方括號( [] ) 字符集
指定要匹配的特定字符集。 字符類元字符序列將匹配該類中包含的任何單個字符。
# 元字符序列[nasty]匹配任何單個'n'、'a'、's'、't'或'y'字符re.search('Dy[nasty]', 'DynastyDynastyzz')<_sre.SRE_Match object; span=(0, 3), match='Dyn'>匹配和[a-z]之間的任何小寫字母字符。
re.search('[a-z]', 'DynastyDynasty')<_sre.SRE_Match object; span=(1, 2), match='y'>匹配和[0-9]之間任何數字字符。
re.search('[0-9][0-9]', 'Dynasty123Dynasty')<_sre.SRE_Match object; span=(7, 9), match='12'>[0-9a-fA-F]匹配任何十六進制數字字符。
re.search('[0-9a-fA-f]', '--- a0 ---')<_sre.SRE_Match object; span=(4, 5), match='a'>[^0-9]匹配任何不是數字的字符開頭的字符。
re.search('[^0-9]', '12345Dynasty')<_sre.SRE_Match object; span=(5, 6), match='D'>如果一個^字符出現在字符類中但不是第一個字符則無結果。
re.search('[#:^]', 'Dynasty^Dynasty:D#d')<_sre.SRE_Match object; span=(7, 8), match='^'>可以通過用連字符分隔字符來指定字符類中的字符范圍，可以將其作為第一個或最后一個字符放置，或者使用反斜杠 ( \ ) 對其進行轉義。
# 直接查找符號re.search('[-abc]', '123-456')<_sre.SRE_Match object; span=(3, 4), match='-'>re.search('[abc-]', '123-456')<_sre.SRE_Match object; span=(3, 4), match='-'>re.search('[ab\-c]', '123-456')<_sre.SRE_Match object; span=(3, 4), match='-'># 查找轉義符號re.search('[]]', 'Dynasty[1]')<_sre.SRE_Match object; span=(9, 10), match=']'>re.search('[ab\]cd]', 'Dynasty[1]')<_sre.SRE_Match object; span=(3, 4), match='a'># [ ] 內的元字符失去意義轉義成字符處理re.search('[)*+|]', '123*456')<_sre.SRE_Match object; span=(3, 4), match='*'>re.search('[)*+|]', '123+456')<_sre.SRE_Match object; span=(3, 4), match='+'>點 ( . ) 通配符
匹配除換行符以外的任何單個字符。
re.search('Dynasty.Dynasty', 'DynastyxDynasty')<_sre.SRE_Match object; span=(0, 15), match='DynastyxDynasty'>print(re.search('Dynasty.Dynasty', 'DynastyDynasty'))Noneprint(re.search('Dynasty.Dynasty', 'Dynasty\nDynasty'))Noneprint(re.search('Dynasty.Dynasty', 'DynastysDynasty'))<_sre.SRE_Match object; span=(0, 15), match='DynastysDynasty'>\w 和 \W 單詞字符匹配
\w匹配任何字母數字字符，單詞字符是大寫和小寫字母、數字和下劃線 ( _) 字符。
\w 等于 [a-zA-Z0-9_] 。
re.search('\w', '#(.a$@&')<_sre.SRE_Match object; span=(3, 4), match='a'>re.search('[a-zA-Z0-9_]', '#(.a$@&')<_sre.SRE_Match object; span=(3, 4), match='a'>\W是相反的。它匹配任何非單詞字符。
\W 等于 [^a-zA-Z0-9_] 。
re.search('\W', 'a_1*3Qb')<_sre.SRE_Match object; span=(3, 4), match='*'>re.search('[^a-zA-Z0-9_]', 'a_1*3Qb')<_sre.SRE_Match object; span=(3, 4), match='*'>\d 和 \D 字符十進制數字匹配
\d匹配任何十進制數字字符，等價于[0-9]。
re.search('\d', 'abc4def')<_sre.SRE_Match object; span=(3, 4), match='4'>\D匹配任何不是十進制數字的字符，等價于[^0-9]。
re.search('\D', '234Q678')<_sre.SRE_Match object; span=(3, 4), match='Q'>\s 和 \S 字符空格匹配
\s匹配任何空白字符，同時也匹配換行符。
re.search('\s', 'Dynasty\nDynasty')<_sre.SRE_Match object; span=(3, 4), match='\n'>\S匹配任何不是空格的字符。
re.search('\S', ' \n Dynasty \n ')<_sre.SRE_Match object; span=(4, 5), match='D'>混合使用 \w, \W, \d, \D, \s, 和\S
字符類序列\w, \W, \d, \D, \s, 和\S也可以出現在方括號字符類中。
# [\d\w\s]匹配任何數字、單詞或空白字符re.search('[\d\w\s]', '---3---')<_sre.SRE_Match object; span=(3, 4), match='3'>re.search('[\d\w\s]', '---a---') <_sre.SRE_Match object; span=(3, 4), match='a'>re.search('[\d\w\s]', '--- ---')<_sre.SRE_Match object; span=(3, 4), match=' '># 由于\w包含\d，相同的字符類也可以表示為略短[\w\s]re.search('[\w\s]', '---a---')<_sre.SRE_Match object; span=(3, 4), match='a'>re.search('[\w\s]', '--- ---')<_sre.SRE_Match object; span=(3, 4), match=' '>反斜杠 ( \ ) 轉義元字符
反斜杠會刪除元字符的特殊含義。
re.search('.', 'Dynasty.Dynasty')<_sre.SRE_Match object; span=(0, 1), match='D'>re.search('\.', 'Dynasty.Dynasty') # 非通配符<_sre.SRE_Match object; span=(7, 8), match='.'>re.search(r'\\', 'Dynasty\Dynasty')<_sre.SRE_Match object; span=(7, 8), match='\\'>不匹配搜索字符串中的任何實際字符，并且在解析期間它們不使用任何搜索字符串。指示搜索字符串中必須發生匹配的特定位置。
^ 和 \A 字符串的開頭匹配項
re.search('^Dynasty', 'DynastyDynasty')<_sre.SRE_Match object; span=(0, 7), match='Dynasty'>re.search('\ADynasty', 'DynastyDynasty')<_sre.SRE_Match object; span=(0, 7), match='Dynasty'>$ 和\Z 字符串的結尾匹配項
re.search('Dynasty$', 'DynastyDynasty')<_sre.SRE_Match object; span=(7, 14), match='Dynasty'>print(re.search('Dynasty$', 'DynastyDynasty'))<_sre.SRE_Match object; span=(7, 14), match='Dynasty'>re.search('Dynasty\Z', 'DynastyDynasty')<_sre.SRE_Match object; span=(7, 14), match='Dynasty'>print(re.search('Dynasty\Z', 'DynastyDynasty'))<_sre.SRE_Match object; span=(7, 14), match='Dynasty'># 特殊$也在搜索字符串末尾的單個換行符之前匹配re.search('Dynasty$', 'DynastyDynasty\n')<_sre.SRE_Match object; span=(7, 14), match='Dynasty'>\b 和 \B 單詞匹配
\b 必須在單詞的開頭或結尾。
# 單詞開頭re.search(r'\bDynasty', 'Dynasty Dynasty')<_sre.SRE_Match object; span=(0, 7), match='Dynasty'>re.search(r'\bDynasty', 'Dynasty.Dynasty')<_sre.SRE_Match object; span=(0, 7), match='Dynasty'>print(re.search(r'\bDynasty', 'DynastyDynasty'))<_sre.SRE_Match object; span=(0, 7), match='Dynasty'># 單詞結尾re.search(r'Dynasty\b', 'Dynasty Dynasty')<_sre.SRE_Match object; span=(0, 7), match='Dynasty'>re.search(r'Dynasty\b', 'Dynasty.Dynasty')<_sre.SRE_Match object; span=(0, 7), match='Dynasty'>print(re.search(r'Dynasty\b', 'DynastyDynasty'))<_sre.SRE_Match object; span=(7, 14), match='Dynasty'># 單詞居中re.search(r'\bDynasty\b', 'Dynasty Dynasty ba')<_sre.SRE_Match object; span=(0, 7), match='Dynasty'>re.search(r'\bDynasty\b', 'Dynasty(Dynasty)ba')<_sre.SRE_Match object; span=(0, 7), match='Dynasty'>print(re.search(r'\bDynasty\b', 'DynastyDynastyba'))None\B 不能在單詞的開頭或結尾。
print(re.search(r'\BDynasty\B', 'Dynasty'))Noneprint(re.search(r'\BDynasty\B', '.Dynasty.'))Nonere.search(r'\BDynasty\B', 'DynastyDynastyba')<_sre.SRE_Match object; span=(7, 14), match='Dynasty'>該部分必須出現多少次才能使匹配成功。
* 匹配前面的子表達式零次或多次
re.search('Dynasty-*Dynasty', 'DynastyDynasty') <_sre.SRE_Match object; span=(0, 14), match='DynastyDynasty'>re.search('Dynasty-*Dynasty', 'Dynasty-Dynasty') <_sre.SRE_Match object; span=(0, 15), match='Dynasty-Dynasty'>re.search('Dynasty-*Dynasty', 'Dynasty--Dynasty') <_sre.SRE_Match object; span=(0, 16), match='Dynasty--Dynasty'>匹配2個字符中全部的內容。
re.search('Dynasty.*Dynasty', '# Dynasty jklasajk#*(@ Dynasty #')<_sre.SRE_Match object; span=(2, 30), match='Dynasty jklasajk#*(@ Dynasty'>+ 匹配前面的子表達式一次或多次
print(re.search('Dynasty-+Dynasty', 'DynastyDynasty')) Nonere.search('Dynasty-+Dynasty', 'Dynasty-Dynasty') <_sre.SRE_Match object; span=(0, 15), match='Dynasty-Dynasty'>re.search('Dynasty-+Dynasty', 'Dynasty--Dynasty') <_sre.SRE_Match object; span=(0, 16), match='Dynasty--Dynasty'>? 匹配前面的子表達式零次或一次
re.search('Dynasty-?Dynasty', 'DynastyDynasty') <_sre.SRE_Match object; span=(0, 14), match='DynastyDynasty'>re.search('Dynasty-?Dynasty', 'Dynasty-Dynasty') <_sre.SRE_Match object; span=(0, 15), match='Dynasty-Dynasty'>print(re.search('Dynasty-?Dynasty', 'Dynasty--Dynasty')) None.*?、+?、?? 最小長度匹配
+ 和 +? 代替了 * 和 *?，加問號則表示為最小長度匹配的懶惰模式。
# .*全匹配貪婪模式re.search('<.*>', '%<Dynasty> <Dynasty> <zs>%')<_sre.SRE_Match object; span=(1, 25), match='<Dynasty> <Dynasty> <sz>'># *? 前一個字符0次或無限次擴展，最小匹配re.search('<.*?>', '%<Dynasty> <Dynasty> <sz>%')<_sre.SRE_Match object; span=(1, 10), match='<Dynasty>'># .+ 前一個字符1次或無限次擴展，最小匹配re.search('<.+>', '%<Dynasty> <Dynasty> <zs>%')<_sre.SRE_Match object; span=(1, 25), match='<Dynasty> <Dynasty> <zs>'># .+? 前一個字符1次或無限次擴展，最小匹配re.search('<.+?>', '%<Dynasty> <Dynasty> <zs>%')<_sre.SRE_Match object; span=(1, 10), match='<Dynasty>'># ? 匹配懶惰模式re.search('ba?', 'baaaa')<_sre.SRE_Match object; span=(0, 2), match='ba'># ?? 前一個字符0次或1次擴展，最小匹配re.search('ba??', 'baaaa')<_sre.SRE_Match object; span=(0, 1), match='b'>{m} 完全匹配m次前面元字符的正則表達式。
print(re.search('x-{3}x', 'x--x')) Nonere.search('x-{3}x', 'x---x') <_sre.SRE_Match object; span=(0, 5), match='x---x'>print(re.search('x-{3}x', 'x----x')) None{m,n} 匹配前面正則表達式的任意數量的重復從m到n次。
for i in range(1, 6): s = f'x{'-' * i}x' print(f'{i} {s:10}', re.search('x-{2,4}x', s))1 x-x None2 x--x <_sre.SRE_Match object; span=(0, 4), match='x--x'>3 x---x <_sre.SRE_Match object; span=(0, 5), match='x---x'>4 x----x <_sre.SRE_Match object; span=(0, 6), match='x----x'>5 x-----x None正則表達式 | 匹配說明 | 相同語法 |
< regex > {,n} | 任何小于或等于的重復次數n | < regex > {0,n} |
< regex > {m,} | 任何大于或等于的重復次數m | ---- |
< regex > {,} | 任意次數的重復 | < regex > {0,} ， < regex > * |
re.search('x{}y', 'x{}y')<_sre.SRE_Match object; span=(0, 4), match='x{}y'>re.search('x{Dynasty}y', 'x{Dynasty}y')<_sre.SRE_Match object; span=(0, 11), match='x{Dynasty}y'>re.search('x{a:b}y', 'x{a:b}y')<_sre.SRE_Match object; span=(0, 7), match='x{a:b}y'>re.search('x{1,3,5}y', 'x{1,3,5}y')<_sre.SRE_Match object; span=(0, 9), match='x{1,3,5}y'>re.search('x{Dynasty,Dynasty}y', 'x{Dynasty,Dynasty}y')<_sre.SRE_Match object; span=(0, 19), match='x{Dynasty,Dynasty}y'>{m,n}? 只匹配一次。
非貪婪（懶惰）版本 {m,n}。
re.search('a{3,5}', 'aaaaaaaa')<_sre.SRE_Match object; span=(0, 5), match='aaaaa'>re.search('a{3,5}?', 'aaaaaaaa')<_sre.SRE_Match object; span=(0, 3), match='aaa'>分組構造將 Python 中的正則表達式分解為子表達式或組。
(<regex>)，定義子表達式或組。 括號中的正則表達式僅匹配括號的內容。
re.search('(Dynasty)', 'Dynasty Dynasty ba')<_sre.SRE_Match object; span=(0, 7), match='Dynasty'>re.search('Dynasty', 'Dynasty Dynasty ba')<_sre.SRE_Match object; span=(0, 7), match='Dynasty'>將組視為一個單元
組后面的量詞元字符對組中指定的整個子表達式作為一個單元進行操作。
re.search('Dynasty+', 'Dynasty Dynasty zs')<_sre.SRE_Match object; span=(0, 7), match='Dynasty'>re.search('(Dynasty)+', 'Dynasty Dynasty zs')<_sre.SRE_Match object; span=(0, 7), match='Dynasty'>re.search('(Dynasty)+', 'Dynasty DynastyDynasty zs')<_sre.SRE_Match object; span=(0, 7), match='Dynasty'>正則表達式 | 解釋 | 匹配說明 | 例子 |
Dynasty+ | 元字符+僅適用于字符'r'。 | 'ba'隨后出現一次或多次'r' | Dynasty、Dynastyr、Dynastyrr等 |
(Dynasty)+ | 元字符+適用于整個字符串'Dynasty'。 | 出現一次或多次'Dynasty' | Dynasty、DynastyDynasty、DynastyDynastyDynasty |
捕獲組，m.groups()
返回一個元組，其中包含從正則表達式匹配中捕獲的所有組。
m = re.search('(\w+),(\w+),(\w+)', 'Dynasty,qw,ba')m<_sre.SRE_Match object; span=(0, 13), match='Dynasty,qw,ba'>m.groups()('Dynasty', 'qw', 'ba')捕獲組，m.group(<n>)
返回包含<n>捕獲的匹配項的字符串。
m = re.search('(\w+),(\w+),(\w+)', 'Dynasty,qw,ba')m.groups()('Dynasty', 'qw', 'ba')m.group(0)'Dynasty,qw,ba'm.group(1)'Dynasty'm.group(2)'qw'm.group(3)'ba'捕獲組，m.group(<n1>, <n2>, ...)
返回一個包含指定捕獲匹配序號的元組。
m = re.search('(\w+),(\w+),(\w+)', 'Dynasty,qw,ba')m.groups()('Dynasty', 'qw', 'ba')m.group(2, 3)('qw', 'ba')m.group(3, 2, 1)('ba', 'qw', 'Dynasty')\<num> 匹配連續相同字符
regex = r'(\w+),\1'm = re.search(regex, 'Dynasty,Dynasty')m<_sre.SRE_Match object; span=(0, 15), match='Dynasty,Dynasty'>m.group(1)'Dynasty'(?P<name><regex>) 創建捕獲組并命名。
m = re.search('(?P<w1>\w+),(?P<w2>\w+),(?P<w3>\w+)', 'Dynasty,qw,ba')m.groups()('Dynasty', 'qw', 'ba')m.group('w1')'Dynasty'm.group('w3')'ba'm.group('w1', 'w2', 'w3')('Dynasty', 'qw', 'ba')m.group(1, 2, 3)('Dynasty', 'qw', 'ba')(?P=<name>) 匹配先前捕獲名的內容。
m = re.search(r'(\w+),\1', 'Dynasty,Dynasty')m<_sre.SRE_Match object; span=(0, 15), match='Dynasty,Dynasty'>m.group(1)'Dynasty'm = re.search(r'(?P<word>\w+),(?P=word)', 'Dynasty,Dynasty')m<_sre.SRE_Match object; span=(0, 15), match='Dynasty,Dynasty'>m.group('word')'Dynasty'(?:<regex>) 創建一個非捕獲組。
m = re.search('(\w+),(?:\w+),(\w+)', 'Dynasty,qw,ba')m.groups()('Dynasty', 'ba')m.group(1)'Dynasty'm.group(2)'ba'根據解析器在搜索字符串中當前位置的后面（左側）或前面（右側）來確定 Python 中正則表達式匹配的成功或失敗。
(?=<lookahead_regex>) 積極前瞻斷言。
斷言正則表達式解析器當前位置之后的內容必須匹配。
# 前瞻斷言(?=[a-z])指定后面的'Dynasty'必須是小寫字母字符。re.search('Dynasty(?=[a-z])', 'Dynastydynasty')<_sre.SRE_Match object; span=(0, 7), match='Dynasty'># 前瞻失敗的例子，Dynasty的下一個字符是'1'print(re.search('Dynasty(?=[a-z])', 'Dynasty123'))None# 前瞻的獨特之處<lookahead_regex>在于不消耗搜索字符串中匹配的部分，并且它不是返回的匹配對象的一部分。re.search('Dynasty(?=[a-z])', 'Dynastydynasty')<_sre.SRE_Match object; span=(0, 7), match='Dynasty'># 舉例對比觀察，?=斷言的區別m = re.search('Dynasty(?=[a-z])(?P<ch>.)', 'Dynastydynasty')m.group('ch')'d'm = re.search('Dynasty([a-z])(?P<ch>.)', 'Dynastydynasty')m.group('ch')'y'(?!<lookahead_regex>) 否定的前瞻斷言。
# 例子和之前的前瞻積極斷言相反re.search('Dynasty(?=[a-z])', 'DynastyDynasty')<_sre.SRE_Match object; span=(0, 3), match='Dynasty'>print(re.search('Dynasty(?![a-z])', 'DynastyDynasty'))Noneprint(re.search('Dynasty(?=[a-z])', 'Dynasty123'))Nonere.search('Dynasty(?![a-z])', 'Dynasty123')<_sre.SRE_Match object; span=(0, 3), match='Dynasty'>(?<=<lookbehind_regex>) 積極的后向斷言。
斷言正則表達式解析器當前位置之前的內容匹配。
# 斷言指定'Dynasty'必須先于'Dynasty're.search('(?<=Dynasty)Dynasty', 'DynastyDynasty')<_sre.SRE_Match object; span=(7, 14), match='Dynasty'>print(re.search('(?<=qux)Dynasty', 'DynastyDynasty'))None(?<!--<lookbehind_regex-->) 否定的向后斷言。
# 例子和之前的向后積極斷言相反print(re.search('(?<!Dynasty)Dynasty', 'DynastyDynasty'))<_sre.SRE_Match object; span=(0, 7), match='Dynasty'>re.search('(?<!qw)Dynasty', 'DynastyDynasty')<_sre.SRE_Match object; span=(0, 7), match='Dynasty'>(?#...) 指定注釋。
正則表達式解析器忽略(?#...)序列中包含的任何內容
re.search('Dynasty(?#xxxx xxxx) *ba', 'Dynasty Dynasty ba qw')<_sre.SRE_Match object; span=(8, 18), match='Dynasty ba'>豎條或管道 ( | ) 指定要匹配的一組備選方案。
形式的表達式最多匹配一個指定的表達式：<regex1>|<regex2>|...|<regexn><regexi>
re.search('Dynasty|Dynasty|ba', 'Dynasty')<_sre.SRE_Match object; span=(0, 7), match='Dynasty'>re.search('Dynasty|Dynasty|ba', 'baz')<_sre.SRE_Match object; span=(0, 2), match='ba'>print(re.search('Dynasty|Dynasty|ba', 'qw'))None結合交替、分組和任何其他元字符來實現需要的任何復雜程度。
# (Dynasty|Dynasty|ba)+表示一個或多個字符串re.search('(Dynasty|Dynasty|ba)+', 'DynastyDynastyDynasty')<_sre.SRE_Match object; span=(0, 21), match='DynastyDynastyDynasty'>re.search('(Dynasty|Dynasty|ba)+', 'bazbazbazbaz')<_sre.SRE_Match object; span=(0, 2), match='ba'>re.search('(Dynasty|Dynasty|ba)+', 'DynastybazDynasty')<_sre.SRE_Match object; span=(0, 9), match='Dynastyba'>