Python 玩转数据 19 - 数据操作 正则表达式 Regular Expressions 搜索模式匹配_re.multiline

引言

本文主要介绍一下 Python 正则表达式，搜索模式匹配。更多 Python 进阶系列文章，请参考 Python 进阶学习 玩转数据系列

内容提要：

1. re 模块方法汇总

2. match() vs. search()

3. 常用的正则表达式通配符

4. 用 Raw Strings 原始字符串

5. MatchObject

6. findall()

7. Matching Flags
   re.IGNORECASE
   re.ASCII
   re.DOTALL
   re.MULTILINE
   re.VERBOSE

8. 字符串操作 re.sub re.split

9. 用 re.compile 更方便

10. 字符串方法 和 正则匹配

11. 匹配 Email 的例子

12. 正则表达式基本语法应用
    简单字符匹配
    一些特殊意义的字符
    [ ] 中括号 Square brackets
    重复通配符 Wildcards match repeated characters
    命名提取匹配部分 Naming extracted components

re 模块方法汇总

match() vs. search()

match() :
● 返回一个 MatchObject 如果 0 或 多个字符从字符串起始位置匹配到正则表达式模式
● 返回 None 如果字符串起始位置没有匹配到模式

search() 扫描正个字符串返回:
● 一个相应的 MatchObject
● None 没有找到匹配到的

举例：

Code:

import re

def match_search(regex, search_str):
    if re.match(regex, search_str):
        print('match: begins with {0}'.format(regex))
    else:
        print('match: {0} not found at beginning'.format(regex))

    if re.search(regex, search_str):
        print('search: contains {0}'.format(regex))
    else:
        print('search: {0} not found within'.format(regex))

lor = '''THE LORD OF THE RINGS

V*art One 

THE FELLOWSHIP 
OF THE RING 

J.R.R.ToIkien'''

match_search('THE', lor)
match_search('THE LORD', lor)
match_search('LORD', lor)
match_search('ToIkien', lor)

regex = re.compile('\s+')

for s in ["     ", "abc  ", "  abc"]:
    if regex.match(s):
        print(repr(s), "matches")
    else:
        print(repr(s), "does not match")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

常用的正则表达式通配符

用 Raw Strings 原始字符串

● \ 反斜杠 backslash ，在字符串中是转义符，而在正则表达式中一个特殊的字符。
● 为了避免混淆反斜杠和转义字符，我们用原始字符串 Raw String
● 用 r’….’ 表示原始字符串 ，\ 在原始字符串不再是一个特殊字符串字符。

举例：
字符串中 \b 是一个特殊的符号，\\ 是表示字符 \，强调用不是转义符。

MatchObject

match() 或 search() 会返回一个 MatchObject
MatchObject 方法:
● start(n) – 返回特定分组的起始索引
● end(n) – 返回特定分组的终止索引
● span(n) – 返回特定分组的起止索引元组 values (start, end)
● groups() – 返回包含所有子分组的元组
● group(n) – 返回特定子分组的元组, zero is the whole match

举例：

代码：

matchobj = re.search(r'(\w+) (\w+) (\w+) (\w+)',
"Hobbits are an unobtrusive but very ancient people")
print("groups():",matchobj.groups())

for i in range(len(matchobj.groups())+1):    
    print("group({0}): {1}".format(str(i), matchobj.group(i)))
    print("start({}): {}".format(str(i), matchobj.start(i)))
    print("end({}): {}".format(str(i), matchobj.end(i)))
1
2
3
4
5
6
7
8

findall()

findall() 返回一个 list，是括号所匹配到的结果(如 matches_2)，多个括号就会返回多个括号分别匹配到的结果(如 matches_3)，如果没有括号就返回就返回整条语句所匹配到的结果(如 matches_1)。

第 1 个 regex 中不带有括号, 其输出的内容就是整个表达式所匹配到的内容。
第 2 个 regex 中带有1个括号，其输出的内容就是括号匹配到的内容，而不是整个表达式所匹配到的结果。
第 3 个 regex 中是带有2个括号的，我们可以看到其输出是一个list 中包含 2 个 tuple

Code:

import re

string = "Hobbits are an unobtrusive but very ancient people"
matches_1 = re.findall(r'\w+', string)
matches_2 = re.findall(r'(\w+) (\w+) (\w+) (\w+)', string)
matches_3 = re.findall(r'((\w+) (\w+) (\w+) (\w+))', string)
print("{0}\ncontains {1} words: {2}".format(string, len(matches_1), matches_1))
print("{0}\ncontains {1} words: {2}".format(string, len(matches_2), matches_2))
print("{0}\ncontains {1} words: {2}".format(string, len(matches_3), matches_3))
1
2
3
4
5
6
7
8
9

Matching Flags

● re.IGNORECASE - 忽略大小写 匹配
● re.ASCII - 只匹配 ASCII，而不是 unicode
● re.VERBOSE - use verbose-style regular expressions
● re.DOTALL - dot(.) 匹配任意字符，包括换行符
● re.MULTILINE - 多行匹配每行的开头或结尾

re.IGNORECASE

re.IGNORECASE 或简写为 re.I ，忽略大小写匹配。

re.ASCII

re.ASCII 或简写为 re.A ，ASCII表示ASCII码的意思，让 w, W, b, B, d, D, s和 S只匹配ASCII，而不是Unicode

re.DOTALL

re.DOTALL 或简写为 re.S，DOT表示 .，ALL表示所有，连起来就是.匹配所有，包括换行符n。默认模式下. 是不能匹配行符 n 的。

re.MULTILINE

re.MULTILINE 或简写为 re.M，多行模式，当某字符串中有换行符 n，默认模式下是不支持换行符特性的，比如：行开头 和 行结尾，而多行模式下是支持匹配行开头的。

re.VERBOSE

通常正则表达式都是一行，不是很好理解。所以，可以使用详细模式，正则表达式中可以加注解。但是详细模式有区别普通模式：

空格被忽略:
● 空格，tabs 符，回车符都会被胡烈
● 如果需要忽略一个空格，需要用转义符。

注释被忽略:
● 详细模式中，一个注释就像 Python 代码中的注释一样，以 # 开头直到行结束。

代码：

import re
pattern = r'''
(\(?\d{3}\)?)? # optional area code, parentheses optional
[-\s.]?        # optional separator, dash, space, or period
\d{3}          # 3-digit prefix
[-\s.]         # separator: dash, space or period
\d{4}          # final 4-digits
'''
phones = [
    '123-456-7890',
    '123 456 7890',
    '(123) 456-7890',
    '123.456,7890',
    '123-4567',
    'abc-dfg-7789'
]

valid = [ph for ph in phones if re.match(pattern, ph, re.VERBOSE)]
print('VERBOSE: Valid phones: {0}'.format(valid))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

字符串操作 re.sub re.split

有两种方法用来处理经过模式匹配后的字符串

1. newstr = re.sub (pattern, replacement, sourcestring) 替换模式匹配到的字符
2. re.split (pattern, sourcestring) 用模式匹配到的作为分隔符

举例：

用 re.compile 更方便

如果一个匹配模式需要反复使用，那么用 re.compile(pattern) 更方便

pattern_obj = re.compile(pattern, re.VERBOSE)

举例：

字符串方法 和 正则匹配

regex.search() 方法和 str.index() 或 str.find() 方法是相同功能的。

regex.sub() 方法像 str.replace()

匹配 Email 的例子

‘\w+@\w+.[a-z]{3}’ \w 只能匹配到字符，数字的字符，邮件里的 . 字符没法匹配到

我们可以用 \S 匹配非空字符。
‘\w+\S\w+@\w+.[a-z]{3}’

正则表达式基本语法应用

简单字符匹配

import re

lor = open('../Python_data_wrangling/Python_data_wrangling_data_raw/data_raw/LordOfTheRings.txt',encoding='utf-8').read()

frodo = re.compile('Frodo')
frodos = frodo.findall(lor)

gandalf = re.compile('Gandalf')
gandalfs = gandalf.findall(lor)

sauron = re.compile('Sauron')
saurons = sauron.findall(lor)

gollum = re.compile('Gollum')
gollums = gollum.findall(lor)

print("Frodo is mentioned {} times\nGandalf is mentioned {} times\nSauron is mentioned: {} times\nGollum is mentioned {} times".
      format(len(frodos),len(gandalfs), len(saurons), len(gollums)))
print("So who is the Lord of the Rings?")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

输出：

Frodo is mentioned 1100 times
Gandalf is mentioned 466 times
Sauron is mentioned: 60 times
Gollum is mentioned 72 times
So who is the Lord of the Rings?
1
2
3
4
5

一些特殊意义的字符

如： ^ $ * + ? { } [ ] \ | ( )
如果只是想匹配到上面的这些字符，不能直接直接用，需要加上转义符 \

[ ] 中括号 Square brackets

如果内置的字符不够充分，用户可以自定义。可以用破折号表示范围
如 “[a-m]” 匹配小写字符 a 到 m 之间的字符

重复通配符 Wildcards match repeated characters

如果想匹配 5 个字符，可以用 “\w\w\w\w\w” 或 “\w{3}”

例如：
[\w.]+ 表示 \w 或 . 出现一次或多次，也就能匹配到任意长度字符数字或 .

命名提取匹配部分 Naming extracted components

用 (?P<name>) 来将匹配的值分组成一个字典

code：

import re
email4 = re.compile('(?P<user>[\w.]+)@(?P<domain>\w+)\.(?P<suffix>[a-z]{3})')
match = email4.match('peter.zhang@gmail.com')
match.groupdict()
1
2
3
4