python 正则表达式详解

低着头走上坡路

于 2024-01-31 14:26:43 发布

阅读量1k

点赞数 32

分类专栏：数字IC及脚本语言文章标签： python 正则表达式开发语言

本文链接：https://blog.csdn.net/qq_44463933/article/details/135952797

版权

数字IC及脚本语言专栏收录该内容

8 篇文章 0 订阅

订阅专栏

正则表达式

1.不用正则表达式来查找文本模式

假设你希望在字符串中查找电话号码。你知道模式：3 个数字，一个短横线，3个数字，一个短横线，再是 4 个数字。例如：415-555-4242。

def isPhoneNumber(text):
    if len(text) != 12: 
        return False 
    for i in range(0, 3):
        if not text[i].isdecimal(): 
            return False
    if text[3] != '-':
        return False 
    for i in range(4, 7): 
        if not text[i].isdecimal(): 
            return False
        if text[7] != '-':
            return False 
    for i in range(8, 12):
        if not text[i].isdecimal(): 
            return False
    return True 
print('415-555-4242 is a phone number:') 
print(isPhoneNumber('415-555-4242'))
print('Moshi moshi is a phone number:')
print(isPhoneNumber('Moshi moshi'))

#----------------output--------------------#
415-555-4242 is a phone number: 
True
Moshi moshi is a phone number:
False
#------------------------------------------#

2.使用正则表达式查找文本模式

前面的电话号码查找程序能工作，但它使用了很多代码，做的事却有限。但正则表达式可以复杂得多。例如，在一个模式后加上花括号包围的 3（{3}），就是说，“匹配这个模式 3 次”。所以较短的正则表达式\d{3}-\d{3}-\d{4}，也匹配正确的电话号码格式。

2.1 创建正则表达式对象：re.compile()

Python 中所有正则表达式的函数都在 re 模块中。在交互式环境中输入代码，导入该模块：import re

向re.compile()传入一个字符串值，表示正则表达式，它将返回一个 Regex 模式对象（或者就简称为 Regex 对象）。
要创建一个 Regex 对象来匹配电话号码模式，就在交互式环境中输入以下代码（\d 表示“一个数字字符”，\d\d\d-\d\d\d-\d\d\d\d 是正确电话号码模式的正则表达式）。

phoneNumRegex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d')

现在 phoneNumRegex 变量包含了一个 Regex 对象。

2.2 匹配Regex对象：search()

Regex 对象的 search()方法查找传入的字符串，寻找该正则表达式的所有匹配。如果字符串中没有找到该正则表达式模式，search()方法将返回 None。如果找到了该模式，search()方法将返回一个 Match 对象。Match 对象有一个 group()方法，它返回被查找字符串中实际匹配的文本。

phoneNumRegex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d')
mo = phoneNumRegex.search('My number is 415-555-4242.') 
print('Phone number found: ' + mo.group())

#----------------output--------------------#
Phone number found: 415-555-4242
#------------------------------------------#

向re.compile()传递原始字符串

Python中转义字符使用倒斜杠（\）。字符串’\n’表示一个换行字符，而不是倒斜杠加上一个小写的 n。你需要输入转义字符\，才能打印出一个倒斜杠。所以’\n’表示一个倒斜杠加上一个小写的 n。
通过在字符串的第一个引号之前加上 r，可以将该字符串标记为原始字符串，它不包括转义字符。因为正则表达式常常使用倒斜杠，向 re.compile()函数传入原始字符串就很方便。
输入r'\d\d\d-\d\d\d-\d\d\d\d' ，比输入'\\d\\d\\d-\\d\\d\\d-\\d\\d\\d\\d'要容易得多。

2.3 正则表达式总结

步骤
1．用 import re 导入正则表达式模块。
2．用 re.compile()函数创建一个 Regex 对象（记得使用原始字符串）。
3．向 Regex 对象的 search()方法传入想查找的字符串。它返回一个 Match 对象。
4．调用 Match 对象的 group()方法，返回实际匹配文本的字符串。

3.用正则表达式匹配更多模式

3.1 利用括号分组: group()

假定想要将区号从电话号码中分离。添加括号将在正则表达式中创建“分组”：(\d\d\d)-(\d\d\d-\d\d\d\d)。然后可以使用 group()匹配对象方法，从一个分组中获取匹配的文本。
正则表达式字符串中的第一对括号是第 1 组。第二对括号是第 2 组。向 group()匹配对象方法传入整数 1 或 2，就可以取得匹配文本的不同部分。向 group()方法传入 0 或不传入参数，将返回整个匹配的文本。输入以下代码：

phoneNumRegex = re.compile(r'(\d\d\d)-(\d\d\d-\d\d\d\d)') 
mo = phoneNumRegex.search('My number is 415-555-4242.') 
mo.group(1)
mo.group(2)
mo.group(0)
mo.group()

#-------------output----------#
'415'
'555-4242'
'415-555-4242'
'415-555-4242'
#-----------------------------#

"如果想要一次就获取所有的分组，请使用 groups()方法，注意函数名的复数形式。"
mo.groups() # 元组：('415', '555-4242')
areaCode, mainNumber = mo.groups()  
print(areaCode)
print(mainNumber)

#-------------output----------#
415
555-4242
#-----------------------------#

因为 mo.groups()返回多个值的元组，所以你可以使用多重复制的技巧，每个值赋给一个独立的变量，就像前面的代码行：areaCode, mainNumber = mo.groups()。

3.2 用管道匹配多个分组: |

字符|称为“管道”。希望匹配许多表达式中的一个时，就可以使用它。例如：正则表达式 r’Batman|Tina Fey’将匹配’Batman’或’Tina Fey’。

"如果 Batman 和 Tina Fey 都出现在被查找的字符串中，第一次出现的匹配文本，将作为 Match 对象返回。"
heroRegex = re.compile (r'Batman|Tina Fey')
mo1 = heroRegex.search('Batman and Tina Fey.') 
mo1.group() # 'Batman'
mo2 = heroRegex.search('Tina Fey and Batman.')
mo2.group() # 'Tina Fey'

假设你希望匹配’Batman’、‘Batmobile’、'Batcopter’和’Batbat’中任意一个。因为所有这些字符串都以 Bat 开始，所以如果能够只指定一次前缀，就很方便。这可以通过括号实现。

batRegex = re.compile(r'Bat(man|mobile|copter|bat)')
mo = batRegex.search('Batmobile lost a wheel')
mo.group()  # 'Batmobile'
mo.group(1) # 'mobile'

方法调用 mo.group()返回了完全匹配的文本’Batmobile’，而 mo.group(1)只是返回第一个括号分组内匹配的文本’mobile’。

3.3 用问号实现可选匹配

"正则表达式中的(wo)?部分表明，模式 wo 是可选的分组。该正则表达式匹配的文本中，wo 将出现零次或一次"
batRegex = re.compile(r'Bat(wo)?man') 
mo1 = batRegex.search('The Adventures of Batman')
mo1.group() # 'Batman'
mo2 = batRegex.search('The Adventures of Batwoman')
mo2.group() # 'Batwoman'

3.4 用星号匹配零次或多次

*（称为星号）意味着“匹配零次或多次”，即星号之前的分组，可以在文本中出现任意次。它可以完全不存在，或一次又一次地重复。让我们再来看看 Batman 的例子。

"对于'Batman'，正则表达式的(wo)*部分匹配 wo 的零个实例。对于'Batwoman'，(wo)*匹配 wo 的一个实例。对于'Batwowowowoman'，(wo)*匹配 wo 的 4 个实例。"
batRegex = re.compile(r'Bat(wo)*man')
mo1 = batRegex.search('The Adventures of Batman') 
mo1.group() # 'Batman'
mo2 = batRegex.search('The Adventures of Batwoman')
mo2.group() # 'Batwoman'
mo3 = batRegex.search('The Adventures of Batwowowowoman')
mo3.group() # 'Batwowowowoman'

3.5 用加号匹配一次或多次

+（加号）则意味着“匹配一次或多次”。加号前面的分组必须“至少出现一次”

"正则表达式 Bat(wo)+man 不会匹配字符串'The Adventures of Batman'，因为加号要求 wo 至少出现一次。"
batRegex = re.compile(r'Bat(wo)+man') 
mo1 = batRegex.search('The Adventures of Batwoman')
mo1.group() # 'Batwoman'
mo2 = batRegex.search('The Adventures of Batwowowowoman')
mo2.group() # 'Batwowowowoman'
mo3 = batRegex.search('The Adventures of Batman') 
mo3 == None # True

3.6 用花括号匹配特定次数

如果想要一个分组重复特定次数，就在正则表达式中该分组的后面，跟上花括号包围的数字。例如，正则表达式(Ha){3}将匹配字符串’HaHaHa’，但不会匹配’HaHa’，因为后者只重复了(Ha)分组两次。
除了一个数字，还可以指定一个范围，即在花括号中写下一个最小值、一个逗号和一个最大值。例如，正则表达式(Ha){3,5}将匹配’HaHaHa’、‘HaHaHaHa’和’HaHaHaHaHa’。
也可以不写花括号中的第一个或第二个数字，不限定最小值或最大值。例如，(Ha){3,}将匹配 3 次或更多次实例，(Ha){,5}将匹配 0 到 5 次实例。花括号让正则表达式更简短。

4.贪心和非贪心匹配

在字符串’HaHaHaHaHa’中，因为(Ha){3,5}可以匹配 3 个、4 个或 5 个实例，你可能会想，为什么在前面花括号的例子中，**Match 对象的 group()调用会返回’HaHaHaHaHa’，而不是更短的可能结果。**毕竟，'HaHaHa’和’HaHaHaHa’也能够有效地匹配正则表达式(Ha){3,5}。

Python 的正则表达式默认是“贪心”的，这表示在有二义的情况下，它们会尽可能匹配最长的字符串。
花括号的“非贪心”版本匹配尽可能最短的字符串，即在结束的花括号后跟着一个问号。

greedyHaRegex = re.compile(r'(Ha){3,5}')
mo1 = greedyHaRegex.search('HaHaHaHaHa')
mo1.group() # 'HaHaHaHaHa'
nongreedyHaRegex = re.compile(r'(Ha){3,5}?')
mo2 = nongreedyHaRegex.search('HaHaHaHaHa')
mo2.group() # 'HaHaHa'

注意问号在正则表达式中可能有两种含义：声明非贪心匹配或表示可选的分组。这两种含义是完全无关的。

5.findall()方法

除了search方法外，Regex对象也有一个findall()方法。search()将返回一个Match对象，包含被查找字符串中的“第一次”匹配的文本，而 findall()方法将返回一组字符串，包含被查找字符串中的所有匹配。

phoneNumRegex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d')
mo = phoneNumRegex.search('Cell: 415-555-9999 Work: 212-555-0000')
mo.group()  
# '415-555-9999'

"findall()不是返回一个 Match 对象，而是返回一个字符串列表，只要在正则表达式中没有分组。列表中的每个字符串都是一段被查找的文本，它匹配该正则表达式。"
phoneNumRegex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d') # has no groups 
phoneNumRegex.findall('Cell: 415-555-9999 Work: 212-555-0000')  
# ['415-555-9999', '212-555-0000']

"如果在正则表达式中有分组，那么 findall 将返回元组的列表。"
phoneNumRegex = re.compile(r'(\d\d\d)-(\d\d\d)-(\d\d\d\d)') # has groups
phoneNumRegex.findall('Cell: 415-555-9999 Work: 212-555-0000')  
# [('415', '555', '1122'), ('212', '555', '0000')]

作为 findall()方法的返回结果的总结，请记住下面两点：

如果调用在一个没有分组的正则表达式上，例如\d\d\d-\d\d\d-\d\d\d\d，方法findall()将返回一个匹配字符串的列表，例如[‘415-555-9999’, ‘212-555-0000’]。
如果调用在一个有分组的正则表达式上，例如(\d\d\d)-(\d\d\d)-(\d\d\d\d)，方法 findall()将返回一个字符串的元组的列表（每个分组对应一个字符串），例如[(‘415’, ‘555’, ‘1122’), (‘212’, ‘555’, ‘0000’)]。

6.字符分类

缩写字符分类	表示
\d	0 到 9 的任何数字
\D	除 0 到 9 的数字以外的任何字符
\w	任何字母、数字或下划线字符（可以认为是匹配“单词”字符）
\W	除字母、数字和下划线以外的任何字符
\s	空格、制表符或换行符（可以认为是匹配“空白”字符）
\S	除空格、制表符和换行符以外的任何字符

"正则表达式\d+\s\w+匹配的文本有一个或多个数字(\d+)，接下来是一个空白字符(\s)，接下来是一个或多个字母/数字/下划线字符(\w+)"
xmasRegex = re.compile(r'\d+\s\w+')
xmasRegex.findall('12 drummers, 11 pipers, 10 lords, 9 ladies, 8 maids, 7swans, 6 geese, 5 rings, 4 birds, 3 hens, 2 doves, 1 partridge') 
# ['12 drummers', '11 pipers', '10 lords', '9 ladies', '8 maids', '7 swans', '6geese', '5 rings', '4 birds', '3 hens', '2 doves', '1 partridge']

7.建立自己的字符分类

有时候你想匹配一组字符，但缩写的字符分类（\d、\w、\s 等）太宽泛。你可以用方括号定义自己的字符分类。

"字符分类[aeiouAEIOU]将匹配所有元音字符，不论大小写。"
vowelRegex = re.compile(r'[aeiouAEIOU]')
vowelRegex.findall('RoboCop eats baby food. BABY FOOD.') 
# ['o', 'o', 'o', 'e', 'a', 'a', 'o', 'o', 'A', 'O', 'O']

也可以使用短横表示字母或数字的范围。例如，字符分类[a-zA-Z0-9]将匹配所有小写字母、大写字母和数字。

注意
在方括号内，普通的正则表达式符号不会被解释。这意味着，你不需要前面加上倒斜杠转义.、*、?或()字符。例如，字符分类将匹配数字 0 到 5 和一个句点。你不需要将它写成[0-5.]。

通过在字符分类的左方括号后加上一个插入字符^，就可以得到“非字符类”。非字符类将匹配不在这个字符类中的所有字符。

consonantRegex = re.compile(r'[^aeiouAEIOU]')
consonantRegex.findall('RoboCop eats baby food. BABY FOOD.')
# ['R', 'b', 'c', 'p', ' ', 't', 's', ' ', 'b', 'b', 'y', ' ', 'f', 'd', '.', '', 'B', 'B', 'Y', ' ', 'F', 'D', '.']

8.插入字符和美元字符

可以在正则表达式的开始处使用插入符号^，表明匹配必须发生在被查找文本开始处。
类似地，可以再正则表达式的末尾加上美元符号$，表示该字符串必须以这个正则表达式的模式结束。
可以同时使用^和$，表明整个字符串必须匹配该模式，也就是说，只匹配该字符串的某个子集是不够的。

"正则表达式 r'^Hello'匹配以'Hello'开始的字符串"
beginsWithHello = re.compile(r'^Hello') 
beginsWithHello.search('Hello world!')
# <_sre.SRE_Match object; span=(0, 5), match='Hello'>
beginsWithHello.search('He said hello.') == None
# True

"正则表达式 r'\d$'匹配以数字 0 到 9 结束的字符串。"
endsWithNumber = re.compile(r'\d$')
endsWithNumber.search('Your number is 42')
# <_sre.SRE_Match object; span=(16, 17), match='2'>
endsWithNumber.search('Your number is forty two.') == None
# True

"正则表达式 r'^\d+$'匹配从开始到结束都是数字的字符串。"
wholeStringIsNum = re.compile(r'^\d+$') 
wholeStringIsNum.search('1234567890')
# <_sre.SRE_Match object; span=(0, 10), match='1234567890'>
wholeStringIsNum.search('12345xyz67890') == None
# True
wholeStringIsNum.search('12 34567890') == None
# True

注意
如果使用了^和$，那么整个字符串必须匹配该正则表达式。

9.通配字符

在正则表达式中，.（句点）字符称为“通配符”。它匹配除了换行之外的所有字符。要记住，句点字符只匹配一个字符

atRegex = re.compile(r'.at')
atRegex.findall('The cat in the hat sat on the flat mat.')
# ['cat', 'hat', 'sat', 'lat', 'mat']

9.1 用点-星匹配所有字符

有时候想要匹配所有字符串。例如，假定想要匹配字符串’First Name:‘，接下来是任意文本，接下来是’Last Name:’，然后又是任意文本。可以用点-星（.*）表示“任意文本”。

nameRegex = re.compile(r'First Name: (.*) Last Name: (.*)')
mo = nameRegex.search('First Name: Al Last Name: Sweigart')
mo.group(1)
# 'Al'
mo.group(2)
# 'Sweigart'

点-星使用“贪心”模式：它总是匹配尽可能多的文本。要用“非贪心”模式匹配所有文本，就使用点-星和问号。

nongreedyRegex = re.compile(r'<.*?>')
mo = nongreedyRegex.search('<To serve man> for dinner.>')
mo.group()
# '<To serve man>'
greedyRegex = re.compile(r'<.*>')
mo = greedyRegex.search('<To serve man> for dinner.>')
mo.group()
# '<To serve man> for dinner.>'

9.2 用句点字符匹配换行

点-星将匹配除换行外的所有字符。通过传入 re.DOTALL 作为 re.compile()的第二个参数，可以让句点字符匹配所有字符，包括换行字符。

noNewlineRegex = re.compile('.*')
noNewlineRegex.search('Serve the public trust.\nProtect the innocent. \nUphold the law.').group()
# 'Serve the public trust.'
newlineRegex = re.compile('.*', re.DOTALL)
newlineRegex.search('Serve the public trust.\nProtect the innocent.\nUphold the law.').group()
# 'Serve the public trust.\nProtect the innocent.\nUphold the law.'

10 正则表达式符号总结

?匹配零次或一次前面的分组。
*匹配零次或多次前面的分组。
+匹配一次或多次前面的分组。
{n}匹配 n 次前面的分组。
{n,}匹配 n 次或更多前面的分组。
{,m}匹配零次到 m 次前面的分组。
{n,m}匹配至少 n 次、至多 m 次前面的分组。
{n,m}?或*?或+?对前面的分组进行非贪心匹配。
^spam 意味着字符串必须以 spam 开始。
spam$意味着字符串必须以 spam 结束。
.匹配所有字符，换行符除外。
\d、\w 和\s 分别匹配数字、单词和空格。
\D、\W 和\S 分别匹配出数字、单词和空格外的所有字符。
[abc]匹配方括号内的任意字符（诸如 a、b 或 c）。
[^abc]匹配不在方括号内的任意字符。

11 不区分大小写

向 re.compile()传入 re.IGNORECASE 或 re.I，作为第二个参数。

robocop = re.compile(r'robocop', re.I)
robocop.search('RoboCop is part man, part machine, all cop.').group()
# 'RoboCop'
robocop.search('ROBOCOP protects the innocent.').group() 
# 'ROBOCOP'
robocop.search('Al, why does your programming book talk about robocop so much?').group() 
# 'robocop'

12 用sub()方法代替字符串

Regex正则表达式不仅能找到文本模式，而且能够用新的文本替换掉这些模式。对象的 sub()方法需要传入两个参数。第一个参数是一个字符串，用于取代发现的匹配。第二个参数是一个字符串，即正则表达式。sub()方法返回替换完成后的字符串。

namesRegex = re.compile(r'Agent \w+')
namesRegex.sub('CENSORED', 'Agent Alice gave the secret documents to Agent Bob.')
# 'CENSORED gave the secret documents to CENSORED.'

有时候，你可能需要使用匹配的文本本身，作为替换的一部分。在 sub()的第一个参数中，可以输入\1、\2、\3……。表示“在替换中输入分组 1、2、3……的文本”。

例如，假定想要隐去密探的姓名，只显示他们姓名的第一个字母。要做到这一点，可以使用正则表达式 Agent (\w)\w*，传入 r’\1****'作为 sub()的第一个参数。字符串中的\1 将由分组 1 匹配的文本所替代，也就是正则表达式的(\w)分组。

agentNamesRegex = re.compile(r'Agent (\w)\w*') 
agentNamesRegex.sub(r'\1****', 'Agent Alice told Agent Carol that Agent Eve knew Agent Bob was a double agent.')
# A**** told C**** that E**** knew B**** was a double agent.'

13 管理复杂的正则表达式

如果要匹配的文本模式很简单，正则表达式就很好。但匹配复杂的文本模式，可能需要长的、费解的正则表达式。你可以告诉 re.compile()，忽略正则表达式字符串中的空白符和注释，从而缓解这一点。要实现这种详细模式，可以向 re.compile()传入变量 re.VERBOSE，作为第二个参数。

"现在，不必使用这样难以阅读的正则表达式："
phoneRegex = re.compile(r'((\d{3}|\(\d{3}\))?(\s|-|\.)?\d{3}(\s|-|\.)\d{4}(\s*(ext|x|ext.)\s*\d{2,5})?)')

"你可以将正则表达式放在多行中，并加上注释，像这样："
phoneRegex = re.compile(r'''(       # 三重引号('")，创建了一个多行字符串。这样就可以将正则表达式定义放在多行中，让它更可读。
    (\d{3}|\(\d{3}\))?              # area code
    (\s|-|\.)?                      # separator
    \d{3}                           # first 3 digits
    (\s|-|\.)                       # separator
    \d{4}                           # last 4 digits
    (\s*(ext|x|ext.)\s*\d{2,5})?    # extension
    )''', re.VERBOSE)

14 组合使用re.IGNORECASE、re.DOTALL和re.VERBOSE

如果你希望在正则表达式中使用 re.VERBOSE 来编写注释，还希望使用re.IGNORECASE 来忽略大小写，该怎么办？遗憾的是，re.compile()函数只接受一
个值作为它的第二参数。可以使用管道字符（|）将变量组合起来，从而绕过这个限制。管道字符在这里称为“按位或”操作符。

someRegexValue = re.compile('foo', re.IGNORECASE | re.DOTALL)

参考“Python编程快速上手—让繁琐工作自动化, [美] Al Sweigart 著王海鹏译”

低着头走上坡路

关注

32
点赞
踩
24

收藏

觉得还不错? 一键收藏
0
评论
python 正则表达式详解

步骤1．用 import re 导入正则表达式模块。2．用 re.compile()函数创建一个 Regex 对象（记得使用原始字符串）。3．向 Regex 对象的 search()方法传入想查找的字符串。它返回一个 Match 对象。4．调用 Match 对象的 group()方法，返回实际匹配文本的字符串。?匹配零次或一次前面的分组。*匹配零次或多次前面的分组。+匹配一次或多次前面的分组。{n}匹配 n 次前面的分组。{n,}匹配 n 次或更多前面的分组。
复制链接

扫一扫

专栏目录