一、正则表达式简介

正则表达式（regex）：
由一些字符和特殊符号组成的字符串，描述了模式的重复或者表述多个字符，可以按照某种模式匹配一系列有相似特征的字符串。为高级的文本模式匹配、抽取、与/或文本形式的搜索和替换功能提供了基础。

也就是是说，使用正则表达式能够匹配多个既定规则的字符串。在严格表述与字符串中模式相关的正则表达式时，一般使用术语“匹配”（matching），即专业术语“模式匹配”（pattern-matching）。

Python中的正则：
Python 通过标准库中的 re 模块来支持正则表达式。

Python 术语中，主要有两种方法完成模式匹配：

• 搜索（searching）：在字符串任意部分中搜索匹配的模式；通过 search()函数或方法来实现
• 匹配（matching）：指判断一个字符串能否从起始处全部或者部分地匹配某个模式；通过调用 match()函数或方法实现。

二、正则表达式

正则表达式的强大之处在于引入特殊字符来定义字符集、匹配子组和重复模式。正是由于这些特殊符号，给予了正则表达式强大的
功能和灵活性使，得正则表达式可以匹配字符串集合，而不仅仅只是某单个字符串。

2.1、正则表达式中的特殊符号：

择一匹配符号：
即管道符号（|），也就是键盘上的竖线，表示一个“从多个模式中选择其一”的操作，用于分割不同的正则表达式。

匹配任意单个字符：
即英文格式句点（.）符号，匹配除了换行符\n 以外的任何一个字符，无论字母、数字、空格（并不包括“\n”换行符）、可打印字符、不可打印字符。
Python中编译标记[S 或者 DOTALL]，该标记能够推翻该限制，从而能够匹配换行符。

字符串起始、结尾、边界：
字符串的起始匹配符：
即脱字符（^）或者特殊字符\A（反斜线和大写字母 A）

字符串的结尾匹配符：
即美元符号（$）或者\Z

字符集匹配符：
即方括号[]，可以匹配特定字符，还支持匹配指定的字符范围。
方括号中两个符号中间用连字符（-）连接，用于指定一个字符的范围，例如，A-Z、a-z 或者 0-9 分别用于表示大写字母、小写字母和数值数字。

否定字符：
如果脱字符（^）紧跟在左方括号后面，这个符号就表示不匹配给定字符集中的任何一个字符。

闭包操作符：
最常用的正则表达式符号一般为星号操作符（）、加号操作符（+）、重载操作符（？）。
星号操作符（），匹配其左侧出现0次或多次，在计算机编程语言和编译原理中，该操作称为 Kleene 闭包。
加号（+）操作符，匹配一次或者多次（也叫做正闭包操作符）。

2.2、正则表达式中的特殊字符：

特殊字符表示字符集：
特殊字符\d 表示匹配任何十进制数字，\w表示全部字母数字的字符集（相当于[A-Za-z0-9_]），\s 可以用来表示空格字符，这些特殊字符的
大写版本表示不匹配。特殊字符组合使用，可以表示更复杂的示例。

2.3、正则表达式中的扩展表示法：

圆括号指定分组：
对于之前匹配成功的数据，在确定整个字符串是否匹配标准后，若想提取任何已经成功匹配的特定字符串或者子字符串，则需要引入圆括号来进行分组，这样匹配模式的子字符串可以保存起来供后续使用，这些子组能够被同一次的匹配或者搜索重复调用，或者提取出来用于后续处理。

使用正则表达式时，一对圆括号可以实现以下任意一个（或者两个）功能：

• 对正则表达式进行分组；
• 匹配子组。

应用场景：

• 两个不同的正则表达式，想用它们来比较同一个字符串；
• 对正则表达式进行分组可以在整个正则表达式中使用重复操作符。

扩展表示法：
以问号开始（?…），通常用于在判断匹配之前提供标记，实现一个前视（或者后视）匹配，或者条件检查。尽管圆括号使用这些符号，但是只有（?P）表述一个分组匹配，所有其他的都没有创建一个分组。

三、Python中的正则表达式之re 模块

Python 中通过使用 re 模块来支持正则表达式。

3.1、核心函数match、search

match(pattern，string，flags=0)：
匹配字符串，带有可选标记的正则表达式的模式。匹配成功，返回匹配对象；匹配失败，返回 None。
只要模式从字符串的起始部分开始匹配，即使字符串比模式长，匹配也仍然能够成功

import re

r1 = re.match('test', 'test')

if r1 is not None:
    g = r1.group()
    print(g)
# 输出结果：test

r2 = re.match('test', 'test , The Second test demo')
if r2 is not None:
    g = r2.group()
    print(g)
# 输出结果：test

r3 = re.match('test', 'The test demo').group()
print(r3)
# 输出结果：AttributeError: 'NoneType' object has no attribute 'group'

search(pattern，string，flags=0)：
搜索，带有可选标记的搜索字符串中第一次出现的正则表达式模式。匹配成功，返回匹配对象；匹配失败，返回 None。
在任意位置对给定正则表达式模式搜索第一次出现的匹配情况，概率远大于出现在字符串起始部分的概率。

import re

r1 = re.search('test', 'test')
if r1 is not None:
    g = r1.group()
    print(g)
# 输出结果：test

r2 = re.search('test', 'test , The Second test demo')
if r2 is not None:
    g = r2.group()
    print(g)
# 输出结果：test

r3 = re.search('test', 'The test demo').group()
print(r3)
# 输出结果：test

3.2、group()、 groups()

group(num=0):
匹配对象的 group()方法能够用于显示那个成功的匹配。返回整个匹配对象，或者编号为 num 的特定子组。
如果匹配失败，将会抛出 AttributeError 异常（None 是返回的错误值，该值并没有 group()属性[方法]），解决该异常添加if语句即可。

groups(default=None):
返回一个包含所有匹配子组的元组（如果没有成功匹配，则返回一个空元组）。

groupdict(default=None)：
返回一个包含所有匹配的命名子组的字典，所有的子组名称作为字典的键（如果没有
成功匹配，则返回一个空字典）

3.3、查找每一次出现的位置findall()、finditer()

findall(pattern，string [, flags] )：
查找字符串中所有（非重复）出现的正则表达式模式，返回一个匹配列表。

r1 = re.findall('car', 'car')
print(r1)
# 输出结果：['car']

r2 = re.findall('car', 'scary')
print(r2)
# 输出结果：['car']

r3 = re.findall('car', 'carry the barcardi to the car')
print(r3)
# 输出结果：['car', 'car', 'car']

finditer(pattern，string [, flags] )：
与 findall()函数相同，但返回的不是一个列表，而是一个迭代器。对于每一次匹配，迭代器都返回一个匹配对象。

import re

s = 'This and that.'
r1 = re.findall(r'(th\w+) and (th\w+)', s, re.I)
print(r1)
# 输出结果：[('This', 'that')]

r2 = re.finditer(r'(th\w+) and (th\w+)', s, re.I)
print(type(r2))
# 输出结果：<class 'callable_iterator'>
for i in r2:
    print(i.groups()) # 输出结果：('This', 'that')
    print(i.group())  # 输出结果：This and that
    print(i.group(1)) # 输出结果：This
    print(i.group(2)) # 输出结果：that


r5 = [g.groups() for g in re.finditer(r'(th\w+) and (th\w+)', s, re.I)]
# 输出结果：print(r5)
[('This', 'that')]

3.4、compile()函数编译正则表达式

在模式匹配发生之前，正则表达式模式必须编译成正则表达式对象。由于正则表达式在执行过程中将进行多次比较操作，因此强烈建议使
用预编译。既然正则表达式的编译是必需的，那么使用预编译来提升执行性能无疑是明智之举。re.compile()能够提供此功能。

模块函数会对已编译的对象进行缓存，所以不是所有使用相同正则表达式模式的 search()和 match()都需要编译。

purge()：清除隐式编译的正则表达式模式

**compile(pattern，flags = 0) **：
使用任何可选的标记来编译正则表达式的模式，然后返回一个正则表达式对象。
推荐预编译，但并不是必需的。如果需要编译，就使用编译过的方法；如果不需要编译，就使用函数。方法和函数名字相同

常用的模块属性（用于大多数正则表达式函数的标记）：

3.5、搜索与替换sub()、subn()

sub(pattern，repl，string，count=0)：
sub()和 subn()这两个函数/方法用于实现搜索和替换功能，几乎一样，subn()还返回一个表示替换的总数。
使用 repl 替换所有正则表达式的模式在字符串中出现的位置，除非定义 count，否则就将替换所有出现的位置（另见 subn()函数，该函数返回替换操作的数目）。

import re

r1 = re.sub('X', 'Mr. Smith', 'attn: X\n\nDear X,\n')
print(r1)
'''输出结果：
attn: Mr. Smith

Dear Mr. Smith,
'''

r2 = re.subn('X', 'Mr. Smith', 'attn: X\n\nDear X,\n')
print(r2)
# 输出结果：('attn: Mr. Smith\n\nDear Mr. Smith,\n', 2)

r3 = re.sub('[ae]', 'X', 'abcdef')
print(r3)
# 输出结果：XbcdXf

r4 = re.subn('[ae]', 'X', 'abcdef')
print(r4)
# 输出结果：('XbcdXf', 2)

3.6、限定模式上使用 split()分隔字符串

split(pattern，string，max=0)：
根据正则表达式的模式分隔符，split 函数将字符串分割为列表，然后返回成功匹配的列表，分隔最多操作 max 次（默认分割所有匹配成功的位置）。

import re

r1 = re.split(':', 'str1:str2:str3')
print(r1)
# 输出结果：['str1', 'str2', 'str3']

DATA = ('Mountain View,CA 94040','Sunnyvale,CA','Los Altos, 94023','Cupertino 95014', 'Palo Alto CA')
for data in DATA:
    print(re.split(',|(?= (?:\d{5}|[A-Z]{2})) ',data)) # 空格紧跟在五个数字（ZIP 编码）或者两个大写字母（美国联邦州缩写）之后，就用 split 语句分割该空格
''' 输出结果：
['Mountain View', 'CA', '94040']
['Sunnyvale', 'CA']
['Los Altos', '', '94023']
['Cupertino', '95014']
['Palo Alto', 'CA']
'''

3.7、 择一匹配（|）符号

择一匹配（|）符号：
用来匹配多个字符串。

bt = 'bat|bet|bit'      # 正则表达式模式: bat、bet、bit
m = re.match(bt, 'bat') # 'bat' 是一个匹配
if m is not None:
    print(m.group())
# 输出结果：bat

m = re.match(bt, 'blt') # 对于 'blt' 没有匹配
if m is not None:
    print(m.group())
# 无输出结果

m = re.match(bt, 'He bit me!') # 不能匹配字符串
if m is not None:
    print(m.group())
# 无输出结果

m = re.search(bt, 'He bit me!') # 通过搜索查找 'bit'
if m is not None:
    print(m.group())
# 输出结果：bit

3.8、点号（.）

点号（.）：
匹配任何单个字符，但不能匹配一个换行符\n 或者非字符（空字符串）。

anyend = '.end'
m = re.match(anyend, 'bend') # 点号匹配 'b'
if m is not None:
    print(m.group())
# 输出结果：'bend'

m = re.match(anyend, 'end') # 不匹配任何字符
if m is not None:
    print(m.group())
# 无输出结果：

m = re.match(anyend, '\nend') # 除了 \n 之外的任何字符
if m is not None:
    print(m.group())
# 无输出结果：

m = re.search('.end', 'The end.')# 在搜索中匹配 ' '
if m is not None:
    print(m.group())
# 输出结果：'end'

3.9、创建字符集（[ ]）

m = re.match('[cr][23][dp][o2]', 'c3po')# 匹配 'c3po'
if m is not None:
    print(m.group())
# 输出结果：'c3po'

m = re.match('[cr][23][dp][o2]', 'c2do')# 匹配 'c2do'
if m is not None:
    print(m.group())
# 输出结果：'c2do'

m = re.match('r2d2|c3po', 'c2do')# 不匹配 'c2do'
if m is not None:
    print(m.group())
# 无输出结果

m = re.match('r2d2|c3po', 'r2d2')# 匹配 'r2d2'
if m is not None:
    print(m.group())
# 输出结果：'r2d2'

3.10、重复、特殊字符以及分组

允许.com 前面有一个或者两个名称：

patt = '\w+@(\w+\.)?\w+\.com'
g1 = re.match(patt, '[email protected]').group()
print(g1)
# 输出结果：'[email protected]'

g2 = re.match(patt, '[email protected]').group()
print(g2)
# 输出结果：'[email protected]'

patt = '\w+@(\w+\.)*\w+\.com'
g3 = re.match(patt, '[email protected]').group()
print(g3)
# 输出结果：'[email protected]'

m = re.match('\w\w\w-\d\d\d', 'abc-123')
if m is not None:
    print(m.group())
# 输出结果：'abc-123'

m = re.match('\w\w\w-\d\d\d', 'abc-xyz')
if m is not None:
    print(m.group())
# 无输出结果：

m = re.match('(\w\w\w)-(\d\d\d)', 'abc-123')
print(m.group()) # 完整匹配
# 输出结果：'abc-123'

print(m.group(1))  # 子组 1
# 输出结果：'abc'

print(m.group(2))  # 子组 2
# 输出结果：'123'

print(m.groups())  # 全部子组
# 输出结果：('abc', '123')

m = re.match('ab', 'ab') # 没有子组
print(m.group()) # 完整匹配
# 输出结果：'ab'

print(m.groups()) # 所有子组
# 输出结果：()

m = re.match('(ab)', 'ab') # 一个子组
print(m.group()) # 完整匹配
# 输出结果：'ab'

print(m.group(1)) # 子组 1
# 输出结果：'ab'

print(m.groups()) # 全部子组
# 输出结果：('ab',)

m = re.match('(a)(b)', 'ab') # 两个子组
print(m.group()) # 完整匹配
# 输出结果：'ab'

print(m.group(1)) # 子组 1
# 输出结果：'a'

print(m.group(2)) # 子组 2
# 输出结果：'b'

print(m.groups()) # 所有子组
# 输出结果：('a', 'b')

m = re.match('(a(b))', 'ab') # 两个子组
print(m.group()) # 完整匹配
# 输出结果：'ab'

print(m.group(1)) # 子组 1
# 输出结果：'ab'

print(m.group(2)) # 子组 2
# 输出结果：'b'

print(m.groups()) # 所有子组
# 输出结果：('ab', 'b')

3.11、匹配字符串的起始和结尾以及单词边界

m = re.search('^The', 'The end.') # 匹配
if m is not None:
    print(m.group())
# 输出结果：'The'

m = re.search('^The', 'end. The') # 不作为起始
if m is not None:
    print(m.group())
# 无输出结果

m = re.search(r'\bthe', 'bite the dog') # 在边界
if m is not None:
    print(m.group())
# 输出结果:'the'

m = re.search(r'\bthe', 'bitethe dog') # 有边界
if m is not None:
    print(m.group())
# 无输出结果

m = re.search(r'\Bthe', 'bitethe dog') # 没有边界
if m is not None:
    print(m.group())
# 输出结果:'the'

3.12、扩展符号

(?iLmsux) 系列选项：
可以直接在正则表达式里面指定一个或者多个标记，而不是通过 compile()或者其他 re 模块函数。

import re

r1 = re.findall(r'(?i)yes', 'yes? Yes. YES!!')
print(r1)
# 输出结果：['yes', 'Yes', 'YES']

r2 = re.findall(r'(?i)th\w+', 'The quickest way is through this tunnel.')
print(r2)
# 输出结果：['The', 'through', 'this']

r3 = re.findall(r'(?im)(^th[\w ]+)', """ 
... This line is the first, 
... another line, 
... that line, it's the best 
... """)
print(r3)
# 输出结果：[]

r4 = re.findall(r'th.+', ''' 
... The first line 
... the second line 
... the third line 
... ''')
print(r4)
# 输出结果：['the second line ', 'the third line ']

r5 = re.findall(r'(?s)th.+', ''' 
... The first line 
... the second line 
... the third line 
... ''')
print(r5)
# 输出结果：['the second line \n... the third line \n... ']

r6 = re.search(r'''(?x) 
\((\d{3})\)     区号 
[ ]            # 空白符 
(\d{3})        # 前缀 
-              # 横线 
(\d{4})        # 终点数字
''', '(800) 555-1212')
if r6 is not None:
    print(r6.group())
# 无输出结果

r7 = re.findall(r'http://(?:\w+\.)*(\w+\.com)', 'http://google.com http://www.google.com http://code.google.com')
print(r7)
# 输出结果：['google.com', 'google.com', 'google.com']

r8 = re.search(r'\((?P<areacode>\d{3})\) (?P<prefix>\d{3})-(?:\d{4})', '(800) 555-1212').groupdict()
print(r8)
# 输出结果：{'areacode': '800', 'prefix': '555'}

# 使用一个类似风格的\g<name>来检索它们
r9 = re.sub(r'\((?P<areacode>\d{3})\) (?P<prefix>\d{3})-(?:\d{4})', '(\g<areacode>) \g<prefix>-xxxx', '(800) 555-1212')
print(r9)
# 输出结果：(800) 555-xxxx

# 压缩版
r10 = bool(re.match(
    r'\((?P<areacode>\d{3})\) (?P<prefix>\d{3})-(?P<number>\d{4}) (?P=areacode)-(?P=prefix)-(?P=number)(?P=areacode)(?P=prefix)(?P=number)',
    '(800) 555-1212 800-555-1212 18005551212'))
print(r10)
# 输出结果：False

# 普通版
r11 = bool(re.match(r'''(?x) 
# match (800) 555-1212, save areacode, prefix, no. 
\((?P<areacode>\d{3})\)[ ](?P<prefix>\d{3})-(?P<number>\d{4}) 
# space 
[ ] 
# match 800-555-1212 
(?P=areacode)-(?P=prefix)-(?P=number) 
# space 
[ ] 
# match 18005551212 
1(?P=areacode)(?P=prefix)(?P=number) 
''', '(800) 555-1212 800-555-1212 18005551212'))
print(r11)
# 输出结果：True

r12 = re.findall(r'\w+(?= van Rossum)', ''' 
Guido van Rossum 
Tim Peters 
Alex Martelli 
Just van Rossum 
Raymond Hettinger 
... ''')
print(r12)
# 输出结果：['Guido', 'Just']

r13 = re.findall(r'(?m)^\s+(?!noreply|postmaster)(\w+)', ''' 
[email protected] 
[email protected] 
[email protected] 
[email protected] 
[email protected] 
... ''')
print(r13)
# 输出结果：['sales']

r14 = ['%[email protected]' % e.group(1) for e in re.finditer(r'(?m)^\s+(?!noreply|postmaster)(\w+)', ''' 
[email protected] 
[email protected] 
[email protected] 
[email protected] 
[email protected] 
... ''')]
print(r14)
# 输出结果：['[email protected]']