1、re.findall(pattern,string,flags=0) ——> list(列表)

列出字串中模式的所有匹配項，並作為一個列表返回。如果無匹配，則返回空列表！

與re.search()不一樣的地方：

• re.findall返回的是列表，re.search返回文字
• re.findall匹配多個值，re.search只要匹配到就返回，只匹配一個值

>>> import re
>>> re.findall(r"ab","abcaaaab")
['ab', 'ab']               #匹配的值作為一個列表範圍

2、re.compile(pattern,flags=0) ——> pattern object

根據包含正則表示式的字串建立模式物件，可以實現更有效率地匹配！用了re.compile以後，正則物件會得到保留，這樣在需要多次運用這個正則物件的時候，效率會有較大的提升

此外，re.cpmpile() 可以通過接受可選的屬性，常用來實現不同的特殊功能和語法變更。

2.1 例1：使用re.compile(pattern)對正則表示式進行編譯

>>> import re
>>> s=r"^010-\d{8}$"
>>> re.findall(s,"010-12345678")
['010-12345678']
>>> p_tel=re
 
.compile(s)                                            #對s這個正則表示式建立模式物件p_tel
>>> p_tel
<_sre.SRE_Pattern object at 0x7f3ab3776d78>
>>> p_tel.findall("010-12345678")           #經過compile轉換的正則表示式物件也能用於普通的re函式，跟上面的re.findall(s,"010-12345678")一樣的效果
['010-12345678']

2.2 使用re.compile(pattern)進行編譯,不區分大小寫

>>> import re
>>> s=r"hello"
>>> greeting=re.compile(s,re.I)    #re.I 屬性讓正則表示式忽略大小寫！
>>> greeting.findall("HELLO")
['HELLO']
>>> greeting.findall("hello")
['hello']
>>> greeting.findall("hEllo")
['hEllo']

2.3 為什麼正則匹配模式前面加 "r"

禁止轉義！反斜槓不會被任何特殊方式處理。

Python編譯器用‘\’（反斜槓）來表示字串常量中的轉義字元。

如果反斜槓後面跟著一串編譯器能夠識別的特殊字元，那麼整個轉義序列將被替換成對應的特殊字元（例如，‘\n’將被編譯器替換成換行符）

本質上來講，使用r，你在告訴編譯器完全不要去幹涉你的字串

例如：

>>> string='this is a\nnormal string'
>>> print string
this is a
normal string                   #不使用r,\n在字串中代表一個換行符
>>> rawstring=r'this is a\nnormal string'
>>> print rawstring
this is a\nnormal string           #使用r,\n在字串中就是\n

3、re.match(pattern, string, flags=0) ——> match object or None

在字串的開始位置匹配正則！如果無匹配，則返回 None 。

>>> import re
>>> s=r"abc"
>>> com=re.compile(s)
>>> com.match("abcdef")                          #abc在開始的位置，可以匹配
<_sre.SRE_Match object at 0x7f3ab3480cc8>
>>> print com.match("hhhabc")                    #abc不在開始的位置，不可以匹配
None

3.1 使用group()-返回匹配的資料

>>> import re
>>> s=r"abc"
>>> com=re.compile(s)
>>> com.match("abcddddd").group()   #使用group()返回匹配的物件
'abc'

4、re.search(pattern, string, flags=0) ——> match object or None

re.search函式會在字串內查詢模式匹配,只要找到第一個匹配然後返回，如果字串沒有匹配，則返回None

re.match與re.search的區別：re.match只匹配字串的開始，如果字串開始不符合正則表示式，則匹配失敗，函式返回None；而re.search匹配整個字串，直到找到一個匹配。

>>> import re
>>> s=r"abc"
>>> com=re.compile(s)
>>> com.search("abcdef")
<_sre.SRE_Match object at 0x7f3ab3480cc8>
>>> com.search("hhhabc")
<_sre.SRE_Match object at 0x7f3ab3480d30>         #與re.match的區別：無論在哪個位置都能匹配

4.1 使用group()-返回匹配的資料

>>> import re
>>> s=r"abc"
>>> com=re.compile(s)
>>> com.search("abcddd").group()             #使用group()返回匹配的物件
'abc'
>>> com.search("abcdddabc").group()          #只匹配一個
'abc'

4.2 關於group更多

返回匹配到的一個或者多個子組。如果是一個引數，那麼結果就是一個字串，如果是多個引數，那麼結果就是一個引數一個item的元組。

group1的預設值為0(將返回所有的匹配值).如果groupN引數為0，相對應的返回值就是全部匹配的字串，

如果group1的值是[1…99]範圍之內的,那麼將匹配對應括號組的字串。如果組號是負的或者比pattern中定義的組號大，那麼將丟擲IndexError異常。如果pattern沒有匹配到，但是group匹配到了，那麼group的值也為None。如果一個pattern可以匹配多個，那麼組對應的是樣式匹配的最後一個。另外，子組是根據括號從左向右來進行區分的。

>>> s=r"(\w+) (\w+)"
>>> com=re.compile(s)
>>> m=com.search("abc def,222")
>>> m.group()   #返回所有的匹配值
'abc def'
>>> m.group(0)    #返回所有的匹配值,預設是0
'abc def'
>>> m.group(1)    #如果group的值是[1…99]範圍之內的,那麼將匹配對應括號組的字串
'abc'
>>> m.group(2)
'def'
>>> m.group(1,2)     #如果是一個引數，那麼結果就是一個字串，如果是多個引數，那麼結果就是一個引數一個item的元組
('abc', 'def')
>>> m.group(3)
Traceback (most recent call last):                 
  File "<stdin>", line 1, in <module>
IndexError: no such group                       #如果組號是負的或者比pattern中定義的組號大，那麼將丟擲IndexError異常

還可以把使用別的變數值來代替預設的group(N)中的N，如下寫法：

>>> import re
>>> m=re.search(r"(?P<one>\w+) (?P<two>\w+)","abc def,222")   #?P<變數值>寫法
>>> m.group("one")
'abc'
>>> m.group("two")
'def'

4.3 關於MatchObject(匹配物件) 方法

re.match和re.search都是返回MatchObject，有如下方法

• group()： 返回被正則匹配的字串；
• start()： 返回匹配開始的位置；
• end()： 返回匹配結束的位置；
• span()： 返回一個元組包含匹配（開始，結束）的位置。

5、re.finditer(pattern,string,flags=0) ——> iterator

列出字串中模式的所有匹配項，並作為一個迭代器返回。

延伸下，什麼是iterator？轉載：https://www.liaoxuefeng.com

• 凡是可作用於for迴圈的物件都是Iterable型別；
• 凡是可作用於next()函式的物件都是Iterator型別，它們表示一個惰性計算的序列；
• 集合資料型別如list、dict、str等是Iterable但不是Iterator，不過可以通過iter()函式獲得一個Iterator物件。

Python的for迴圈本質上就是通過不斷呼叫next()函式實現的，例如：

for x in [1, 2, 3, 4, 5]:
    pass

# 首先獲得Iterator物件:
it = iter([1, 2, 3, 4, 5])
# 迴圈:
while True:
    try:
        # 獲得下一個值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出迴圈
        break

言歸正傳，舉例如下：

>>> import re
>>> s=r"\d+"
>>> com=re.compile(s)
>>> com.finditer("aa11bb22cc")
<callable-iterator object at 0x7f3ab3499cd0>
>>> it=com.finditer("aa11bb22cc")
>>> for i in it:
...     print i     #返回一個match物件
...     print i.group()   #返回匹配的資料
...
<_sre.SRE_Match object at 0x7f3ab3480d30>   
11
<_sre.SRE_Match object at 0x7f3ab3480cc8>
22

6、re.sub(pattern, repl, string, count=0, flags=0) ——> string

將字串中所有 pattern 的匹配項用 repl 替換！

>>> import re
>>> re.sub(r"abc","123","abcdefabc")
'123def123'

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

與sub()實現相同的替換作用，但是subn()返回一個元組，其中包含新字串和替換次數！

>>> import re
>>> re.subn(r"abc","123","abcdefabc")
('123def123', 2)

8、re.split(pattern, string, maxsplit=0, flags=0) ——> list

根據模式的匹配項來分割字串！

>>> import re
>>> re.split(r"\d+","aa11bb22cc")  #以正則表示式\d+為分割符
['aa', 'bb', 'cc']
>>> re.split(r"\d","aa11bb22cc")   #以正則表示式\d+為分割符
['aa', '', 'bb', '', 'cc']