以下示例所使用 python 版本为： 3.7

python 提供 re 模块，来满足正则表达式的使用。在开始介绍 re 模块之前，首先说明一下两个小内容：

1. 转义字符 \

转义字符作用是使得字符失去原本的意思，去表示另外一个作用。例如字符 d 表示一个普通的字符 d， 加 \ 转义后 \d 表示数字，字符 s 经转义后，\s 表示空白字符。

如果要匹配转义符号 \ 本身，则需要表达为 \\ 。而在编程语言中要表达两个转义符号 \\，则需要对每个转义符号进行转义，即形式为 \\\\，需要四个转义符号才能完成用于匹配一个转义符号 \ 的正则表达式。

为了减弱转义字符使用上的麻烦，能够将使用者的注意力集中在正则表达式的编写上，这里推荐所有的正则表达式开头使用 r 字符开头，表示正则内容作为原始字符串输入到 re 模块的使用中。即编程环境中 r'\\' 直接作为正则表达式使用，来完成对字符 \ 的匹配。

示例：

import re

reg = r'\\'
str = '\\'    #转义符号，str实际值为\

if re.match(reg,str):
    print('match {}'.format(str))
------------------------
运行结果：
match \

1. Pattern、Match对象

在re模块中使用正则表达式完成字符串处理有两种方式：

• 在 python 中可以直接使用 re 模块生成 Match 对象，完成字符串处理。
  示例：

import re

reg = r'abc'
str = 'abc'

mattern = re.match(reg,str)
print(mattern .group())
------------------------
运行结果：
abc

• 使用 re 模块生成 Pattern 对象，然后使用 Pattern 对象生成 Match 对象，完成字符串处理。
  示例：

import re

reg = r'abc'
str = 'abc'

pattern = re.compile(reg)
match = pattern.match(str)
print(match.group())
------------------------
运行结果：
abc

这两种方式执行效果基本一样，观察 re 模块源代码：

模块： \Python37\Lib\re.py

# --------------------------------------------------------------------
# public interface

def match(pattern, string, flags=0):          #第一种方式
    """Try to apply the pattern at the start of the string, returning
    a Match object, or None if no match was found."""
    return _compile(pattern, flags).match(string)

def compile(pattern, flags=0):                #第二种方式
    "Compile a regular expression pattern, returning a Pattern object."
    return _compile(pattern, flags)

# --------------------------------------------------------------------
# internals

_cache = {}  # ordered!

_MAXCACHE = 512
def _compile(pattern, flags):
    # internal: compile pattern
    if isinstance(flags, RegexFlag):
        flags = flags.value
    try:
        return _cache[type(pattern), pattern, flags]         #从缓存字典中查询
    except KeyError:
        pass
    if isinstance(pattern, Pattern):
        if flags:
            raise ValueError(
                "cannot process flags argument with a compiled pattern")
        return pattern
    if not sre_compile.isstring(pattern):
        raise TypeError("first argument must be string or compiled pattern")
    p = sre_compile.compile(pattern, flags)
    if not (flags & DEBUG):
        if len(_cache) >= _MAXCACHE:
            # Drop the oldest item
            try:
                del _cache[next(iter(_cache))]
            except (StopIteration, RuntimeError, KeyError):
                pass
        _cache[type(pattern), pattern, flags] = p         #添加到缓存字典中
    return p

观察源码可知， re 模块提供的 compile 函数和 match 函数，都需要先通过 _compile(pattern, flags) 函数生成一个 Pattern 对象，区别在于 match 函数直接在生成 Pattern 对象后调用了 match 函数。
观察 _compile(pattern, flags) 函数体可知，首先会从缓存字典中查询是否已经存在 Pattern 对象，存在则返回，不存在则生成该 Pattern 对象，添加到缓存字典后返回。

由此可知，直接使用 re 模块的 match 函数来生成 Match 对象，和使用 re 模块的 compile 函数生成 Pattern 对象，然后再利用 match 函数生成 Match 对象完成字符串处理，这两种方式都是首先调用 _compile(pattern, flags) 函数生成一个Pattern对象，然后再使用该 Pattern 对象的 match 函数生成 Match 对象。

所以两种方式基本相同，区别只在于当 Pattern 对象多次使用时，第一种方式会存在多次查询缓存操作，且缓存字典容量是有限制的，超出后会删除最先添加的 Pattern 对象，所以推荐所有的正则中都使用构造的 Pattern 对象来完成字符串处理。

下面列出 Pattern 对象中使用到的函数：

• match 函数

match 函数返回指定范围内，从指定起始位置开始匹配到的对象。使用过程中只有三点需要注意一下：
1. 可以指定匹配的范围，默认范围是 0 到 len(str)
2. 匹配是从指定的起始位置开始的，也就是固定了开始位置
3. 匹配成功则返回，也就是只返回一个匹配对象

示例：

import re

reg = r'\d'
pattern = re.compile(reg)

str1 = 'a1b2c3'

match1 = pattern.match(str1)
match2 = pattern.match(str1,1)

print('match1 = {}'.format(match1))
if match1:
    print('match1 matched = {}'.format(match1.group()))

print('match2 = {}'.format(match2))
if match2:
    print('match2 matched = {}'.format(match2.group()))
运行结果：
match1 = None
match2 = <re.Match object; span=(1, 2), match='1'>
match2 matched = 1

• search 函数

search 函数返回指定范围内，从任意起始位置开始匹配到的对象。使用过程中只有三点需要注意一下：
1. 可以指定匹配的范围，默认范围是 0 到 len(str)
2. 匹配是从范围内的任意起始位置开始的，也就是不固定开始位置
3. 匹配成功则返回，也就是只返回一个匹配对象

示例：

import re

reg = r'\d'
pattern = re.compile(reg)

str1 = 'a1b2c3'

match1 = pattern.search(str1)

print('match1 = {}'.format(match1))
if match1:
    print('match1 matched = {}'.format(match1.group()))
运行结果：
match1 = <re.Match object; span=(1, 2), match='1'>
match1 matched = 1

比较 match 和 search 函数的使用：两个函数都是一次匹配，得到结果则返回 (None 或 Match 对象)，区别在于 match 函数从指定的起始位置开始匹配，search 函数从指定范围内的任意位置开始。

• findall 函数

findall 函数返回指定范围内，所有匹配结果构成的列表。使用过程中只有两点需要注意一下：
1. 可以指定匹配的范围，默认范围是 0 到 len(str)
2. 返回的是一个列表，元素是 str 对象，而非 Match 对象

示例：

import re

reg = r'\d'
pattern = re.compile(reg)

str1 = 'a1b2c3'

match1 = pattern.findall(str1)

print('match1 = {}'.format(match1))
for element in match1:
    print('element = {}'.format(element))
运行结果：
match1 = ['1', '2', '3']
element = 1
element = 2
element = 3

• finditer 函数

finditer 函数返回指定范围内，所有匹配对象构成的迭代器。使用过程中只有两点需要注意一下：
1. 可以指定匹配的范围，默认范围是 0 到 len(str)
2. 返回的是一个迭代器，元素是 Match 对象

示例：

import re

reg = r'\d'
pattern = re.compile(reg)

str1 = 'a1b2c3'

match1 = pattern.finditer(str1)

print('match1 = {}'.format(match1))
for element in match1:
    print('element = {}'.format(element.group()))
运行结果：
match1 = <callable_iterator object at 0x0000000002CA0550>
element = 1
element = 2
element = 3

比较 findall 和 finditer 函数的使用：两个函数都是获取所有匹配内容，区别在于 findall 函数返回的是一个列表，元素类型是 str，finditer 函数返回的是一个迭代器，元素类型是 Match 。

• split 函数

split 函数返回根据指定分割次数，分割后得到的结果列表。使用过程中只有两点需要注意一下：
1. 可以指定分割次数，默认值 0 表示全分割
2. 返回的是一个列表，元素是 str 对象

示例：

import re

reg = r'\d'
pattern = re.compile(reg)

str1 = 'a1b2c3'

match1 = pattern.split(str1)

print('match1 = {}'.format(match1))
for element in match1:
    print('element = {}'.format(element))
运行结果：
match1 = ['a', 'b', 'c', '']
element = a
element = b
element = c
element = 

• sub 函数

sub 函数根据指定替换规则和替换次数，返回替换后内容。使用过程中只有三点需要注意一下：
1. 可以指定替换次数，默认值 0 表示全替换
2. 返回的是一个 str 对象
3. 指定的替换规则可以是 str 对象，可以是一个函数，也可以是分组的引用

示例：

import re

def fun(match):
    return match.group()[::-1]

reg = r'(\d)(\d)'
pattern = re.compile(reg)

str1 = 'a12b34c56'

match1 = pattern.sub('__',str1)
match2 = pattern.sub(fun,str1)
match3 = pattern.sub(r'\2\1',str1)

print('match1 = {}'.format(match1))
print('match2 = {}'.format(match2))
print('match3 = {}'.format(match3))
运行结果：
match1 = a__b__c__
match2 = a21b43c65
match3 = a21b43c65

• subn 函数

subn 函数根据指定替换规则和替换次数，返回替换后内容和替换次数构成的元组。使用过程中只有三点需要注意一下：
1. 可以指定替换次数，默认值 0 表示全替换
2. 返回的是一个 str 对象和 int 对象构成的元组
3. 指定的替换规则可以是 str 对象，可以是一个函数，也可以是分组的引用

示例：

import re

def fun(match):
    return match.group()[::-1]

reg = r'(\d)(\d)'
pattern = re.compile(reg)

str1 = 'a12b34c56'

match1 = pattern.subn('__',str1,1)
match2 = pattern.subn('__',str1,2)


print('match1 = {}'.format(match1))
print('match2 = {}'.format(match2))
运行结果：
match1 = ('a__b34c56', 1)
match2 = ('a__b__c56', 2)

比较 sub 和 subn 函数的使用：两个函数都是替换匹配内容，区别在于 sub 函数返回的是一个 str 对象，subn 函数返回的是替换后 str 对象和替换次数 int 对象构成的元组。

下面列出 Match 对象中常到的函数：

• group、groups、span、start、end 函数

以上这几个函数作为常用函数，使用方式较为简单：
1. group：返回指定分组匹配的内容，参数为零或者默认值时，返回整个正则表达式匹配结果；参数为多个分组时，返回分组匹配结果构成的元组
2. groups：返回分组匹配结果构成的元组
3. span：返回指定分组匹配结果区间的首尾两个下标值（左闭右开）构成的元组，默认情况下匹配整个正则表达式匹配结果的首尾两个下标值
4. start：返回指定分组匹配结果区间的首下标
5. end：返回指定分组匹配结果区间的尾下标

示例：

import re

reg = r'(\d)(\d)'
pattern = re.compile(reg)

str1 = 'a12b'

match1 = pattern.search(str1)

print('group 1 = {}'.format(match1.group(1)))
print('span 1 = {}'.format(match1.span(1)))
print('start 1 = {}'.format(match1.start(1)))
print('end 1 = {}'.format(match1.end(1)),end='\n\n')

print('group 2 = {}'.format(match1.group(2)))
print('span 2 = {}'.format(match1.span(2)))
print('start 2 = {}'.format(match1.start(2)))
print('end 2 = {}'.format(match1.end(2)),end='\n\n')

print('groups = {}'.format(match1.groups()))
print('span = {}'.format(match1.span()))
print('start = {}'.format(match1.start()))
print('end = {}'.format(match1.end()),end='\n\n')

print('group 1,2 = {}'.format(match1.group(1,2)))
运行结果：
group 1 = 1
span 1 = (1, 2)
start 1 = 1
end 1 = 2

group 2 = 2
span 2 = (2, 3)
start 2 = 2
end 2 = 3

groups = ('1', '2')
span = (1, 3)
start = 1
end = 3

group 1,2 = ('1', '2')

Pattern 用作模式处理，Match 用作分组结果提取

比较以上 Pattern 和 Match 两种对象的使用方式，可以发现 Pattern 对象作用如其名称所示，是一种体现正则表达式规则的对象，也就是体现为一种文本模式。其所提供的诸多函数，如： find、search、match 等等，都是拿自身的规则以不同的方式去处理目标文本。而 Match 对象则是对分组结果的操作，Match 对象提供的函数则都是对结果以不同方式的提取，如：groups、span等，获取匹配分组结果的各项数据。