python | 巧用正则表达式

本文简单总结正则表达式的一些语法规则和给出相关示例。

更新： 2023 / 7 / 1

---

正则匹配作为专业的查找工具，在判断字符串中含有特定字串上效率相对较高。

---

正则表达式

基本内容

正则表达式修饰符 —— 可选标志

正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR (|) 来指定。如 re.l | re.M 被设置成 l 和 M 标志 ¹。

正则表达式模式

模式字符串使用特殊的语法来表示一个正则表达式：

• 字母和数字表示它们自身。
• 多数字母和数字前加一个反斜杠时会有不同的涵义，比如 \n 表示换行。
• 标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。
• 反斜杠本身需要使用反斜杠转义。
• 由于正则表达式通常都包含反斜杠，最好使用原始字符串来表示它们。模式元素（如 r\t 等价于 \\t ）匹配相应的特殊字符。

下表列出了正则表达式模式语法中的特殊元素 ²。如果使用模式的同时提供了可选的标志参数，某些模式元素的含义会被改变：

元字符

字符

数量

边界

分组

用 () 表示的就是要提取的分组，一般用于提取子串。
比如 ^(\d{3})-(\d{3,8})$，从匹配的字符串中提取出区号和本地号码。

常见表达式函数

正则表达式是一个特殊的字符序列，可以方便的检查一个字符串是否与某种模式匹配。Python 自带的 re 模块使 Python 语言拥有全部的正则表达式功能。

Python 常用的正则表达式函数如下：

查找一个匹配项

re.match

语法

re.match(pattern, string, flags=0)
1

re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match() 就返回 none；如果匹配成功的话可以使用 group(num) 或 groups() 匹配对象函数来获取匹配表达式。

示例

s = 'name:alice,result:89'
result = re.match('\w+:(\w+).\w+:(.\d+)', s)

print(result)
# 

print(result.group(0))
# name:alice,result:89

print(result.group(1))
# alice

print(result.group(2))
# 89

print(result.group())
# name:alice,result:89
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

从结果可以看出，re.match() 方法返回一个匹配的对象，而不是匹配的内容。通过调用 span() 可以获得匹配结果的位置。而如果从起始位置开始没有匹配成功，即便其他部分包含需要匹配的内容，re.match() 也会返回 None。可以使用 group() 来提取每组匹配到的字符串。

group() 会返回一个包含所有小组字符串的元组，从 0 到所含的小组号。

注意，如果在运用正则表达式做匹配的过程中没有匹配到元素，之后又调用了 group()，会报错：AttributeError: 'NoneType' object has no attribute 'group'。

如果出现这种报错，可以将 match 改成 search() 就可以避开这类问题了。
search 函数是先扫描全部的代码块，再进行提取的。

re.search

语法

re.search(pattern, string, flags=0)
1

参数同 re.match()。

在给定字符串中查找第一个与正则表达式匹配的子串，如果找到则返回 MatchObject 对象（结果为真），否则返回 None（结果为假），参数 pattern 为正则表达式，string 为要匹配的字符串，flags 为标志位，控制是否区分大小写等等。

MatchObject 对象包含与模式匹配的子串的信息，这些子串部分称为编组。编组就是放在圆括号内的子模式，根据左边的括号数变好，其中编组 0 指的是整个模式。

MatchObject 对象的几个重要方法：

• groups 返回一个包含所有编组字符串的元组，从 1 到所含的编组，不包含编组 0.
• group[(group1, ...)] 获取与给定子模式（编组）匹配的子串，没有指定编组号则默认为 0。
• start([group]) 返回与给定编组匹配的子串的起始位置；
• end([group]) 返回与给定编组匹配的子串的终止位置（与切片一样不包含终止位置）
• span([group]) 返回与给定编组匹配的子串的起始位置和终止位置

示例

• re.match

s = 'class:1班,name:alice,result:89'
result = re.match('name:(\w+).result:(.\d+)', s)
print(result)
# None
print(result.group(0))
# Traceback (most recent call last):
#   File "test.py", line 34, in 
#     print(result.group(0))
# AttributeError: 'NoneType' object has no attribute 'group'
1
2
3
4
5
6
7
8
9

因为没有在起始位置匹配成功，则 re.match 返回 none。

• re.search

s = 'class:1班,name:alice,result:89'
result = re.search('name:(\w+).result:(.\d+)', s)
print(result)
# 

if result:
    print(result.groups())
    # ('alice', '89')
print(result.group(0))
# name:alice,result:89

print(result.group(1))
# alice
print(result.start(1))
# 14
print(result.end(1))
# 19
print(result.span(1))
# (14, 19)
print(s[14:19])
# alice

print(result.group(2))
# 89
print(result.start(2))
# 27
print(result.end(2))
# 29
print(result.span(2))
# (27, 29)
print(s[27:29])
# 89
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

re.search 在整个字符串中进行匹配。

查找多个匹配项

re.findall

语法

在字符串中找到正则表达式所匹配的所有子串，并返回一个列表。
如果有多个匹配模式，则返回元组列表；
如果没有找到匹配对象，则返回空列表；

注意：re.search 和 re.match 都是返回第一个匹配到的对象，而 re.findall 则返回所有的匹配对象。

示例

s = '../DataAnalysis/Jira/DataAnalysisWithJira_1.py'
result = re.findall('\d+', s)
print(result)
# ['1']
1
2
3
4

分割

语法

re.split(pattern, string[, maxsplit=0, flags=0])
1

根据模式来分割字符串，返回字符串。

示例

s = '/home/Desktop/string,numpy pandas'
result = re.split('[/ ,]', s)
# 以斜杠、逗号和空格为分隔符进行分割
print(result)
# ['', 'home', 'Desktop', 'string', 'numpy', 'pandas']
1
2
3
4
5

替换

re.sub

语法

re.sub(pattern, repl, string, count=0, flags=0)
1

将字符串中与模式 pattern 匹配的子串都替换为 repl ³

示例

1.

s = 'name:alice,result:89'
res1 = re.sub(pattern=r'\d+', repl='90', string=s)
print(res1)
# name:alice,result:90
1
2
3
4

如果 repl 是一个函数，如下：

def change(matched):
    print(matched)
    # 

    print(matched.group('value'))
    # 89
    print(type(matched.group('value')))
    # 

    value = int(matched.group('value'))
    print(str(value + 1))
    # 90
    print(type(str(value + 1)))
    # 

    return str(value + 1)


s = 'name:alice,result:89'
# result = re.findall('(?P\d+)', s)
# print(result)
# # ['89']

res1 = re.sub('(?P\d+)', change, s)
print(res1)
# name:alice,result:90
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

2.

s = 'abc123def'
result = re.sub(r'\D', '-', 'abc123def')
print(result)
1
2
3

编译正则对象

re.compile

语法

re.compile(pattern, flags)
1

re.compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象。它单独使用就没有任何意义，需要和 findall()，search() 和 match() 搭配使用 ¹。

re 模块的一般使用步骤是：

1. 使用 compile 函数将正则表达式的字符串形式编译为一个 Pattern 对象；
2. 通过 Pattern 对象提供的一系列方法对文本进行匹配查找，获得匹配结果（一个 Match 对象）；
3. 最后使用 Match 对象提供的属性和方法获得信息，根据需要进行其他的操作里是引用；

示例

s = 'www.python.org'
pattern = re.compile(r'python')
result = pattern.search(s)
if result:
    print(result)
    # < re.Match object; span = (4, 10), match = 'python' >
    print(result.group(0))
    # python
    print(result.span())
    # python
    print(s[4:10])
    # python
1
2
3
4
5
6
7
8
9
10
11
12

技巧总结

示例

数字

s = 'name:alice,math:89.3,english:42,chemistry:-30.5,chinese:56,physics:-59'
result = re.findall('-\d+', s)
# ['-30', '-59']			

result = re.findall('\d+', s)
# ['89', '3', '42', '30', '5', '56', '59']

result = re.findall('[0-9]+', s)
# ['89', '3', '42', '30', '5', '56', '59']

result = re.findall('-?\d+\.\d+', s)
# ['89.3', '-30.5']
1
2
3
4
5
6
7
8
9
10
11
12

日期

s = 'name:alice,page:http://baidu.com/, birth date: 11/06/1997'

result = re.search('(0?[1-9]|1[012])[- /.](0?[1-9]|[12][0-9]|3[01])[- /.](19|20)?[0-9]{2}', s)
print(result.group())
# 11/06/1997


s = 'name:alice,page:http://baidu.com/, birth date: 1997/11/06'

result = re.search('(19|20)?[0-9]{2}[- /.](0?[1-9]|1[012])[- /.](0?[1-9]|[12][0-9]|3[01])', s)
print(result.group())
# 1997/11/06
1
2
3
4
5
6
7
8
9
10
11
12

字母

s = 'Name:alice, Result:Math:89.3;English:42;Chemistry:-30.5;Chinese:56;Physics:-59'

result = re.findall('[A-Z]+', s)
print(result)
# ['N', 'R', 'M', 'E', 'C', 'C', 'P']

result = re.findall('[a-z]+', s)
print(result)
# ['ame', 'alice', 'esult', 'ath', 'nglish', 'hemistry', 'hinese', 'hysics']
1
2
3
4
5
6
7
8
9

数字 + 字母

邮箱

参考 ⁴

s = 'name:alice,mail:alice.zhang_0521@hotmail.com'

result = re.findall('mail:([a-zA-Z0-9._%-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4})', s)
# ['alice.zhang_0521@hotmail.com']

result = re.findall(r'mail:(\S+@\S+)', s)
# ['alice.zhang_0521@hotmail.com']

result = re.findall(r'mail:(\S+)@(\S+)', s)
# [('alice.zhang_0521', 'hotmail.com')]
1
2
3
4
5
6
7
8
9
10

网址

s = 'name:alice,page:http://baidu.com/'
result = re.findall('([a-zA-z]+://[^\s]*)', s)
# ['http://baidu.com/']

s = 'link: https://www.baidu.com/s?wd=%E6%8E%A8%E5%8A%A8%E4%B8%AD%E5%9B%BD%E4%B8%AD%E4%BA%9A%E5%85%B3%E7%B3%BB%E8%A1%8C%E7%A8%B3%E8%87%B4%E8%BF%9C&sa=fyb_n_homepage&rsv_dl=fyb_n_homepage&from=super&cl=3&tn=baidutop10&fr=top1000&rsv_idx=2&hisfilter=1,yes?'
result = re.findall('([a-zA-z]+://[^\s]*),yes?', s)
# ['https://www.baidu.com/s?wd=%E6%8E%A8%E5%8A%A8%E4%B8%AD%E5%9B%BD%E4%B8%AD%E4%BA%9A%E5%85%B3%E7%B3%BB%E8%A1%8C%E7%A8%B3%E8%87%B4%E8%BF%9C&sa=fyb_n_homepage&rsv_dl=fyb_n_homepage&from=super&cl=3&tn=baidutop10&fr=top1000&rsv_idx=2&hisfilter=1']
1
2
3
4
5
6
7

字符

汉字

s = '名字：唐_@伯虎; name: tang_bohu;'
result = re.findall('[\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff]', s)
# ['名', '字', '唐', '伯', '虎']
1
2
3

pattern

1.

s = 'WindowsXP, Windows97, Windows2000'
result = re.findall('Windows(?=95|98|XP|2000)', s)
# ['Windows', 'Windows']
### 匹配的是 `Windows97` 和 `Windows2000` 中的 `Windows`

s = 'WindowsXP, Windows97, Windows2000'
result = re.findall('Windows(?!95|98|XP|2000)', s)
# ['Windows']
### 匹配的是 `WindowsXP` 中的 `Windows`
1
2
3
4
5
6
7
8
9

2.

s = 'never ever stop running.'
result = re.findall(r'\w+ver\b', s)
# ['never', 'ever']
result = re.findall(r'\bnev\w+', s)
# ['never']
result = re.findall(r'\w+ing\b', s)
# ['running']
1
2
3
4
5
6
7

去除特殊字符

去空格

s = ' No pain, no gain ...'
result = re.findall('\S', s)
# ['N', 'o', 'p', 'a', 'i', 'n', ',', 'n', 'o', 'g', 'a', 'i', 'n', '.', '.', '.']
result = ''.join(result)
# Nopain,nogain...
1
2
3
4
5

去斜杠等

s = './PycharmProjects/DataAnalysis/test_1.py'

x = re.findall('\w+', s)
# ['PycharmProjects', 'DataAnalysis', 'test_1', 'py']
x = '-'.join(x)
# PycharmProjects-DataAnalysis-test_1-py
1
2
3
4
5
6

s = './PycharmProjects/DataAnalysis/file.list'

result = re.findall(r'\w+\.?\w+', s)
# ['PycharmProjects', 'DataAnalysis', 'file.list']

result = re.sub(r'\w+\.?\w+', '..', s)
# ./../../..
1
2
3
4
5
6
7

去特殊字符

s = './PycharmPro!#@&jects/DataAnalysis/test_1.py'
symbol = re.findall('[!#@^$&)+]+?', s)
# ['!', '#', '@', '&']

s = re.sub('[!#@^$&)+]+?', "", s)
# ./PycharmProjects/DataAnalysis/test_1.py
1
2
3
4
5
6

---

参考链接

---

1. 【python】使用正则匹配判断字符串中含有某些特定子串 及 正则表达式详解 ↩︎ ↩︎

2. Python正则表达式最强整理（速查手册，记得收藏） ↩︎

3. Python 的正则操作与获取指定目录下的文件 ↩︎

4. 如何在 Python 和 Pandas 中使用正则表达式 ↩︎