文章目錄

• • 一、特殊字符(這里列出常用的)
  • 二、函數(shù)語法中flags=0參數(shù)——官方解釋
  • 三、re.match
  • 四、re.search
  • 五、re.match與re.search的區(qū)別
  • 六、re.compile
  • 七、findall
  • 八、re.M與re.S對比，還有其中的.\*與.\*?對比

一、特殊字符(這里列出常用的)

參考于：https://docs.python.org/zh-cn/3/library/re.html

符號釋義

普通字符	匹配自身
.	(點) 在默認模式，匹配除了換行的任意字符。如果指定了標(biāo)簽 DOTALL ，它將匹配包括換行符的任意字符。
^	(插入符號) 匹配字符串的開頭， 并且在 MULTILINE 模式也匹配換行后的首個符號，舉例：^表示行的開頭， ^\d表示必須以數(shù)字開頭。$表示行的結(jié)束，\d$表示必須以數(shù)字結(jié)束
$	匹配字符串尾或者換行符的前一個字符，在 MULTILINE 模式匹配換行符的前一個字符。 foo 匹配 ‘foo’ 和 ‘foobar’ , 但正則 foo$ 只匹配 ‘foo’。更有趣的是， 在 ‘foo1\nfoo2\n’ 搜索 foo.$ ，通常匹配 ‘foo2’ ，但在 MULTILINE 模式 ，可以匹配到 ‘foo1’ ；在 ‘foo\n’ 搜索 $ 會找到兩個空串：一個在換行前，一個在字符串最后。
*	對它前面的正則式匹配0到任意次重復(fù)， 盡量多的匹配字符串。 ab* 會匹配 ‘a(chǎn)’， ‘a(chǎn)b’， 或者 'a’后面跟隨任意個 'b’
+	對它前面的正則式匹配1到任意次重復(fù)。 ab+ 會匹配 ‘a(chǎn)’ 后面跟隨1個以上到任意個 ‘b’，它不會匹配 'a’
?	對它前面的正則式匹配0到1次重復(fù)。 ab? 會匹配 ‘a(chǎn)’ 或者 'ab’
*?, +?, ??	* , + 和 ? 修飾符都是 貪婪的；它們在字符串進行盡可能多的匹配。有時候并不需要這種行為。如果正則式 <.*> 希望找到 ‘<a> b <c>’，它將會匹配整個字符串，而不僅是 ‘<a>’。在修飾符之后添加 ? 將使樣式以非貪婪方式或者 :dfn:`最小 方式進行匹配； 盡量 少 的字符將會被匹配。 使用正則式 <.*?> 將會僅僅匹配 <a>
“{m}”	對其之前的正則式指定匹配 m 個重復(fù)；少于 m 的話就會導(dǎo)致匹配失敗。比如， a{6} 將匹配6個 ‘a(chǎn)’ , 但是不能是5個
“{m, n}”	對正則式進行 m 到 n 次匹配，在 m 和 n 之間取盡量多。 比如，a{3,5} 將匹配 3 到 5個 ‘a(chǎn)’。忽略 m 意為指定下界為0，忽略 n 指定上界為無限次。 比如 a{4,}b 將匹配 ‘a(chǎn)aaab’ 或者1000個 ‘a(chǎn)’ 尾隨一個 ‘b’，但不能匹配 ‘a(chǎn)aab’。逗號不能省略，否則無法辨別修飾符應(yīng)該忽略哪個邊界
{m,n}?	前一個修飾符的非貪婪模式，只匹配盡量少的字符次數(shù)。比如，對于 ‘a(chǎn)aaaaa’， a{3,5} 匹配 5個 ‘a(chǎn)’ ，而 a{3,5}? 只匹配3個 ‘a(chǎn)’
\	轉(zhuǎn)義特殊字符（允許你匹配 ‘*’, ‘?’, 或者此類其他），或者表示一個特殊序列；特殊序列之后進行討論。如果你沒有使用原始字符串（ r’raw’ ）來表達樣式，要牢記Python也使用反斜杠作為轉(zhuǎn)義序列；如果轉(zhuǎn)義序列不被Python的分析器識別，反斜杠和字符才能出現(xiàn)在字符串中。如果Python可以識別這個序列，那么反斜杠就應(yīng)該重復(fù)兩次。這將導(dǎo)致理解障礙，所以高度推薦，就算是最簡單的表達式，也要使用原始字符串
[]	用于表示一個字符集合。在一個集合中：字符可以單獨列出，比如[amk] 匹配 ‘a(chǎn)’， ‘m’， 或者 ‘k’。可以表示字符范圍，通過用 ‘-’ 將兩個字符連起來。比如 [a-z] 將匹配任何小寫ASCII字符， [0-5][0-9] 將匹配從 00 到 59 的兩位數(shù)字， [0-9A-Fa-f] 將匹配任何十六進制數(shù)位。 如果 - 進行了轉(zhuǎn)義 （比如 [a-z]）或者它的位置在首位或者末尾（如 [-a] 或 [a-]），它就只表示普通字符 ‘-’。特殊字符在集合中，失去它的特殊含義。比如 [(+*)] 只會匹配這幾個文法字符 ‘(’, ‘+’, ‘*’, or ‘)’。字符類如 \w 或者 \S (如下定義) 在集合內(nèi)可以接受，它們可以匹配的字符由 ASCII 或者 LOCALE 模式?jīng)Q定。不在集合范圍內(nèi)的字符可以通過 取反 來進行匹配。如果集合首字符是 ‘^’ ，所有 不 在集合內(nèi)的字符將會被匹配，比如[^5]將匹配所有字符，除了 ‘5’， [^^] 將匹配所有字符，除了 ‘^’. ^ 如果不在集合首位，就沒有特殊含義。在集合內(nèi)要匹配一個字符 ‘]’，有兩種方法，要么就在它之前加上反斜杠，要么就把它放到集合首位。比如， [()[]{}] 和 [{}] 都可以匹配括號。Unicode Technical Standard #18 里的嵌套集合和集合操作支持可能在未來添加。這將會改變語法，所以為了幫助這個改變，一個 FutureWarning 將會在有多義的情況里被 raise，包含以下幾種情況，集合由 ‘[’ 開始，或者包含下列字符序列 ‘–’, ‘&&’, ‘~~’, 和 ‘||’。為了避免警告，需要將它們用反斜杠轉(zhuǎn)義。
|	A|B， A 和 B 可以是任意正則表達式，創(chuàng)建一個正則表達式，匹配 A 或者 B. 任意個正則表達式可以用 ‘|’ 連接。它也可以在組合（見下列）內(nèi)使用。掃描目標(biāo)字符串時， ‘|’ 分隔開的正則樣式從左到右進行匹配。當(dāng)一個樣式完全匹配時，這個分支就被接受。意思就是，一旦 A 匹配成功， B 就不再進行匹配，即便它能產(chǎn)生一個更好的匹配。或者說，’|’ 操作符絕不貪婪。 如果要匹配 ‘|’ 字符，使用 |， 或者把它包含在字符集里，比如 [|]
(…)	(組合），匹配括號內(nèi)的任意正則表達式，并標(biāo)識出組合的開始和結(jié)尾。匹配完成后，組合的內(nèi)容可以被獲取，并可以在之后用 \number 轉(zhuǎn)義序列進行再次匹配，之后進行詳細說明。要匹配字符 ‘(’ 或者 ‘)’, 用 ( 或 ), 或者把它們包含在字符集合里: [(], [)]

由 ‘\’ 和一個字符組成的特殊序列在以下列出。 如果普通字符不是ASCII數(shù)位或者ASCII字母，那么正則樣式將匹配第二個字符。比如，\$ 匹配字符 ‘$’

符號釋義

\number	匹配數(shù)字代表的組合。每個括號是一個組合，組合從1開始編號。比如 (.+) \1 匹配 ‘the the’ 或者 ‘55 55’, 但不會匹配 ‘thethe’ (注意組合后面的空格)。這個特殊序列只能用于匹配前面99個組合。如果 number 的第一個數(shù)位是0， 或者 number 是三個八進制數(shù)，它將不會被看作是一個組合，而是八進制的數(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’。默認情況下，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十進制數(shù)（就是在Unicode字符目錄[Nd]里的字符）。這包括了 [0-9] ，和很多其他的數(shù)字字符。如果設(shè)置了 ASCII 標(biāo)志，就只匹配 [0-9] 。對于8位(bytes)樣式：匹配任何十進制數(shù)，就是 [0-9]
\D	匹配任何非十進制數(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的字符串本身也用\轉(zhuǎn)義，因此我們建議使用Python的r前綴，就不用考慮轉(zhuǎn)義的問題了
舉例：

s = '123\\abc' # Python的字符串 # 對應(yīng)的正則表達式字符串變成： # '123\abc' 改寫為r前綴，如下： s =r'123\abc' # Python的字符串 # # 對應(yīng)的正則表達式字符串變成： # # '123\abc'

二、函數(shù)語法中flags=0參數(shù)——官方解釋

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 是冗余的，因為默認字符串已經(jīng)是Unicode了（并且Unicode匹配不允許byte出現(xiàn))。

re.DEBUG
顯示編譯時的debug信息，沒有內(nèi)聯(lián)標(biāo)記。

re.I
re.IGNORECASE
進行忽略大小寫匹配；表達式如 [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 帶個點在上面), ‘?’ (U+0131, 拉丁小寫沒有點的 I ), ‘?’ (U+017F, 拉丁小寫長 s) and ‘K’ (U+212A, 開爾文符號).如果使用 ASCII 標(biāo)記，就只匹配 ‘a(chǎn)’ 到 ‘z’ 和 ‘A’ 到 ‘Z’ 。

re.L
re.LOCALE
由當(dāng)前語言區(qū)域決定 \w, \W, \b, \B 和大小寫敏感匹配。這個標(biāo)記只能對byte樣式有效。這個標(biāo)記不推薦使用，因為語言區(qū)域機制很不可靠，它一次只能處理一個 "習(xí)慣”，而且只對8位字節(jié)有效。Unicode匹配在Python 3 里默認啟用，并可以處理不同語言。 這個對應(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é)尾（換行符前面那個符號）。默認情況下，’^’ 匹配字符串頭，’$’ 匹配字符串尾。對應(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āng)中或者由反斜杠轉(zhuǎn)義，或者在 *?, (?: or (?P<…> 分組之內(nèi)。當(dāng)一個行內(nèi)有 # 不在字符集和轉(zhuǎn)義序列，那么它之后的所有字符都是注釋。

三、re.match

re.match 從字符串的起始位置開始匹配，如果起始位置匹配不成功的話，match()就返回none

語法：re.match(pattern, string, flags=0)

簡單的說就是：string(大魚)里有沒有pattern(小魚)
參數(shù)說明:

參數(shù)描述

pattern	匹配的正則表達式 (pattern就好比小魚)
string	被匹配的字符串(string就好比大魚)
flags	標(biāo)志位，用于控制正則表達式的匹配方式，如：是否區(qū)分大小寫，多行匹配等等

舉例：

import reprint(re.match('韶', '韶風(fēng)')) #在起始位置匹配 print(re.match('風(fēng)', '韶風(fēng)')) #不在起始位置匹配#結(jié)果 <re.Match object; span=(0, 1), match='韶'> None

四、re.search

re.search 掃描整個字符串并返回第一個成功的匹配

語法：re.search(pattern, string, flags=0)

參數(shù)說明:

參數(shù)描述

pattern	匹配的正則表達式 (pattern就好比小魚)
string	被匹配的字符串(string就好比大魚)
flags	標(biāo)志位，用于控制正則表達式的匹配方式，如：是否區(qū)分大小寫，多行匹配等等

匹配成功re.search方法返回一個匹配的對象，否則返回None

舉例：

import reprint(re.search('韶', '韶風(fēng)')) #在起始位置匹配 print(re.search('風(fēng)', '韶風(fēng)')) #不在起始位置匹配#結(jié)果 <re.Match object; span=(0, 1), match='韶'> <re.Match object; span=(1, 2), match='風(fēng)'>

五、re.match與re.search的區(qū)別

re.match只匹配字符串的開始，如果字符串開始不符合正則表達式，則匹配失敗，函數(shù)返回None；而re.search匹配整個字符串，直到找到一個匹配，否則返回None

六、re.compile

compile 函數(shù)用于編譯正則表達式，生成一個正則表達式（ Pattern ）對象，供 match() 和 search() 這兩個函數(shù)使用。

語法格式為：

re.compile(pattern[, flags]) prog = re.compile(pattern) result = prog.match(string) 等價于 result = re.match(pattern, string)

參數(shù)：

pattern : 一個字符串形式的正則表達式flags : 可選，表示匹配模式，比如忽略大小寫，多行模式等，具體參數(shù)為： re.I 忽略大小寫 re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依賴于當(dāng)前環(huán)境 re.M 多行模式 re.S 即為 . 并且包括換行符在內(nèi)的任意字符（. 不包括換行符） re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依賴于 Unicode 字符屬性數(shù)據(jù)庫 re.X 為了增加可讀性，忽略空格和 # 后面的注釋

舉例：

import reA='123456QWERT!@#$%\n' \'<a> a<c>\n' \'12s6634566666' com = re.compile(r'<.*>',re.S) print(com.search(A).group()) #結(jié)果： <a> a<c>

group([group1, …]) 方法用于獲得一個或多個分組匹配的字符串，當(dāng)要獲得整個匹配的子串時，可直接使用 group() 或 group(0)； start([group]) 方法用于獲取分組匹配的子串在整個字符串中的起始位置（子串第一個字符的索引），參數(shù)默認值為0； end([group]) 方法用于獲取分組匹配的子串在整個字符串中的結(jié)束位置（子串最后一個字符的索引+1），參數(shù)默認值為 0； span([group]) 方法返回 (start(group), end(group))

七、findall

在字符串中找到正則表達式所匹配的所有子串，并返回一個列表，如果沒有找到匹配的，則返回空列表。
注意： match 和 search 是匹配一次，而findall 是匹配所有

語法：findall(string[, pos[, endpos]]) 參數(shù)： string : 待匹配的字符串。 pos : 可選參數(shù)，指定字符串的起始位置，默認為 0。 endpos : 可選參數(shù)，指定字符串的結(jié)束位置，默認為字符串的長度。 import re A='123456QWERT!@#$%\n' \'<a> a<c>\n' \'12s6634566666'\com = re.compile(r'<.*>',re.S) print(com.findall(A)) 或 import reA='123456QWERT!@#$%\n' \'<a> a<c>\n' \'12s6634566666'com = re.findall(r'<.*>',A,re.S) print(com)#兩種方法的結(jié)果： ['<a> a<c>']

八、re.M與re.S對比，還有其中的.*與.*?對比

第一個：
re.M與re.對比

#re.M import reA='123456QWERT!@#$%\n' \'<a1> a<c>\n' \'12s6634566666\n'\'<12><2><3>'com = re.findall(r'<.*>',A,re.M) print(com) #結(jié)果： ['<a1> a<c>', '<12><2><3>']#re.S import reA = '123456QWERT!@#$%\n' \'<a1> a<c>\n' \'12s6634566666\n'\'<12><2><3>'com = re.findall(r'<.*>',A,re.S) print(com) #結(jié)果： ['<a1> a<c>\n12s6634566666\n<12><2><3>'] #這里是貪婪匹配，又因為選擇的re.S(可以匹配換行符)，所以匹配到了第一個<到最后一個>中的所有內(nèi)容#總結(jié)：遇到換行的還是使用re.M，如果你需要換行符，就選擇re.S

第二個:
.*與.*?對比

#.* import reA = '123456QWERT!@#$%\n' \'<a1> a<c>\n' \'12s6634566666\n'\'<12><2><3>'com = re.findall(r'<.*>',A,re.M) print(com) #結(jié)果： ['<a1> a<c>', '<12><2><3>']#.*? import reA = '123456QWERT!@#$%\n' \'<a1> a<c>\n' \'12s6634566666\n'\'<12><2><3>'com = re.findall(r'<.*?>',A,re.M) print(com) #結(jié)果： ['<a1>', '<c>', '<12>', '<2>', '<3>']總結(jié)：.*是貪婪匹配，就是匹配所有的從第一個<到最后一個>內(nèi)的所有內(nèi)容(對它前面的正則式匹配0到任意次重復(fù))，盡量多的匹配字符串簡單釋義：因為<所以先匹配<，再看.，所以匹配a，再看*，因為后面沒有?，所以貪婪匹配，匹配前面的.最大次數(shù)， 一直匹配到結(jié)尾的>(這個最后的>不在*的匹配里面，因此這個>在A里必須要有，否則匹配不到>，會顯示空)，匹配就結(jié)束， 結(jié)果就是['<a1> a<c>', '<12><2><3>'].*?是非貪婪匹配(*?是一個整體)，以最小的方式進行匹配(*?表示對它前面的正則式匹配盡量少的次數(shù)，最小0次)簡單釋義：因為<所以先匹配<，再看.，所以匹配a，再看*，因為后面有?，所以*?是一個整體，使用非貪婪匹配， 匹配前面.的最少的次數(shù)，0次，但這里最后有個普通字符>，就把普通字符>前面的全部匹配進去，因而這里的匹配次數(shù)最小， 就是匹配離.*?最近的>，所以第一個匹配的就是<a1>，而非['<a1> a<c>', '<12><2><3>']， 接著依次按照匹配<a1>的步驟匹配<c>,<12>,<2>,<3>,最后結(jié)果是['<a1>', '<c>', '<12>', '<2>', '<3>']， 這里為什么能匹配這么多，請看前面的findall函數(shù)釋義哦~ 在findall中，只要第一次匹配成功的，就納入列表，接著匹配下一個，納入列表的就不再重新匹配

幫助理解.*?的代碼

#.*?代碼的理解(幫助記憶) #1. import re A = '12>' com = re.search(r'.*?',A,re.M) print(com.group()) #結(jié)果： 無返回值，什么都沒有 #釋義：.匹配1，因為*?，所以最小匹配，匹配前面的.0次，所以返回空#2. import re A = '12>' com = re.search(r'1.*?',A,re.M) print(com.group()) #結(jié)果： 1 #釋義：匹配普通字符1，然后.匹配2，因為*?，所以最小匹配，匹配前面的.0次。所以最后返回1#3. import re A = '12>' com = re.search(r'1.*?>',A,re.M) print(com.group()) #結(jié)果： 12> #釋義：匹配普通字符1，然后匹配2，因為*?，所以最小匹配，但是他結(jié)尾還匹配了普通字符>，所以完成盡量少匹配，尋找離*?最近的>(#4就驗證了這個道理)，之后1到>里面的內(nèi)容全部匹配#4. import re A = '12><12>' com = re.search(r'1.*?>',A,re.M) print(com.group()) #結(jié)果： 12>總結(jié)：上面四段代碼表示，一般情況下，都是*?按照最小次數(shù)匹配，也就是0次，但只要*?后面若有普通字符的匹配， 那就把普通字符前面的全部匹配進去，但后面的普通字符要是最小次數(shù)的，匹配.*?后面靠著最近的一個普通字符>， 完成所謂的最小匹配

注：這里的筆記只挑選了幾個函數(shù)，其他函數(shù)語法請參考：https://docs.python.org/zh-cn/3/library/re.html
和
https://www.runoob.com/python/python-reg-expressions.html

總結(jié)

以上是生活随笔為你收集整理的Python3.7模块之re的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。