一、簡介
1.1、相關鏈接
官方文檔：
Python2：https://docs.python.org/2/library/re.html
Python3：https://docs.python.org/3/library/re.html
HOWTO：
Python2：https://docs.python.org/2/howto/regex.html
Python3：https://docs.python.org/3/howto/regex.html
二、函數詳解
2.1、正則匹配的基本事項
- 函數中使用參數標識：
| 參數 |
描述 |
| pattern |
匹配的正則表達式 |
| string |
要匹配的字符串。 |
| flags |
標志位，用於控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等等。 |
- 函數中flags取值：
| Flag |
Meaning |
| DOTALL, S |
Make . match any character, including newlines 使 . 匹配包括換行在內的所有字符 |
| IGNORECASE, I |
Do case-insensitive matches 使匹配對大小寫不敏感 |
| LOCALE, L |
Do a locale-aware match 做本地化識別（locale-aware）匹配 |
| MULTILINE, M |
Multi-line matching, affecting ^ and $ 多行匹配，影響 ^ 和 $ |
| VERBOSE, X |
Enable verbose REs, which can be organized more cleanly and understandably. 該標志通過給予你更靈活的格式以便你將正則表達式寫得更易於理解。 |
| UNICODE, U |
Makes several escapes like \w, \b, \s and \d dependent on the Unicode character database. 根據Unicode字符集解析字符。這個標志影響 \w, \W, \b, \B. |
- 正則表達式的通配符表示含義：
模式字符串使用特殊的語法來表示一個正則表達式：
字母和數字表示他們自身。一個正則表達式模式中的字母和數字匹配同樣的字符串。
多數字母和數字前加一個反斜杠時會擁有不同的含義。
標點符號只有被轉義時才匹配自身，否則它們表示特殊的含義。
反斜杠本身需要使用反斜杠轉義。
由於正則表達式通常都包含反斜杠，所以你最好使用原始字符串來表示它們。模式元素(如 r'\t'，等價於 '\\t')匹配相應的特殊字符。
下表列出了正則表達式模式語法中的特殊元素。如果你使用模式的同時提供了可選的標志參數，某些模式元素的含義會改變。
| 模式 |
描述 |
| ^ |
匹配字符串的開頭 |
| $ |
匹配字符串的末尾。 |
| . |
匹配除了換行符(\n)的任意字符，當re.DOTALL標記被指定時，則可以匹配包括換行符的任意字符。 |
| [...] |
用來表示一組字符,單獨列出：[amk] 匹配 'a'，'m'或'k' |
| [^...] |
不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。 |
| re* |
匹配0個或多個的表達式。 |
| re+ |
匹配1個或多個的表達式。 |
| re? |
匹配0個或1個由前面的正則表達式定義的片段，非貪婪方式 |
| re{ n} |
|
| re{ n,} |
精確匹配n個前面表達式。 |
| re{ n, m} |
匹配 n 到 m 次由前面的正則表達式定義的片段，貪婪方式 |
| a| b |
匹配a或b |
| (re) |
G匹配括號內的表達式，也表示一個組 |
| (?imx) |
正則表達式包含三種可選標志：i, m, 或 x 。只影響括號中的區域。 |
| (?-imx) |
正則表達式關閉 i, m, 或 x 可選標志。只影響括號中的區域。 |
| (?: re) |
類似 (...), 但是不表示一個組 |
| (?imx: re) |
在括號中使用i, m, 或 x 可選標志 |
| (?-imx: re) |
在括號中不使用i, m, 或 x 可選標志 |
| (?#...) |
注釋. |
| (?= re) |
前向肯定界定符。如果所含正則表達式，以 ... 表示，在當前位置成功匹配時成功，否則失敗。但一旦所含表達式已經嘗試，匹配引擎根本沒有提高；模式的剩余部分還要嘗試界定符的右邊。 |
| (?! re) |
前向否定界定符。與肯定界定符相反；當所含表達式不能在字符串當前位置匹配時成功 |
| (?> re) |
匹配的獨立模式，省去回溯。 |
| \w |
匹配字母數字及下划線，等價於'[A-Za-z0-9_]'。 |
| \W |
匹配非字母數字及下划線，等價於 '[^A-Za-z0-9_]'。 |
| \s |
匹配任意空白字符，等價於 [\t\n\r\f]. |
| \S |
匹配任意非空字符，等價於 [^ \f\n\r\t\v]。 |
| \d |
匹配任意數字，等價於 [0-9]. |
| \D |
匹配任意非數字，等價於 [^0-9]。 |
| \A |
匹配字符串開始 |
| \Z |
匹配字符串結束，如果是存在換行，只匹配到換行前的結束字符串。c |
| \z |
匹配字符串結束 |
| \G |
匹配最后匹配完成的位置。 |
| \b |
匹配一個單詞邊界，也就是指單詞和空格間的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。 |
| \B |
匹配非單詞邊界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。 |
| \n, \t, 等. |
匹配一個換行符。匹配一個制表符。等 |
| \1...\9 |
匹配第n個分組的內容。 |
| \10 |
匹配第n個分組的內容，如果它經匹配。否則指的是八進制字符碼的表達式。 |
2.2、常用函數
以下是re模塊常用的七個函數：
| 函數名 |
含義 |
實例 |
| re.compile() |
將正則表達式模式編譯成一個正則表達式對象，它可以用於匹配使用它的match ()和search ()方法，如下所述。 可以通過指定flags值修改表達式的行為。值可以是任何以下變量，使用組合 OR （ |運算符）。 但使用re.compile()和保存所產生的正則表達式對象重用效率更高時該表達式會在單個程序中多次使用。 |
語法：compile(pattern, flags=0) >>> s = '[a-z]+\d*' >>> a = re.compile(s) >>> a <_sre.SRE_Pattern object at 0x0000000003308738> >>> type(a) <type '_sre.SRE_Pattern'> >>> b = a.match('a123') >>> b.group() 'a123' 等價於： >>> b = re.match('[a-z]+\d*', 'a123') >>> b.group() 'a123' |
| re.escape() |
返回的字符串與所有非字母數字帶有反斜杠；這是有用的如果你想匹配一個任意的文本字符串，在它可能包含正則表達式元字符 簡單理解：把字符串按照可能會是正則表達式來理解，這樣就需要把特殊字符都轉義。這樣才能方便匹配時精確匹配每個字符。 字符'[a-z]'這個字符串可以看作是正則表達式的模式，這樣就不能作為被匹配的字符串。如果想把這個字符串作為被匹配的模式就需要轉義這些特殊字符。print(re.escape('[a-z]')) \[a\-z\] |
語法：escape(pattern) >>> s = 'abc.|123' >>> print s abc.|123 >>> print(re.escape(s)) abc\.\|123 |
| re.findall() |
作為一個字符串列表，在字符串中，返回所有非重疊匹配的模式。該字符串是從左到右掃描的，匹配按照發現的順序返回。如果一個或多個組是本模式中，返回一個列表的群體 ；如果該模式具有多個組，這將是元組的列表。空匹配包含在結果中，除非他們接觸到另一場匹配的開頭。 返回一個匹配的所有內容的列表。如果沒有匹配內容則返回空列表。 在 1.5.2 版本新。 2.4 版本中的更改：添加可選的標志參數。 |
語法：findall(pattern, string, flags=0) >>> a = 'abc,123.abc.123' >>> s = '[a-z]+' >>> r = re.findall(s,a) >>> r ['abc', 'abc'] |
| re.match() |
如果在字符串的開頭的零個或更多字符匹配這個正則表達式，將返回相應的作法實例。返回沒有如果，則該字符串與模式不匹配請注意這是不同於零長度匹配。 簡單理解：就是從字符串的開始做正則匹配。能匹配到的最大位置返回。返回的對象用group/groups方法讀取。可以不匹配到字符串的末尾。但是字符串的開始必須匹配，否則返回空字符串。 |
語法：match(pattern, string, flags=0) >>> s = '[a-z]*' >>> a = 'test123' >>> b = re.match(s,a) >>> b.group() 'test' >>> a = '123abc' >>> b = re.match(s,a) >>> b.group() ''
|
| re.search() |
掃描字符串尋找第一個匹配位置，在此正則表達式產生的匹配，並返回相應的MatchObject實例。如果沒有字符串中的位置匹配模式返回空 。 可選的第二個參數pos給索引在字符串中搜索在哪里開始；它將默認為0。這並不完全等於切片的字符串 ； ' ^'模式字符匹配在真正開始的字符串和位置剛換行，但不是一定是在開始搜索的索引。
可選參數endpos限制了多遠的字符串將被搜索 ；它將，如果字符串是endpos個字符長，因此，只有從pos到字符endpos - 1將搜索匹配項。如果endpos小於pos，沒有比賽會發現，否則，如果rx是已編譯的正則表達式對象， rx.search （字符串， 0， 50)相當於rx.search （字符串 [： 50]， 0)。 注意：如果查找字符時用*則會默認匹配0個對應的字符。這樣就會返回空字符串。 |
語法：search(pattern, string, flags=0) >>> s = '\d*' >>> a = 'abc123,31' >>> s = re.search(s,a) >>> s.group() '' >>> s.span() (0, 0) >>> s = '\d+' >>> s = re.search(s,a) >>> s.span() (3, 6) >>> s.group() '123' |
| re.split() |
將字符串拆分的模式的匹配項。如果在模式中使用捕獲括號，則然后也作為結果列表的一部分返回的文本模式中的所有組。如果maxsplit不為零，頂多maxsplit分裂發生，並且該字符串的其余部分將作為列表的最后一個元素返回。（不兼容性說明： 在原始的 Python 1.5 版本中， maxsplit被忽略。這已被固定在以后的版本。） |
語法：split(pattern, string, maxsplit=0, flags=0) >>> 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"""
>>> 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'] >>> [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']]
>>> [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']]
|
| re.sub() |
Return the string obtained by replacing the leftmost non-overlapping occurrences of pattern in string by the replacement repl. 如果pattern沒有被找到， string不變。repl 可以是一個字符串或一個函數；如果是一個字符串, 任何反斜杠轉義都會實現。那就是，\n會轉化成一個換行符，\r 會轉化成一個回車，等等。 未知的轉義字符例如 \j不做處理。 簡單理解：按照規則pattern匹配字符串string，匹配的字符串按照規則repl來替換。替換后和原來字符串組合返回。repl可以使字符串也可以是函數。 |
語法：sub(pattern, repl, string, count=0, flags=0) >>> 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{'
>>> 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'
|
2.2、函數匯總
注意：python3中新增一個函數：
re.fullmatch()，這個函數和re.match()的不同之處是需要全部匹配才能返回字符串。如果沒有全部匹配則返回空。
| 序號 |
函數名 |
作用 |
實例 |
| 1 |
re.DEBUG |
顯示正則表達式的調試信息 |
>>> s = '\d\W' >>> r = re.compile(s, re.DEBUG) in category category_digit in category category_not_word |
| 2 |
re.DOTALL |
使'.'特殊字符匹配任何字符，包括換行 ；如果沒有此標志， '.'將匹配除換行符的任何內容。 |
>>> s = '.*' >>> r = re.match(s,'a.123\nabc') >>> r.group() 'a.123' >>> r = re.match(s,'a.123\nabc',re.DOTALL) >>> r.group() 'a.123\nabc' |
| 3 |
re.I |
測試和re.IGNORECASE作用相同是re.IGNORECASE的簡寫模式 |
>>> r = re.match('a*','aA',re.I) >>> r.group() 'aA' |
| 4 |
re.IGNORECASE |
執行不區分大小寫的匹配 ；如[A-Z]表達式將太匹配小寫字母。這不被受當前的區域設置。 |
>>> r = re.match('a*','aA',re.IGNORECASE) >>> r.group() 'aA' |
| 5 |
re.L |
和re.LOCALE作用相同。是re.LOCALE簡寫模式 |
|
| 6 |
re.LOCALE |
使用當前環境的\w, \W, \b, \B, \s and \S |
|
| 7 |
re.M |
|
|
| 8 |
re.MULTILINE |
當指定時，模式字符' ^'匹配字符串的開頭以及每個行的開頭（緊接每個換行符）； 模式字符'$'匹配字符串的末尾以及每一行的結尾（緊靠每個換行符之前）。 默認情況下， '^'只匹配字符串的開始，'$'只匹配字符串的末尾和字符串末尾換行符（如果有的話）之前的位置 |
|
| 9 |
re.S |
作用和re.DOTALL相同。使'.'特殊字符匹配任何字符，包括換行 ；如果沒有此標志， '.'將匹配除換行符的任何內容。 |
>>> s = '.*' >>> r = re.match(s,'a.123\nabc') >>> r.group() 'a.123' >>> r = re.match(s,'a.123\nabc',re.S) >>> r.group() 'a.123\nabc' |
| 10 |
re.Scanner |
|
|
| 11 |
re.T |
|
|
| 12 |
re.TEMPLATE |
|
|
| 13 |
re.U |
和re.UNICODE作用相同 |
|
| 14 |
re.UNICODE |
使得\w, \W, \b, \B, \d, \D, \s和 \S 取決於UNICODE定義的字符屬性 |
|
| 15 |
re.VERBOSE |
此標志允許您編寫正則表達式，看起來更好。在模式中的空白將被忽略，除非當在字符類或者前面非轉義反斜杠，和，當一條線包含一個'#'既不在字符類中或由非轉義反斜杠，從最左側的所有字符之前，這種'#'通過行末尾將被忽略。 這意味着兩個以下正則表達式匹配的對象，一個十進制數是相同的功能：
a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*") |
|
| 16 |
re.X |
|
|
| 17 |
re._MAXCACHE |
|
|
| 18 |
re.__all__ |
|
|
| 19 |
re.__class__() |
|
|
| 20 |
re.__delattr__() |
|
|
| 21 |
re.__dict__ |
|
|
| 22 |
re.__doc__ |
|
|
| 23 |
re.__file__ |
|
|
| 24 |
re.__format__() |
|
|
| 25 |
re.__getattribute__() |
|
|
| 26 |
re.__hash__() |
|
|
| 27 |
re.__init__() |
|
|
| 28 |
re.__name__ |
|
|
| 29 |
re.__new__() |
|
|
| 30 |
re.__package__ |
|
|
| 31 |
re.__reduce__() |
|
|
| 32 |
re.__reduce_ex__() |
|
|
| 33 |
re.__repr__() |
|
|
| 34 |
re.__setattr__() |
|
|
| 35 |
re.__sizeof__() |
|
|
| 36 |
re.__str__() |
|
|
| 37 |
re.__subclasshook__() |
|
|
| 38 |
re.__version__ |
|
|
| 39 |
re._alphanum |
|
|
| 40 |
re._cache |
|
|
| 41 |
re._cache_repl |
|
|
| 42 |
re._compile() |
|
|
| 43 |
re._compile_repl() |
|
|
| 44 |
re._expand() |
|
|
| 45 |
re._locale |
|
|
| 46 |
re._pattern_type() |
|
|
| 47 |
re._pickle() |
|
|
| 48 |
re._subx() |
|
|
| 49 |
re.compile() |
將正則表達式模式編譯成一個正則表達式對象，它可以用於匹配使用它的match ()和search ()方法，如下所述。 可以通過指定flags值修改表達式的行為。值可以是任何以下變量，使用組合 OR （ |運算符）。 但使用re.compile()和保存所產生的正則表達式對象重用效率更高時該表達式會在單個程序中多次使用。 |
語法：compile(pattern, flags=0) >>> s = '[a-z]+\d*' >>> a = re.compile(s) >>> a <_sre.SRE_Pattern object at 0x0000000003308738> >>> type(a) <type '_sre.SRE_Pattern'> >>> b = a.match('a123') >>> b.group() 'a123' 等價於： >>> b = re.match('[a-z]+\d*', 'a123') >>> b.group() 'a123' |
| 50 |
re.copy_reg |
幫助提供pickle/cPickle的可擴展性。 |
|
| 51 |
re.error() |
正則表達式異常，當一個字符串傳遞給這里的函數之一時引發的異常不是有效的正則表達式 （例如，它可能包含不匹配的括號） 或其他一些錯誤在編譯或匹配過程中發生的時。如果一個字符串包含不匹配的一種模式，它永遠不會是一個錯誤。 |
|
| 52 |
re.escape() |
返回的字符串與所有非字母數字帶有反斜杠；這是有用的如果你想匹配一個任意的文本字符串，在它可能包含正則表達式元字符 簡單理解：把字符串按照可能會是正則表達式來理解，這樣就需要把特殊字符都轉義。這樣才能方便匹配時精確匹配每個字符。 字符'[a-z]'這個字符串可以看作是正則表達式的模式，這樣就不能作為被匹配的字符串。如果想把這個字符串作為被匹配的模式就需要轉義這些特殊字符。print(re.escape('[a-z]')) \[a\-z\] |
語法：escape(pattern) >>> s = 'abc.|123' >>> print s abc.|123 >>> print(re.escape(s)) abc\.\|123 |
| 53 |
re.findall() |
作為一個字符串列表，在字符串中，返回所有非重疊匹配的模式。該字符串是從左到右掃描的，匹配按照發現的順序返回。如果一個或多個組是本模式中，返回一個列表的群體 ；如果該模式具有多個組，這將是元組的列表。空匹配包含在結果中，除非他們接觸到另一場匹配的開頭。 返回一個匹配的所有內容的列表。如果沒有匹配內容則返回空列表。 在 1.5.2 版本新。 2.4 版本中的更改：添加可選的標志參數。 |
語法：findall(pattern, string, flags=0) >>> a = 'abc,123.abc.123' >>> s = '[a-z]+' >>> r = re.findall(s,a) >>> r ['abc', 'abc'] |
| 54 |
re.finditer() |
返回一個迭代器符合MatchObject情況 在 RE模式字符串中的所有非重疊的匹配。該字符串是掃描的左到右，和按發現的順序返回匹配。空匹配包含在結果中，除非他們接觸的另一個匹配的開頭。 新版本 2.2 中的。 2.4 版本中的更改：添加可選的標志參數。 |
>>> a = 'testestest' >>> s = 'test' >>> r = re.finditer(s,a) >>> c = r.next() >>> c.group() 'test' >>> c = r.next() >>> c.group() 'test' >>> c = r.next() Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration
>>> 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: carefully 40-47: quickly |
| 55 |
re.match() |
如果在字符串的開頭的零個或更多字符匹配這個正則表達式，將返回相應的作法實例。返回沒有如果，則該字符串與模式不匹配請注意這是不同於零長度匹配。 簡單理解：就是從字符串的開始做正則匹配。能匹配到的最大位置返回。返回的對象用group/groups方法讀取。可以不匹配到字符串的末尾。但是字符串的開始必須匹配，否則返回空字符串。 |
語法：match(pattern, string, flags=0) >>> s = '[a-z]*' >>> a = 'test123' >>> b = re.match(s,a) >>> b.group() 'test' >>> a = '123abc' >>> b = re.match(s,a) >>> b.group() ''
|
| 56 |
re.purge() |
清除正則表達式緩存。 |
|
| 57 |
re.search() |
掃描字符串尋找第一個匹配位置，在此正則表達式產生的匹配，並返回相應的MatchObject實例。如果沒有字符串中的位置匹配模式返回空 。 可選的第二個參數pos給索引在字符串中搜索在哪里開始；它將默認為0。這並不完全等於切片的字符串 ； ' ^'模式字符匹配在真正開始的字符串和位置剛換行，但不是一定是在開始搜索的索引。
可選參數endpos限制了多遠的字符串將被搜索 ；它將，如果字符串是endpos個字符長，因此，只有從pos到字符endpos - 1將搜索匹配項。如果endpos小於pos，沒有比賽會發現，否則，如果rx是已編譯的正則表達式對象， rx.search （字符串， 0， 50)相當於rx.search （字符串 [： 50]， 0)。 注意：如果查找字符時用*則會默認匹配0個對應的字符。這樣就會返回空字符串。 |
語法：search(pattern, string, flags=0) >>> s = '\d*' >>> a = 'abc123,31' >>> s = re.search(s,a) >>> s.group() '' >>> s.span() (0, 0) >>> s = '\d+' >>> s = re.search(s,a) >>> s.span() (3, 6) >>> s.group() '123' |
| 58 |
re.split() |
將字符串拆分的模式的匹配項。如果在模式中使用捕獲括號，則然后也作為結果列表的一部分返回的文本模式中的所有組。如果maxsplit不為零，頂多maxsplit分裂發生，並且該字符串的其余部分將作為列表的最后一個元素返回。（不兼容性說明： 在原始的 Python 1.5 版本中， maxsplit被忽略。這已被固定在以后的版本。） |
語法：split(pattern, string, maxsplit=0, flags=0) >>> 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"""
>>> 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'] >>> [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']]
>>> [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']]
|
| 59 |
re.sre_compile |
|
|
| 60 |
re.sre_parse |
|
|
| 61 |
re.sub() |
Return the string obtained by replacing the leftmost non-overlapping occurrences of pattern in string by the replacement repl. 如果pattern沒有被找到， string不變。repl 可以是一個字符串或一個函數；如果是一個字符串, 任何反斜杠轉義都會實現。那就是，\n會轉化成一個換行符，\r 會轉化成一個回車，等等。 未知的轉義字符例如 \j不做處理。 簡單理解：按照規則pattern匹配字符串string，匹配的字符串按照規則repl來替換。替換后和原來字符串組合返回。repl可以使字符串也可以是函數。 |
語法：sub(pattern, repl, string, count=0, flags=0) >>> 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{'
>>> 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'
|
| 62 |
re.subn() |
執行相同的操作，如sub()，但返回一個元組（new_string， number_of_subs_made)。 2.7 版本中的更改：添加可選的標志參數。 |
語法：subn(pattern, repl, string, count=0, flags=0)
|
| 63 |
re.sys |
|
|
| 64 |
re.template() |
|
|
2.3、函數返回的MatchObject對象的內置函數
search、match返回對象是MatchObject或者是None。
findall返回對象是列表。列表每個元素都是一個可以匹配的一段子串。
如果是MatchObject則這個對象的內置函數包括：
| 序號 |
函數名 |
作用 |
| 1 |
re.__class__() |
|
| 2 |
re.__copy__() |
|
| 3 |
re.__deepcopy__() |
|
| 4 |
re.__delattr__() |
|
| 5 |
re.__doc__ |
|
| 6 |
re.__format__() |
|
| 7 |
re.__getattribute__() |
|
| 8 |
re.__hash__() |
|
| 9 |
re.__init__() |
|
| 10 |
re.__new__() |
|
| 11 |
re.__reduce__() |
|
| 12 |
re.__reduce_ex__() |
|
| 13 |
re.__repr__() |
|
| 14 |
re.__setattr__() |
|
| 15 |
re.__sizeof__() |
|
| 16 |
re.__str__() |
|
| 17 |
re.__subclasshook__() |
|
| 18 |
re.end() |
返回這個對象的內容長度 |
| 19 |
re.endpos |
|
| 20 |
re.expand() |
|
| 21 |
re.group() |
返回對象匹配的內容，這是所有內容。如果匹配的正則表達式分組了，那么這個函數返回的值就是元組，元組每個元素都是匹配的一個子串 |
| 22 |
re.groupdict() |
|
| 23 |
re.groups() |
如果匹配的正則表達式分組了，那么可以用這個函數返回指定組名的字符串。默認時組0 |
| 24 |
re.lastgroup |
最后一個分組內容 |
| 25 |
re.lastindex |
|
| 26 |
re.pos |
|
| 27 |
re.re |
|
| 28 |
re.regs |
|
| 29 |
re.span() |
返回這個對象匹配的字符串在源字符串的起始和結束的索引值，以元組形式返回 |
| 30 |
re.start() |
返回匹配結果的內容匹配到源字符串的起始位置的索引值，返回整型 |
| 31 |
re.string |
返回源字符串。 |
三、注意事項
3.1、match、fullmatch、findall、finditer、search
match是根據傳入的正則表達式匹配對應的字符串。並且是從開始字符匹配。匹配到字符不能匹配的位置然后返回匹配的對象。返回的對象是MatchObject或者空。
fullmatch，和match的區別是fullmatch必須是目標字符串從開始到結束全部都匹配這個傳入的正則表達式才可以返回匹配對象。否則返回空。返回的對象也是MatchObject對象。
findall，從字符串中從前向后依次查找匹配正則表達式的子串。最后把多個匹配的子串用列表形式返回。列表的每個元素是一個匹配的子串。
finditer，和findall功能相同。但是finditer返回的是一個可迭代對象。可以用next()方法讀取。然后再用group方法讀取匹配的內容。
search，是從前向后依次掃描整個字符串。返回第一個匹配的子串。匹配位置不一定是開始字符。但是如果用*來表示0-n次重復時需要測試。有時候會返回空字符串。