正則表示式是用於字串搜尋、匹配、替換的常見方法，而它實際上就是一個特殊的字元序列，用來幫助你方便的檢查一個字串是否與某種模式匹配。 Python中re包是專門用來處理正則表示式的相關操作，我參考了一些資料整理了re包中所有的函式應用，僅供參考！

 說明：以下所有函式均是（均可）re.funcname()，也就是說正則表示式具有兩種程式設計手法，使用方式基本相同，但是函式引數略有不同，使用時注意就好！

• 方法1

  ​ re.function();

• 方法2

  ​ obj = re.compile();

  ​ obj.funcname();

compile()

  compile()函式根據一個模式字串和可選的標誌引數生成一個正則表示式物件

re.compile(pattern='regex_exp', flags=re.I)

• pattern : 一個字串形式的正則表示式
• flags : 可選，表示匹配模式，比如忽略大小寫，多行模式等，具體引數為：
  
  1. re.I 忽略大小寫
  2. re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依賴於當前環境
  3. re.M 多行模式
  4. re.S 即為 . 並且包括換行符在內的任意字元（. 不包括換行符）
  5. re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依賴於 Unicode 字元屬性資料庫
  6. re.X 為了增加可讀性，忽略空格和 # 後面的註釋

# match()函式嘗試從字串的起始位置匹配一個模式，如果不是起始位置匹配成功的話，match()就返回none

>>>import re


# 例項1
>>> pattern = re.compile(r'\d+')                    # 用於匹配至少一個數字
>>> m = pattern.match('one12twothree34four')        # 查詢頭部，沒有匹配
>>> print m
None

>>> 
 
m = pattern.match('one12twothree34four', 3, 10) # 從'1'的位置開始匹配，正好匹配

>>> print m                                         # 返回一個 Match 物件
<_sre.SRE_Match object at 0x10a42aac0>

# 用於獲得一個或多個分組匹配的字串，當要獲得整個匹配的子串時，可直接使用 group() 或 group(0)
>>> m.group(0)   # 可省略 0
'12'

# 用於獲取分組匹配的子串在整個字串中的起始位置（子串第一個字元的索引），引數預設值為 0
>>> m.start(0)   # 可省略 0
3

# 用於獲取分組匹配的子串在整個字串中的結束位置（子串最後一個字元的索引+1），引數預設值為 0
>>> m.end(0)     # 可省略 0
5

 # (start(group), end(group))
>>> m.span(0)    # 可省略 0
(3, 5)



# 例項2
# 該例子中正式引入分組概念，注意理解
>>> pattern = re.compile(r'([a-z]+) ([a-z]+)', re.I)
>>> m = pattern.match('Hello World Wide Web')

>>> m.group(0)                            # 返回匹配成功的整個子串
'Hello World'
>>> m.span(0)                             # 返回匹配成功的整個子串的索引
(0, 11)


>>> m.group(1)                            # 返回第一個分組匹配成功的子串
'Hello'
>>> m.span(1)                             # 返回第一個分組匹配成功的子串的索引
(0, 5)

>>> m.group(2)                            # 返回第二個分組匹配成功的子串
'World'
>>> m.span(2)                             # 返回第二個分組匹配成功的子串
(6, 11)

>>> m.groups()                            # 等價於 (m.group(1), m.group(2), ...)
('Hello', 'World')

match()

  如前所述，re.match()嘗試從字串的起始位置匹配一個模式，如果匹配成功則返回一個Match物件，反之返回none

import re
print(re.match('www', 'www.runoob.com').span())  # 在起始位置匹配  (0,3)
print(re.match('com', 'www.runoob.com'))         # 不在起始位置匹配 None

fullmatch()

  這個好理解，要求完全匹配

import re

s = '234d'
matched = re.fullmatch('\d+', s, 0)
if matched:
    print(matched.group())
else:
    print('not matched')

 # not matched

search()

  re.search 掃描整個字串並返回第一個成功的匹配(Match物件)，否則返回None

line = "Cats are smarter than dogs"
searchObj = re.search(r'(.*) are (.*?) .*', line, re.M | re.I)
# print(type(searchObj))  # Match物件
if searchObj:
    # 這是第二個提到分組的例子
    # 分組是對匹配結果的一個分組，體現在正則表示式的（）上，一個（）代表建立一個分組
    print("searchObj.group() : ", searchObj.group())
    print("searchObj.group(1) : ", searchObj.group(1))
    print("searchObj.group(2) : ", searchObj.group(2))
else:
    print("Nothing found!!")


# searchObj.group() :  Cats are smarter than dogs
# searchObj.group(1) :  Cats
# searchObj.group(2) :  smarter

sub()

  sub()函式用於字串替換，原型：re.sub(pattern, repl, string, count=0, flags=0),說明一下，count是指模式匹配後替換的最大次數，預設 0 表示替換所有的匹配；repl（replace）表示替換的字串，也可為一個函式。

# repl 作為一個字串
import re

num = "2018-08-17"
new_num = re.sub(r"\D", "", num, count=0)
print(new_num)

# 20180817

# repl作為一個函式 

# 將匹配的數字乘以 2
def double(matched):
    value = int(matched.group('value'))
    return str(value * 2)

s = 'A23G4HFD567'
new_str = re.sub(r'(?P<value>\d+)', double, s)
print(new_str)
# A46G8HFD1134

subn

subn()函式基本同sub()函式，唯一不同點是subn()還會返回替代次數，例子如下：

s = 'A23G4HFD567'
n = re.subn(r'(?P<value>\d+)', '', s)
print(n)

# ('AGHFD', 3) 返回一個tuple。根據具體情境選用sub() or subn()

findall()

  在字串中找到正則表示式所匹配的所有子串，並返回一個列表，如果沒有找到匹配的，則返回空列表，而上面提到的match()、search()函式匹配一次且返回物件為Match或None.

s = 'A23G4HFD567'
# flags其實和上面一樣，不過這裡我用的是 int型別數來表示
# 具體對應關係，我...也記不住！
print(re.findall(r'\d+', s, flags=0))

# ['23', '4', '567']

finditer()

  和 findall 類似，在字串中找到正則表示式所匹配的所有子串，並把它們作為一個迭代器返回，具有更好的效能。

s = 'A23G4HFD567'
iter = re.finditer(r'\d+', s, flags=0)

for match in iter:
    print(match.group())

# 23
# 4
# 567

split()

  split 方法按照能夠匹配的子串將字串分割後返回列表，在很多其他語言也有這個函式，如C#，java。在函式中，maxsplit表示分隔次數，maxsplit=1 分隔一次，預設為 0，不限制次數。

import re
s = 'A23G4HFD567N'
res = re.split(r'\d+', s, maxsplit=2, flags=0)
print(res)

# ['A', 'G', 'HFD567N']

escape()

  可以對字串中所有可能被解釋為正則運算子的字元進行轉義的應用函式。如果字串很長且包含很多特殊技字元，而你又不想輸入一大堆反斜槓，例子：

s = 'A23G4HFD567N'

# Escape all the characters in pattern except ASCII letters, numbers and '_'.
# re.escape('www.python.org')  # 返回值 str

res = re.findall(re.escape('*+.py'), "jw.pyji w.py.f")
print(res)

# ['w.py', 'w.py']

purge()

  無參函式，用於清空快取中的正則表示式，用於末尾，就好比其他語言中的close()、flush()，用來做相應的收尾工作。

Match Object

  Match物件在前面的例子中已經有例子了，提出來主要是為了更全面、更清晰。re.match()和re.search()函式如果匹配成功都會返回一個match物件，這裡主要看看Match物件的一些方法應用。

import re

s = '234d567gg'
matched = re.search(r'(\d+)\w(\d+)', s, flags=0)

if matched:
    print(matched.groups())  # ('234', '567')

    print(matched.group())  # 234d567
    print(matched.group(1))  # 234
    print(matched.group(2))  # 567

    print(matched.span())  # (0,7)
    print(matched.start(0))  # 0
    print(matched.end(0))  # 7

    print(matched.expand(r'\2 \1'))  # 567 234 type is str
    # 注意這下面的用法 python3.6及以上才有的
    print(matched[0])  # 234d567
    print(matched[1])  # 234
    print(matched[2])  # 567

    # 屬性
    print(matched.pos)  # 0
    print(matched.endpos)  # 7
    print(matched.string)  # 234d567
    print(matched.re)  # 返回的是regular expression object
    print(matched.lastindex)  # 2,這個2指的是 matched[i]
    print(matched.lastgroup)  # None