python基礎之正則表達式

 

正則表達式語法

正則表達式 （或 RE） 指定一組字符串匹配它;在此模塊中的功能讓您檢查一下，如果一個特定的字符串匹配給定的正則表達式 （或給定的正則表達式匹配特定的字符串，可歸結為同一件事）。

正則表達式可以連接到形式新的正則表達式; 如果A 和 B 兩個都是正則表達式, 那么 AB i也是正則表達式。

本模塊提供了類似於那些在 Perl 中找到的正則表達式匹配操作。

兩個模式和字符串被搜索可以是Unicode字符串以及8位串。然而，Unicode字符串和8位串不能混用：也就是說，你不能匹配一個Unicode字符串用字節模式，反之亦然; 類似地，要求一個取代時，替換字符串必須是同一類型的圖案和搜索字符串兩者。

正則表達式用反斜杠字符（'\'）來表示特殊格式或允許在不調用它們的特殊含義要使用特殊字符。這與碰撞為字符串文字相同的目的相同的字符Python的使用; 例如，匹配一個反斜杠，人們可能不得不寫'\\\\'的模式字符串，因為正則表達式必須是\\，而且每個反斜杠必須表示為\\一個普通的Python字符串里。

解決的辦法是使用Python的raw字符串表示的正則表達式模式; 反斜杠不會以任何特殊的方式在字符串字面處理前綴'r'。因此r"\n"是一個包含兩個字符'\'和'n'，而"\n"是包含一個換行符一個一個字符的字符串。通常的模式將在Python代碼使用這種原始字符串表示法表示。

需要注意的是大多數的正則表達式的操作可作為模塊級的功能和方法是很重要的已編譯的正則表達式。該功能是不要求你先編譯一個正則表達式對象，但錯過了一些微調參數快捷鍵。

正則表達式可以包含特殊和普通字符。最普通的字符，如 'A'，'a'，或 '0'，是最簡單的正則表達式;他們只是與自己相匹配。You can concatenate ordinary characters, so lastmatches the string 'last'. (In the rest of this section, we’ll write RE’s in this special style, usually without quotes, and strings to be matched 'in single quotes'.)

某些字符，如'|'或'('，是特殊的。特殊字符不是代表的普通字符類，或會影響他們周圍的正則表達式解釋。正則表達式模式的字符串可能不包含空字節，但可使用指定空字節\number符號如'\x00'。

的特殊字符是：

'.'

(Dot.)  在默認模式下，匹配除換行符之外的任何字符。 如果 DOTALL 標志被指定時，匹配任何字符包括換行符。

'^'

(Caret.)  從字符串的開始匹配, 在 MULTILINE 模式下每個換行符后面立即開始匹配。

'$'

匹配字符串的結尾或只是之前換行符結尾的字符串，並在 多行 模式下也匹配在換行符之前。 foo matches both ‘foo’ and ‘foobar’, while the regular expression foo$ matches only ‘foo’.  More interestingly, searching for foo.$ in 'foo1\nfoo2\n' matches ‘foo2’ normally, but ‘foo1’ in MULTILINE mode; searching for a single $ in 'foo\n' will find two (empty) matches: one just before the newline, and one at the end of the string.

'*'

原因形成的再匹配0或多次重復前面的RE，因為許多重復的是可能的。 ab*將匹配'a'，'AB'或'a'后跟任意數目的'B的。

'+'

使所得RE以匹配前面的RE 1以上重復。 ab+將匹配'a'后跟任何非零數字的'B的; 它不會匹配只是'一'。

'?'

使所得RE以匹配前面的RE 0或1次重復。 將匹配'a'或'AB'。 ab?

*?, +?, ??

的'*'，'+'和'?' 預選賽都是貪婪的 ; 它們匹配盡可能多的文字越好。 有時，這種行為是不希望的; 如果RE <.*>是對匹配，它將整個字符串匹配，而不是只。<a> b <c><a> 添加? 了預選賽后，使得它執行在比賽非貪婪或最小的時尚; 作為幾個字符可能會被匹配。 使用RE <.*?>只會匹配<a>。

{m}

指定正好米以前的RE的副本應該匹配; 比賽少導致整個RE不匹配。 例如，a{6}將匹配整整6 'a'個字符，但不是五個。

{m,n}

使所得稀土，從符合米到Ñ前述稀土的重復，試圖匹配盡可能多的重復越好。 例如，a{3,5}將匹配的3至5 'a'個字符。 省略米指定下限為零，並省略ñ指定一個無限的上限。 作為一個例子，a{4,}b將匹配aaaab或一千'a'后跟一個字符b，但不是aaab。 逗號可能不被省略或修改將與先前描述的形式相混淆。

{m,n}?

使所得稀土，從符合米到Ñ前述稀土的重復，試圖作為匹配少重復越好。 這是前面限定的非貪婪版本。 例如，在6個字符的字符串'aaaaaa'，a{3,5}將匹配5 'a'個字符，而a{3,5}? 將只匹配3個字符。

'\'

或者轉義特殊字符（允許您匹配類似的字符'*'，'?'等等），或者發出一個特殊序列; 特殊序列在下面討論。

如果你不使用原始字符串來表達模式，請記住，Python中也使用反斜杠作為字符串文字的轉義序列; 如果轉義序列不被Python的解析器識別，反斜杠和隨后的字符都包含在產生的字符串中。然而，如果Python中會認識到所產生的序列，反斜線應重復兩次。這是復雜的，很難理解，所以強烈建議您使用的所有原始字符串，但最簡單的表達。

[]

用來表示一個字符集合。在這個集合中：

• 字符可以被單獨羅列，例如：[amk] 會匹配 'a', 'm', 或 'k'.
• 字符范圍可以表明通過給予兩個字符和分離他們的 '-'、 例如 [z] 將匹配任何小寫字母的 ASCII 字母、 [0-5] [0-9] 將匹配所有兩位數數字從 00 到 59，和 [0-9A-Fa-f] 將都匹配任何十六進制數字。If - is escaped (e.g. [a\-z]) or if it’s placed as the first or last character (e.g. [a-]), it will match a literal '-'.
• 在集合內，特殊字符失去特殊意義。例如，[(+*)] 將匹配任何字符 '('，'+'，'* '，或 '')''。
• 字符類如\w或\S（如下定義）也接受一組內，盡管它們匹配的字符取決於是否ASCII或LOCALE模式是有效。
• 字符不在范圍內可以通過匹配補充設定。如果該組的第一個字符是'^'，所有屬於字符不是在設定將被匹配。例如，[^5]將匹配除了任何字符'5'，並且[^^]會匹配除了任意字符'^'。^有，如果它不是在集合的第一個字符沒有特殊含義。
• 要匹配文字']'集里面，前面加上反斜線，或者將其放置在集的開頭。例如，雙方[()[\]{}]並[]()[{}]都將匹配一個括號。

'|'

A|B，其中A和B可以是任意的RE，創建了一個正則表達式的匹配A或B  的RE的任意數量可以被分離'|'以這種方式。 這可以內組使用（見下文）為好。 作為目標串被掃描時，RE的分隔'|'是試圖從左到右。 當一個模式匹配完全，該分支被接受。 這意味着一旦A匹配時，B將不作進一步測試，即使它會產生一個較長的總的匹配。 換句話說，在'|'操作者從來貪婪。 要匹配文字'|'，使用\|，或將其包含在字符類中，如[|]。

(...)

無論匹配正則表達式的括號內，並指示開始和一組結束; 匹配已執行之后可以檢索一個組中的內容，並可以用在字符串中以后匹配\number特殊序列，如下所述。 要匹配的文字'('或')'使用\(，或\)，或將它們括字符類中：。[(] [)]

(?...)

這是一個擴展符號 (a '?' following a '(' 沒有別的意義). 在 '?'之后的第一個字符 決定了意義和進一步的語法結構是什么. 擴展通常不會創建一個新的組; (?P<name>...) 這個規則的唯一例外. 以下是當前支持的擴展。

(?aiLmsux)

（從設置一個或多個字母'a'，'i'，'L'，'m'，'s'，'u'，'x'。）組匹配空字符串; 字母設置相應的標志：re.A（ASCII-僅匹配），（re.I忽略大小寫）， re.L（當前位置有關）， re.M（多線）， re.S（點匹配所有），和re.X（詳細），整個正則表達式。（該標志描述模塊內容。）如果你想，而不是通過一個包括標志為正則表達式的一部分，這是非常有用的標志參數的re.compile()函數。

注意，(?x)標志改變表達是如何解析。應當首先使用在表達式串，或之后的一個或多個空格字符。如果有前旗非空白字符，結果是不確定的。

(?:...)

一個正則括號的不捕獲版本. Matches whatever regular expression is inside the parentheses, but the substring matched by the group cannot be retrieved after performing a match or referenced later in the pattern.

(?P<name>...)

和正則括號相似, 但是這個組匹配到的子字符串可以通過符號組名稱name進行訪問.組名稱必須是有效的Python標識符, 並且每個組名稱在正則表達式中只能被定義一次(注:組名必須唯一).一個符號組也是一個帶編號的組, 就好像這個組沒有被命名一樣.(注:除了原有的編號外再指定一個額外的別名).

可以在三種上下文中引用已命名的組。如果模式是 (?P<quote>['"]).*?(?P=quote) (例如:使用單引號或雙引號來匹配一個被引用的字符串):

參考上下文來組“引用”	如何引用它
以相同的模式本身	(?P=quote) （如圖所示） \1
處理匹配對象時 m	m.group('quote') m.end('quote') （等等。）
在傳遞到一個字符串repl的論點re.sub()	\g<quote> \g<1> \1

(?P=name)

反向引用一個命名組; 它匹配任何文本是由早期的命名組匹配的名稱。

(?#...)

注釋; 括號中的內容被忽略。

(?=...)

匹配，如果...匹配下，但不消耗任何字符串。 這就是所謂的前向斷言。 例如，將匹配，如果是其次才。Isaac (?=Asimov)'Isaac ''Asimov'

(?!...)

如果比賽...沒有一個匹配。 這是一種消極的前向斷言。 例如，將匹配如果它只是沒有后面。Isaac (?!Asimov)'Isaac ''Asimov'

(?<=...)

如果字符串中的當前位置被匹配前面匹配...，在當前位置結束。這被稱為正面向后插入。(?<=abc)def會找到一個匹配abcdef，因為后向將備份3個字符，並檢查所包含的模式匹配。所包含的模式必須只匹配一些固定長度的串，這意味着abc或者a|b是允許的，但a*並a{3,4}不是。請注意，這與積極向斷言啟動模式將不會匹配在所搜索的字符串的開始; 你很可能要使用的search()功能，而不是match()功能：

>>> import re
>>> m = re.search('(?<=abc)def', 'abcdef')
>>> m.group(0)
'def'

這個例子查找以下連字符的一句話：

>>> m = re.search('(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'

 

改變在3.5版本中：增加支持固定長度的組引用。

(?<!...)

如果匹配字符串中的當前位置不匹配的前面...。 這就是所謂的負向后插入。 轉正后向斷言相似，所包含的模式必須匹配只有一些固定長度的字符串。 被搜索與負向斷言開始可以在字符串的開頭匹配模式。

(?(id/name)yes-pattern|no-pattern)

將嘗試配合yes-pattern，如果給定組ID或名稱存在，並no-pattern如果它不。 no-pattern是可選的，並且可以省略。 例如，(<)?(\w+@\w+(?:\.\w+)+)(?(1)>|$)是不良的電子郵件匹配模式，這將匹配'<[e-mail]>'以及'[e-mail]'，但不與'<[e-mail]'也不'[e-mail]>'。

特殊的序列組成的'\'，並從以下列表中的一個字符。如果采用普通的字符不在列表上，然后將所得的稀土將匹配第二個字符。例如，\$匹配的字符'$'。

\number

匹配的組數相同的內容。 組編號從1開始 。例如，匹配或者，但不（注意該組之后的空間）。(.+)\1'the the''55 55''thethe' 這個特殊的序列可以僅用於匹配第一99組中的一個。 如果第一個數字數是0，或數為3個八進制數字長，也不會被解釋為一組的比賽，但與八進制值的字符數。 里面'['和']'一個字符類，所有的數字逃逸被視為字符。

\A

僅在字符串的開始匹配。

\b

匹配空字符串，但只在一個單詞的開頭或結尾。一個字被定義為Unicode字母或下划線字符序列，因此單詞的結尾是用空白或者非字母數字表明，非下划線Unicode字符。需要注意的是正式，\b被定義為一個之間的邊界\w和一\W字符（或反之亦然）之間，或\w與串的開頭/結束。這意味着，r'\bfoo\b'比賽'foo'，'foo.'，'(foo)'，但不是或。'bar foo baz''foobar''foo3'

默認的Unicode字母數字是所使用的那些，但這可以通過使用改變ASCII的標志。在字符范圍內，\b表示退格符，與python的字符串兼容。

\B

匹配空字符串，但它只是沒有在單詞的開頭或結尾。 這意味着，r'py\B'比賽'python'，'py3'，'py2'，但不能'py'，'py.'或'py!'。 \B是正好相反\b，因此，字字符的Unicode字母數字或下划線，雖然這可以通過使用改變ASCII的標志。

\d

對於Unicode（STR）模式：

匹配任何Unicode十進制數（也就是在Unicode字符類的任何字符[釹]）。 這包括[0-9]，和許多其他的數字字符集。 如果ASCII僅用於標記[0-9]匹配（但標志會影響整個規范表達式，從而在這種情況下使用顯式[0-9]可能是一個更好的選擇）。

對於8位（字節）型態：

匹配任何十進制數字; 這相當於[0-9]。

\D

匹配這不是一個Unicode十進制數字的任何字符。 這是相反的\d。 如果該ASCII標志用於這成為相當於[^0-9]（但標志會影響整個規范表達式，從而在這種情況下使用顯式[^0-9]可能是一個更好的選擇）。

\s

對於Unicode（STR）模式：

匹配的Unicode空白字符（包括，以及許多其他字符，例如，通過排版規則在許多語言要求的非中斷空格）。[ \t\n\r\f\v] 如果ASCII使用標志，只被匹配（但使用一個明確的標志會影響整個規范表達式，從而在這樣的情況下可能是一個更好的選擇）。[ \t\n\r\f\v][ \t\n\r\f\v]

對於8位（字節）型態：

匹配考慮空白在ASCII字符集的字符; 這相當於。[ \t\n\r\f\v]

\S

匹配這不是一個Unicode空白字符的任意字符。 這是相反的\s。 如果該ASCII標志用於這成為相當於（但標志會影響整個規范表達式，從而在這種情況下使用顯式可能是一個更好的選擇）。[^\t\n\r\f\v][^ \t\n\r\f\v]

\w

對於Unicode（STR）模式：

匹配的Unicode字符字; 這包括可以在任何語言中的單詞的一部分大多數字符，以及數字和下划線。 如果ASCII使用標志，只[a-zA-Z0-9_]被匹配（但使用一個明確的標志會影響整個規范表達式，從而在這樣的情況下[a-zA-Z0-9_]可能是一個更好的選擇）。

對於8位（字節）型態：

考慮匹配的字母數字ASCII字符集的字符; 這相當於[a-zA-Z0-9_]。

\W

匹配這不是一個Unicode字字符的任意字符。 這是相反的\w。 如果該ASCII標志用於這成為相當於[^a-zA-Z0-9_]（但標志會影響整個規范表達式，從而在這種情況下使用顯式[^a-zA-Z0-9_]可能是一個更好的選擇）。

\Z

僅在字符串的末尾匹配。

大多數被Python字符串支持的標准逃逸也由正則表達式解析器接受：

\a      \b      \f      \n
\r      \t      \u      \U
\v      \x      \\

 

（請注意，\b用於表示字邊界的裝置，以及僅內部字符類“退格”）。

'\u'和'\U'轉義序列只以Unicode模式的認可。在字節模式他們沒有特殊處理。

八進制轉義被包括在一個有限的形式。如果第一個數字是0，或者有三個八進制數字，它被認為是一個八進制轉義。否則，它是一組參考。對於字符串，八進制轉義始終是最多三位數字的長度。

改變在3.3版本：在'\u'和'\U'轉義序列已被添加。

因為3.5版本已過時，將在3.6版本中移除：由未知逃逸'\'和ASCII字母現在養不贊成警告，將在Python 3.6被禁止。

也可以看看
精通正則表達式
本書由傑弗里·弗里德爾正則表達式，由O'Reilly出版。該書的第二版不再涵蓋Python的所有，但第一版涵蓋了非常詳細編寫好的正則表達式模式。

 

模塊內容

模塊定義了幾個函數、 常量和一個異常。某些函數是編譯正則表達式全特性方法的簡化版本。大多數復雜應用程序總是使用已編譯的形式。

re.compile(pattern, flags=0)

將正則表達式模式編譯成一個正則表達式對象，匹配時可以調用它的 match() 和 search() 方法，如下所述。

可以通過指定flags 值修改表達式的行為。值可以是任何以下變量， 組合使用 OR ( | 運算符).

The sequence

prog = re.compile(pattern) result = prog.match(string) 

等同於

result = re.match(pattern, string) 

但表達式在單個程序中多次使用時， 使用re.compile() 和保存生成的正則表達式對象重用效率更高。

re.search(pattern, string, flags=0)

通過掃描字符串尋找那里的正則表達式的第一個位置模式產生匹配，並返回相應的匹配對象。返回None如果字符串中沒有位置的模式相匹配; 注意，這是從字符串中的某個時刻找到一個零長度的比賽不同。

re.match(pattern, string, flags=0)

如果在開始的零個或多個字符的字符串匹配正則表達式模式，返回相應的匹配對象。返回None如果字符串不匹配模式; 注意，這是從零長度匹配不同。

需要注意的是，即使在MULTILINE模式下，re.match()將只匹配於字符串的開頭，而不是在每一行的開頭。

If you want to locate a match anywhere in string, use search() instead (see also search() vs. match()).

re.fullmatch(pattern, string, flags=0)

如果整個字符串匹配正則表達式模式，返回相應的匹配對象。返回None如果字符串不匹配模式; 注意，這是從零長度匹配不同。

在新版本3.4。

re.split(pattern, string, maxsplit=0, flags=0)

分割字符串用的發生模式。如果捕獲括號中所用圖案，然后在圖案所有組的文本也被返回作為結果列表的一部分。如果maxsplit非零，至多maxsplit分裂發生，並且該串的剩余部分作為返回列表的最后一個元件。

>>> re.split('\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split('(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split('\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']

 如果在分離器捕獲組和它在字符串的開頭相匹配，則結果將與空字符串啟動。這同樣適用於字符串的端：

>>>

>>> re.split('(\W+)', '...words, words...')
['', '...', 'words', ', ', 'words', '...', '']

 這樣，分離器組件總是在結果列表中的相同相對索引找到。

Note

注意

split()目前並不在一個空的模式匹配拆分的字符串。例如：

>>>

>>> re.split('x*', 'axbc')
['a', 'bc']

 

在3.1版本的變化：增加了可選的標志參數。

改變在3.5版本中：分割上可以匹配一個空字符串現在提出一個警告的模式。現在的模式，只能匹配空字符串被拒絕。

>>>

>>> re.split("^$", "foo\n\nbar\n", flags=re.M)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  ...
ValueError: split() requires a non-empty pattern match.

 

在3.1版本的變化：增加了可選的標志參數。

改變在3.5版本中：分割上可以匹配一個空字符串現在提出一個警告的模式。現在的模式，只能匹配空字符串被拒絕。

re.findall(pattern, string, flags=0)

Return all non-overlapping matches of pattern in string, as a list of strings. The string是從左到右掃描的，所以匹配的內容是按照該順序來的If one or more groups are present in the pattern, return a list of groups; this will be a list of tuples if the pattern has more than one group. Return all non-overlapping matches of pattern in string, as a list of strings. The string是從左到右掃描的，所以匹配的內容是按照該順序來的If one or more groups are present in the pattern, return a list of groups; this will be a list of tuples if the pattern has more than one group. Empty matches are included in the result unless they touch the beginning of another match.

re.finditer(pattern, string, flags=0)

返回一個迭代器產生的匹配對象，在為RE的所有非重疊的匹配模式的字符串。該字符串進行掃描左到右，而匹配的中發現的順序返回。空場比賽都包括在結果，除非他們碰另一場比賽的開始。

re.sub(pattern, repl, string, count=0, flags=0)

返回由替換最左邊的非重疊事件中獲得的字符串模式在字符串的置換REPL。如果未找到模式，串原樣返回。REPL可以是一個字符串或函數; 如果它是一個字符串，任何反斜杠在它被處理。即，\n被轉換為單一的換行符，\r被轉換成一個回車，等等。未知的轉義如\&被單獨留在家中。反向引用，如\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是一個函數，它被稱為為每個非重疊出現的格局。該函數有一個匹配的對象參數，返回替換字符串。例如：

>>>

>>> 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'

 

該圖案可以是字符串或RE對象。

可選參數計數是要被替換的模式出現的最大數量; 計數必須是一個非負整數。如果省略或為零，所有出現將被替換。該模式匹配空更換，只有當不相鄰的上一個比賽，所以回報。sub('x*', '-','abc')'-a-b-c-'

在字符串類型的REPL參數，除了上述的字符轉義和反向引用，\g<name>將使用指定的組相匹配的子字符串name，由定義的(?P<name>...)語法。\g<number>使用相應的組號; \g<2>因此等效於\2，但不是在更換諸如模棱兩可\g<2>0。\20將被解釋為對組20中的引用，而不是對第2組的基准后跟文字字符'0'。反向引用\g<0>整個字符串替代由RE相匹配。

在3.1版本的變化：增加了可選的標志參數。

在3.5版本中改為：無與倫比的群體被替換為空字符串。

因為3.5版本已過時，將在3.6版本中刪除：未知逃逸包括'\'與ASCII字母現在養不贊成警告，將在Python 3.6被禁止。

re.subn(pattern, repl, string, count=0, flags=0)

執行相同的操作sub()，但返回的元組。(new_string, number_of_subs_made)

在3.1版本的變化：增加了可選的標志參數。

在3.5版本中改為：無與倫比的群體被替換為空字符串。

re.escape(string)

逃避所有的模式，除了ASCII字母，數字和字符'_'。如果你想匹配，可能有正則表達式元字符在它的任意文字字符串，這非常有用。

在3.3版本中更改：該'_'字符不再逃跑。

re.purge()

清除正則表達式緩存。

exception re.error(msg, pattern=None, pos=None)

這里的時候，一個字符串傳遞的功能之一提出的例外是不是一個有效的正則表達式（例如，它可能包含括號不匹配），或在編譯或匹配時發生其他一些錯誤。如果一個字符串包含敵不過一個模式，是永遠不會出錯。錯誤實例具有以下附加屬性：

msg

未格式化的錯誤消息。

pattern

正則表達式模式。

pos

指數模式，其中編譯失敗。

lineno

相對於線路POS。

colno

相應於列POS。

在3.5版本中變化：增加了額外的屬性。

6.2.3. 正則表達式對象

已編譯的正則表達式對象支持下列方法和屬性︰

regex.search(string[, pos[, endpos]])

掃描string 尋找正則表達式產生匹配后的第一個位置 , 然后返回一個相對應的 match object.Return None if no position in the string matches the pattern; note that this is different from finding a zero-length match at some point in the string.

可選的第二個參數 pos 給索引在字符串中搜索在哪里開始;它默認為 0。This is not completely equivalent to slicing the string; the '^' pattern character matches at the real beginning of the string and at positions just after a newline, but not necessarily at the index where the search is to start.

可選參數endpos限制字符串將在多大程度上被搜索; 將它作為字符串是否endpos字符長，所以只能從人物POS機，以將搜索匹配。endpos - 1如果endpos低於POS，不匹配會被發現; 否則，如果RX是一個正則表達式編譯對象，就等於。rx.search(string, 0, 50)rx.search(string[:50], 0)

>>>

>>> pattern = re.compile("d")
>>> pattern.search("dog")     # Match at index 0
<_sre.SRE_Match object; span=(0, 1), match='d'>
>>> pattern.search("dog", 1)  # No match; search doesn't include the "d"

regex.match(string[, pos[, endpos]])

I

如果在零個或多個字符開頭的字符串匹配這個正則表達式，返回相應的匹配對象。如果返回 None，則該字符串不匹配模式;注意這不同於一個零字節長度的匹配。

可選的POS和endpos參數的含義與對於相同的search()方法。

>>>

>>> pattern = re.compile("o")
>>> pattern.match("dog")      # 沒有匹配的“O”是不是在“狗”的開始。
>>> pattern.match("dog", 1)   # 匹配為“O”是“狗”的第2個字符。
<_sre.SRE_Match object; span=(1, 2), match='o'>

如果您想要的任何地方找到一個匹配的字符串，用search()代替， use search() instead (see also search() vs. match()).

regex.fullmatch(string[, pos[, endpos]])

如果整個字符串這個正則表達式匹配，返回相應的匹配對象。返回None如果字符串不匹配模式; 注意，這是從零長度匹配不同。

可選的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.
<_sre.SRE_Match object; span=(1, 3), match='og'>

New in version 3.4.

regex.split(string, maxsplit=0)

相同的split()功能，采用編圖案。

regex.findall(string[, pos[, endpos]])

類似於 findall() 的功能，使用已編譯的模版，但也接受可選的 pos 和 endpos 參數限制搜索區域像 match （）。

regex.finditer(string[, pos[, endpos]])

類似於 findall() 的功能，使用已編譯的模版，但也接受可選的 pos 和 endpos 參數像 match （）限制搜索區域。

regex.sub(repl, string, count=0)

相同的sub()功能，采用編圖案。

regex.subn(repl, string, count=0)

相同的subn()功能，采用編圖案。

regex.flags

T正則表達式匹配標志。這是提供給標志的組合compile()，任何(?...)在圖案內聯的標志，並且如隱標志UNICODE如果該圖案是Unicode字符串。

regex.groups

在圖案捕獲基團的數目。

regex.groupindex

對應的字典定義為任何符號的組名(?P<id>)，以組號碼。如果沒有符號組分別在模式中使用的字典是空的。

regex.pattern

該模式字符串從中RE對象被編譯。

Match 對象

Match對象總是有一個布爾值True。由於match()與search()返回None時沒有匹配，您可以測試是否有一個簡單的比賽if語句：

match = re.search(pattern, string) 
if match:
 process(match)

 

Match 對象支持下列方法和屬性︰

match.expand（模板）

返回由該模板串做反斜杠替換獲得的字符串模板，由做sub()方法。逃逸如\n被轉換成相應的字符，數字反向引用（\1，\2）並命名為反向引用（\g<1>，\g<name>）是由相應的組的內容替換。

在3.5版本中改為：無與倫比的群體被替換為空字符串。

正則表達式實例

Checking for a Pair

在這個例子中，我們將使用下面的輔助函數來顯示匹配的對象多了幾分優雅：

def displaymatch(match):
    if match is None:
        return None
    return '<Match: %r, groups=%r>' % (match.group(), match.groups())

 

假設你正在編寫一個球員的手表示為5個字符的字符串代表一個卡的每個字符撲克節目，“一”的王牌，“K”為王，“Q”為皇后，“J”的插孔， “T”為10，“2”至“9”表示與該值的卡。

要查看是否給定的字符串是一個有效的手，我們可以做到以下幾點：

>>>

>>> valid = re.compile(r"^[a2-9tjqk]{5}$")
>>> displaymatch(valid.match("akt5q"))  # Valid.
"<Match: 'akt5q', groups=()>"
>>> displaymatch(valid.match("akt5e"))  # Invalid.
>>> displaymatch(valid.match("akt"))    # Invalid.
>>> displaymatch(valid.match("727ak"))  # Valid.
"<Match: '727ak', groups=()>"

這最后一手，"727ak"載一對，兩個同樣看重卡。 要使用正則表達式匹配這一點，我們可以使用反向引用這樣：

>>>

>>> pair = re.compile(r".*(.).*\1")
>>> displaymatch(pair.match("717ak"))     # Pair of 7s.
"<Match: '717', groups=('7',)>"
>>> displaymatch(pair.match("718ak"))     # No pairs.
>>> displaymatch(pair.match("354aa"))     # Pair of aces.
"<Match: '354aa', groups=('a',)>"

要找出對包括什么牌，我們可以用 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'

6.2.5.2. Simulating scanf()

Python中目前沒有一個相當於scanf()。正則表達式一般都比較強大，雖也更詳細，比scanf()格式字符串。下表提供的一些或多或少等價映射scanf()格式標記和正則表達式。

scanf() Token	Regular Expression
%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]+

提取像一個字符串的文件名和號碼

/usr/sbin/sendmail - 0 errors, 4 warnings

你可以使用一個scanf()類似的格式

%s - %d errors, %d warnings

等效正則表達式會

(\S+) - (\d+) errors, (\d+) warnings

 

search() vs. match()

Python 提供基於正則表達式兩個不同的原語操作re.match()僅在字符串的開頭進行匹配檢查，而re.search()進行匹配的字符串中的任何檢查（這是Perl並默認情況下）。

例如：

>>>

>>> re.match("c", "abcdef")    # No match
>>> re.search("c", "abcdef")   # Match
<_sre.SRE_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
<_sre.SRE_Match object; span=(0, 1), match='a'>

但是請注意，在MULTILINE模式match()僅在字符串的開頭相匹配，而使用search()帶開始正則表達式'^'匹配在每個行的開始。

>>>

>>> re.match('X', 'A\nB\nX', re.MULTILINE)  # No match
>>> re.search('^X', 'A\nB\nX', re.MULTILINE)  # Match
<_sre.SRE_Match object; span=(4, 5), match='X'>

Making a Phonebook通訊錄

split()將一個字符串復制到傳遞模式分隔列表。該方法是非常寶貴的，用於將文本數據轉換為可以容易地讀取和Python的改性如下面的示例，創建一個電話簿證明的數據結構。

首先，這里是輸入。通常，它可能來自一個文件，這里我們使用三引號字符串語法：

>>>

>>> 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']

最后，拆每個條目與姓，名，電話號碼和地址的列表。我們使用maxsplit的參數，split()因為地址有空格，我們的分裂模式，在其中：

>>>

>>> [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']]

 

The :? pattern matches the colon after the last name, so that it does not occur in the result list. With a maxsplit of 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']]

Text Munging文字改寫

sub()替換字符串或函數的結果的圖形的每一個發生。這個例子演示了使用sub()帶有功能為“munge”的文字，或在隨機除了第一個和最后一個字符一個句子中每個單詞的所有字符的順序：

>>>

>>> 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()匹配所有的模式的出現，不僅是第一個search()做。例如，如果一個人是一個作家，想找到所有的副詞的一些文字，他或她可能使用findall()的方式如下：

>>>

>>> text = "He was carefully disguised but captured quickly by police."
>>> re.findall(r"\w+ly", text)
['carefully', 'quickly']

 

找到所有的副詞及其位置

如果想了解比匹配的文本模式的所有匹配的更多信息，finditer()因為它提供了非常有用的匹配對象，而不是字符串。 與繼續前面的例子，如果一個是誰想要找到所有的副詞的作家和他們的立場的一些文字，他或她會用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: carefully
40-47: quickly

raw字符串表示

原始字符串符號（r"text"）保持正則表達式理智。 沒有它，每一個反斜杠（'\'）在正則表達式必須與另一個逃跑呢前綴。 例如，以下兩個行代碼在功能上是相同的：

>>>

>>> re.match(r"\W(.)\1\W", " ff ")
<_sre.SRE_Match object; span=(0, 4), match=' ff '>
>>> re.match("\\W(.)\\1\\W", " ff ")
<_sre.SRE_Match object; span=(0, 4), match=' ff '>

當一個人想匹配一個反斜杠，它必須在正則表達式進行轉義。隨着原始字符串符號，這意味着r"\\"。如果沒有原始字符串符號，你必須使用"\\\\"，使得代碼功能相同下面幾行：

>>>

>>> re.match(r"\\", r"\\")
<_sre.SRE_Match object; span=(0, 1), match='\\'>
>>> re.match("\\\\", r"\\")
<_sre.SRE_Match object; span=(0, 1), match='\\'>

 

編寫一個標記

一個標記生成器或掃描儀分析字符串進行分類字符組。這是寫一個編譯器或解釋有益的第一步。

文本類別與正則表達式指定。該技術是將這些組合成一個單一的主正則表達式和遍歷連續匹配：

import collections
import re

Token = collections.namedtuple('Token', ['typ', '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>%s)' % pair for pair in token_specification)
    line_num = 1
    line_start = 0
    for mo in re.finditer(tok_regex, code):
        kind = mo.lastgroup
        value = mo.group(kind)
        if kind == 'NEWLINE':
            line_start = mo.end()
            line_num += 1
        elif kind == 'SKIP':
            pass
        elif kind == 'MISMATCH':
            raise RuntimeError('%r unexpected on line %d' % (value, line_num))
        else:
            if kind == 'ID' and value in keywords:
                kind = value
            column = mo.start() - line_start
            yield Token(kind, value, line_num, column)

statements = '''
    IF quantity THEN
        total := total + price * quantity;
        tax := price * 0.05;
    ENDIF;
'''

for token in tokenize(statements):
    print(token)

 

標記生成器產生以下的輸出：

Token(typ='IF', value='IF', line=2, column=4)
Token(typ='ID', value='quantity', line=2, column=7)
Token(typ='THEN', value='THEN', line=2, column=16)
Token(typ='ID', value='total', line=3, column=8)
Token(typ='ASSIGN', value=':=', line=3, column=14)
Token(typ='ID', value='total', line=3, column=17)
Token(typ='OP', value='+', line=3, column=23)
Token(typ='ID', value='price', line=3, column=25)
Token(typ='OP', value='*', line=3, column=31)
Token(typ='ID', value='quantity', line=3, column=33)
Token(typ='END', value=';', line=3, column=41)
Token(typ='ID', value='tax', line=4, column=8)
Token(typ='ASSIGN', value=':=', line=4, column=12)
Token(typ='ID', value='price', line=4, column=15)
Token(typ='OP', value='*', line=4, column=21)
Token(typ='NUMBER', value='0.05', line=4, column=23)
Token(typ='END', value=';', line=4, column=27)
Token(typ='ENDIF', value='ENDIF', line=5, column=4)
Token(typ='END', value=';', line=5, column=9)

 

re常用正則表達式符號

'.'     默認匹配除\n之外的任意一個字符，若指定flag DOTALL,則匹配任意字符，包括換行
'^'     匹配字符開頭，若指定flags MULTILINE,這種也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)
'$'     匹配字符結尾，或e.search("foo$","bfoo\nsdfsf",flags=re.MULTILINE).group()也可以
'*'     匹配*號前的字符0次或多次，re.findall("ab*","cabb3abcbbac")  結果為['abb', 'ab', 'a']
'+'     匹配前一個字符1次或多次，re.findall("ab+","ab+cd+abb+bba") 結果['ab', 'abb']
'?'     匹配前一個字符1次或0次
'{m}'   匹配前一個字符m次
'{n,m}' 匹配前一個字符n到m次，re.findall("ab{1,3}","abb abc abbcbbb") 結果'abb', 'ab', 'abb']
'|'     匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group() 結果'ABC'
'(...)' 分組匹配，re.search("(abc){2}a(123|456)c", "abcabca456c").group() 結果 abcabca456c
 
 
'\A'    只從字符開頭匹配，re.search("\Aabc","alexabc") 是匹配不到的
'\Z'    匹配字符結尾，同$
'\d'    匹配數字0-9
'\D'    匹配非數字
'\w'    匹配[A-Za-z0-9]
'\W'    匹配非[A-Za-z0-9]
's'     匹配空白字符、\t、\n、\r , re.search("\s+","ab\tc1\n3").group() 結果 '\t'
 
'(?P<name>...)' 分組匹配 re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict("city") 結果{'province': '3714', 'city': '81', 'birthday': '1993'}

 最常用的匹配語法

re.match 從頭開始匹配
re.search 匹配包含
re.findall 把所有匹配到的字符放到以列表中的元素返回
re.splitall 以匹配到的字符當做列表分隔符
re.sub      匹配字符並替換 

 match

# match，從起始位置開始匹配，匹配成功返回一個對象，未匹配成功返回None
 
 
 match(pattern, string, flags=0)
 # pattern： 正則模型
 # string ： 要匹配的字符串
 # falgs  ： 匹配模式
     X  VERBOSE     Ignore whitespace and comments for nicer looking RE's.
     I  IGNORECASE  Perform case-insensitive matching.
     M  MULTILINE   "^" matches the beginning of lines (after a newline)
                    as well as the string.
                    "$" matches the end of lines (before a newline) as well
                    as the end of the string.
     S  DOTALL      "." matches any character at all, including the newline.
 
     A  ASCII       For string patterns, make \w, \W, \b, \B, \d, \D
                    match the corresponding ASCII character categories
                    (rather than the whole Unicode categories, which is the
                    default).
                    For bytes patterns, this flag is the only available
                    behaviour and needn't be specified.
      
     L  LOCALE      Make \w, \W, \b, \B, dependent on the current locale.
     U  UNICODE     For compatibility only. Ignored for string patterns (it
                    is the default), and forbidden for bytes patterns.

 實例：

# 無分組
        r = re.match("h\w+", origin)
        print(r.group())     # 獲取匹配到的所有結果
        print(r.groups())    # 獲取模型中匹配到的分組結果
        print(r.groupdict()) # 獲取模型中匹配到的分組結果

        # 有分組

        # 為何要有分組？提取匹配成功的指定內容（先匹配成功全部正則，再匹配成功的局部內容提取出來）

        r = re.match("h(\w+).*(?P<name>\d)$", origin)
        print(r.group())     # 獲取匹配到的所有結果
        print(r.groups())    # 獲取模型中匹配到的分組結果
        print(r.groupdict()) # 獲取模型中匹配到的分組中所有執行了key的組

Demo

 search

# search,瀏覽整個字符串去匹配第一個，未匹配成功返回None
# search(pattern, string, flags=0)

 實例：

# 無分組

        r = re.search("a\w+", origin)
        print(r.group())     # 獲取匹配到的所有結果
        print(r.groups())    # 獲取模型中匹配到的分組結果
        print(r.groupdict()) # 獲取模型中匹配到的分組結果

        # 有分組

        r = re.search("a(\w+).*(?P<name>\d)$", origin)
        print(r.group())     # 獲取匹配到的所有結果
        print(r.groups())    # 獲取模型中匹配到的分組結果
        print(r.groupdict()) # 獲取模型中匹配到的分組中所有執行了key的組

demo

import re obj = re.match('\d+', '123uuasf') if obj: print(obj.group())

a = '123abc456'
print(re.search('([0-9]*)([a-z]*)([0-9]*)',a).group())#123abc456
print(re.search('([0-9]*)([a-z]*)([0-9]*)',a).group(0))#123abc456
print(re.search('([0-9]*)([a-z]*)([0-9]*)',a).group(1))#123
print(re.search('([0-9]*)([a-z]*)([0-9]*)',a).group(2))#abc

import re obj = re.search('\d+', 'u123uu888asf') if obj: print(obj.group())

group和groups

a = "123abc456"
print re.search("([0-9]*)([a-z]*)([0-9]*)", a).group()

print re.search("([0-9]*)([a-z]*)([0-9]*)", a).group(0)
print re.search("([0-9]*)([a-z]*)([0-9]*)", a).group(1)
print re.search("([0-9]*)([a-z]*)([0-9]*)", a).group(2)

print re.search("([0-9]*)([a-z]*)([0-9]*)", a).groups()

 

findall

# findall，獲取非重復的匹配列表；如果有一個組則以列表形式返回，且每一個匹配均是字符串；如果模型中有多個組，則以列表形式返回，且每一個匹配均是元祖；
# 空的匹配也會包含在結果中
#findall(pattern, string, flags=0)

 實例：

# 無分組
        r = re.findall("a\w+",origin)
        print(r)

        # 有分組
        origin = "hello alex bcd abcd lge acd 19"
        r = re.findall("a((\w*)c)(d)", origin)
        print(r)

Demo

import re

obj = re.findall('\d+', 'fa123uu888asf')
print(obj)

 

sub

# sub，替換匹配成功的指定位置字符串
 
sub(pattern, repl, string, count=0, flags=0)
# pattern： 正則模型
# repl   ： 要替換的字符串或可執行對象
# string ： 要匹配的字符串
# count  ： 指定匹配個數
# flags  ： 匹配模式

 實例：

# 與分組無關

        origin = "hello alex bcd alex lge alex acd 19"
        r = re.sub("a\w+", "999", origin, 2)
        print(r)

根據指定匹配進行分組

content = "'1 - 2 * ((60-30+1*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2) )'"
new_content = re.split('\*', content)
# new_content = re.split('\*', content, 1)
print new_content

 2

content = "'1 - 2 * ((60-30+1*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2) )'"
new_content = re.split('[\+\-\*\/]+', content)
# new_content = re.split('\*', content, 1)
print new_content

 3

inpp = '1-2*((60-30 +(-40-5)*(9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2))'
inpp = re.sub('\s*','',inpp)
new_content = re.split('\(([\+\-\*\/]?\d+[\+\-\*\/]?\d+){1}\)', inpp, 1)
print new_content

 相比於str.split更加強大

實例：計算器源碼 

split

# split，根據正則匹配分割字符串
 
split(pattern, string, maxsplit=0, flags=0)
# pattern： 正則模型
# string ： 要匹配的字符串
# maxsplit：指定分割個數
# flags  ： 匹配模式

 實例：

# 無分組
        origin = "hello alex bcd alex lge alex acd 19"
        r = re.split("alex", origin, 1)
        print(r)

        # 有分組
        
        origin = "hello alex bcd alex lge alex acd 19"
        r1 = re.split("(alex)", origin, 1)
        print(r1)
        r2 = re.split("(al(ex))", origin, 1)
        print(r2)

Demo

 

IP：
^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$
手機號：
^1[3|4|5|8][0-9]\d{8}$
郵箱：
[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+

常用正則表達式

 

字符串模板匹配

re 模塊為高級字符串處理提供了正則表達式工具。對於復雜的匹配和操作，正則表達式提供了簡潔、優化的解決方案：

>>> import re
>>> re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
['foot', 'fell', 'fastest']
>>> re.sub(r'(\b[a-z]+) \1', r'\1', 'cat in the the hat')
'cat in the hat'

 當只需要簡單的功能時，最好使用字符串方法，因為它們更容易閱讀和調試：

>>> 'tea for too'.replace('too', 'two')
'tea for two'

 

數學

math模塊提供基於c庫函數的浮點運算.

>>> import math
>>> math.cos(math.pi / 4)
0.70710678118654757
>>> math.log(1024, 2)
10.0

 random 的模塊提供了進行隨機選擇的工具︰

>>> import random
>>> random.choice(['apple', 'pear', 'banana'])
'apple'
>>> random.sample(range(100), 10)   # sampling without replacement
[30, 83, 16, 4, 8, 81, 41, 50, 18, 33]
>>> random.random()    # random float
0.17970987693706186
>>> random.randrange(6)    # random integer chosen from range(6)
4

 statistics 模塊計算數值數據的基本統計特性 （均值、 中位數、 方差，等）。e :

>>> import statistics
>>> data = [2.75, 1.75, 1.25, 0.25, 0.5, 1.25, 3.5]
>>> statistics.mean(data)
1.6071428571428572
>>> statistics.median(data)
1.25
>>> statistics.variance(data)
1.3720238095238095