我心中的王者：Python-第16章正则表达式(Regular Expression)

关注

原创最新推荐文章于 2026-09-12 09:52:27 发布 1.4k 阅读 AI 写同款· GEO 优化 ›

python使用正则表达式（Regular Expression）方法超详细一、导入re库 python使用正则表达式要导入re库。 import re 在re库中。正则表达式通常被用来检索查找、替换那些符合某个模式(规则)的文本。二、使用正则表达式步骤 1、寻找规律； 2、使用正则符号表示规律； 3、提取信息，如果每一个字符都能匹配，则匹配成功；一旦有匹配不成功的字符则匹配失败。三、正则表达式中常见的基本符号 1．点号“.” 一个点号可以代替除了换行符（\n）以外的任何一个字符，包括但不限于英文字母、数字、汉字、英文标点符号和中文标点符号。 2．星号“*” 一个星号可以表示它前面的一个子表达式（普通字符、另一个或几个正则表达式符号）0次到无限立即下载

我心中的王者：Python-第16章　正则表达式(Regular Expression)

正则表达式(Regular Expression)主要功能是执行模式的比对与搜寻，甚至Word文件也可以使用正则表达式处理搜寻(search)与取代(replace)功能，本章首先会介绍如果没用正则表达式，如何处理搜寻文字功能，再介绍使用正则表达式处理这类问题，读者会发现整个工作变得更简洁容易。

16-1　使用Python硬功夫搜寻文字

如果现在打开手机的联络信息可以看到，台湾手机号码的格式如下：

 0952-282-020  # 可以表示为xxxx-xxx-xxx，每个x代表一个0-9数字

从上述可以发现手机号码格式是由4个数字，1个连字符号，3个数字，1个连字符号，3个数字所组成。

程序实例ch16_1.py：用传统知识设计一个程序，然后判断字符串是否含有台湾的手机号码格式。

# ch16_1.py
def taiwanPhoneNum(string):
    """检查是否有含手机联络信息的台湾手机号码格式"""
    if len(string) != 12:       # 如果长度不是12
        return False            # 传回非手机号码格式
    
    for i in range(0, 4):       # 如果前4个字出现非数字字符
        if string[i].isdecimal() == False:
            return False        # 传回非手机号码格式
        
    if string[4] != '-':        # 如果不是'-'字符
        return False            # 传回非手机号码格式
   
    for i in range(5, 8):       # 如果中间3个字出现非数字字符
        if string[i].isdecimal() == False:
            return False        # 传回非手机号码格

    if string[8] != '-':        # 如果不是'-'字符
        return False            # 传回非手机号码格式

    for i in range(9, 12):      # 如果最后3个字出现非数字字符
        if string[i].isdecimal() == False:
            return False        # 传回非手机号码格
    return True                 # 通过以上测试

print("I love Ming-Chi: 是台湾手机号码", taiwanPhoneNum('I love Ming-Chi'))
print("0932-999-199:    是台湾手机号码", taiwanPhoneNum('0932-999-199'))

执行结果

I love Ming-Chi: 是台湾手机号码 False
0932-999-199:    是台湾手机号码 True

上述程序第4和5行是判断字符串长度是否12，如果不是则表示这不是手机号码格式。程序第7至9行是判断字符串前4码是不是数字，如果不是则表示这不是手机号码格式。程序第11至12行是判断这个字符是不是‘-’，如果不是则表示这不是手机号码格式。程序第14至16行是判断字符串索引[5][6][7]码是不是数字，如果不是则表示这不是手机号码格式。程序第18至19行是判断这个字符是不是‘-’，如果不是则表示这不是手机号码格式。程序第21至23行是判断字符串索引[9][10][11]码是不是数字，如果不是则表示这不是手机号码格式。如果通过了以上所有测试，表示这是手机号码格式，程序第24行传回True。

在真实的环境应用中，我们可能需面临一段文字，这段文字内穿插一些数字，然后我们必须将手机号码从这段文字抽离出来。

程序实例ch16_2.py：将电话号码从一段文字抽离出来。

# ch16_2.py
def taiwanPhoneNum(string):
    """检查是否有含手机联络信息的台湾手机号码格式"""
    if len(string) != 12:       # 如果长度不是12
        return False            # 传回非手机号码格式
    
    for i in range(0, 4):       # 如果前4个字出现非数字字符
        if string[i].isdecimal() == False:
            return False        # 传回非手机号码格式
        
    if string[4] != '-':        # 如果不是'-'字符
        return False            # 传回非手机号码格式
   
    for i in range(5, 8):       # 如果中间3个字出现非数字字符
        if string[i].isdecimal() == False:
            return False        # 传回非手机号码格

    if string[8] != '-':        # 如果不是'-'字符
        return False            # 传回非手机号码格式

    for i in range(9, 12):      # 如果最后3个字出现非数字字符
        if string[i].isdecimal() == False:
            return False        # 传回非手机号码格
    return True                 # 通过以上测试

def parseString(string):
    """解析字符串是否含有电话号码"""
    notFoundSignal = True       # 注记没有找到电话号码为True
    for i in range(len(string)):  # 用循环逐步抽取12个字符做测试
        msg = string[i:i+12]
        if taiwanPhoneNum(msg):
            print("电话号码是: %s" % msg)
            notFoundSignal = False        
    if notFoundSignal:          # 如果没有找到电话号码则打印
        print("%s 字符串不含电话号码" % string)

msg1 = 'Please call my secretary using 0930-919-919 or 0952-001-001'
msg2 = '请明天17:30和我一起参加明志科大教师节晚餐'
msg3 = '请明天17:30和我一起参加明志科大教师节晚餐, 可用0933-080-080联络我'
parseString(msg1)
parseString(msg2)
parseString(msg3)

执行结果

电话号码是: 0930-919-919
电话号码是: 0952-001-001
请明天17:30和我一起参加明志科大教师节晚餐 字符串不含电话号码
电话号码是: 0933-080-080

从上述执行结果可以得知我们成功地从一个字符串分析，然后将电话号码分析出来了。分析方式的重点是程序第26行到35行的parseString函数，这个函数重点是第29至33行，这个循环会逐步抽取字符串的12个字符做比对，将比对字符串放在msg字符串变量内，下列是各循环次序的msg字符串变量内容。
在这里插入图片描述

程序第28行将没有找到电话号码notFoundSignal设为True，如果有找到电话号码程序33行将notFoundSignal标示为False，当parseString( )函数执行完，notFoundSignal仍是True，表示没找到电话号码，所以第35行打印字符串不含电话号码。

上述使用所学的Python硬功夫虽然解决了我们的问题，但是若是将电话号码改成中国大陆手机号(xxx-xxxx-xxxx)、美国手机号(xxx-xxx-xxxx)或是一般公司行号的电话，整个号码格式不一样，要重新设计可能需要一些时间。不过不用担心，接下来笔者将讲解的Python的正则表达式可以轻松解决上述困扰。

16-2　正则表达式的基础

Python有关正则表达式的方法是在re模块内，所以使用正则表达式需要导入re模块。

import re # 导入re模块

16-2-1　建立搜寻字符串模式

在前一节我们使用isdecimal( )方法判断字符是否是0—9的数字。

正则表达式是一种文本模式的表达方法，在这个方法中使用\d表示0—9的数字字符，采用这个观念我们可以将前一节的手机号码xxxx-xxx-xxx改用下列正则表达方式表示：

 '\d\d\d\d-\d\d\d-\d\d\d'

由逸出字符的观念可知，将上述表达式当字符串放入函数内需增加‘\’，所以整个正则表达式的使用方式如下：

 '\\d\\d\\d\\d-\\d\\d\\d-\\d\\d\\d'

在3-4-9小节笔者有介绍字符串前加r可以防止字符串内的逸出字符被转译，所以又可以将上述正则表达式简化为下列格式：

 r'\d\d\d\d-\d\d\d-\d\d\d'

16-2-2　使用re.compile( )建立Regex对象

Regex是Regular expression的简称，在re模块内有compile( )方法，可以将16-2-1节的欲搜寻字符串的正则表达式当作字符串参数放在此方法内，然后会传回一个Regex对象。如下所示：

   phoneRule = re.compile(r'\d\d\d\d-\d\d\d-\d\d\d') # 建立phoneRule对象

16-2-3　搜寻对象

在Regex对象内有search( )方法，可以由Regex对象启用，然后将欲搜寻的字符串放在这个方法内，沿用上述观念程序片段如下：

 phoneNum = phoneRule.search(msg)  # msg是欲搜寻的字符串

如果找不到比对相符的字符串会传回None，如果找到比对相符的字符串会将结果传回所设定的phoneNum变量对象，这个对象在Python中称之为MatchObject对象，将在16-6节完整解说。现在笔者将介绍实用性较高的部分，处理此对象主要是将搜寻结果传回，我们可以用group( )方法将结果传回，不过search( )将只传回第一个比对相符的字符串。

程序实例ch16_3.py：使用正则表达式重新设计ch16_2.py。

# ch16_3.py
import re

msg1 = 'Please call my secretary using 0930-919-919 or 0952-001-001'
msg2 = '请明天17:30和我一起参加明志科大教师节晚餐'
msg3 = '请明天17:30和我一起参加明志科大教师节晚餐, 可用0933-080-080联络我'

def parseString(string):
    """解析字符串是否含有电话号码"""
    phoneRule = re.compile(r'\d\d\d\d-\d\d\d-\d\d\d')
    phoneNum = phoneRule.search(string)
    if phoneNum != None:        # 检查phoneNum内容
        print("电话号码是: %s" % phoneNum.group())
    else:
        print("%s 字符串不含电话号码" % string)

parseString(msg1)
parseString(msg2)
parseString(msg3)

执行结果

电话号码是: 0930-919-919
请明天17:30和我一起参加明志科大教师节晚餐 字符串不含电话号码
电话号码是: 0933-080-080

在程序实例ch16_2.py我们使用了约21行做字符串解析，当我们使用Python的正则表达式时，只用第10和11行共2行就解析了字符串是否含手机号码了，整个程序变得简单许多。不过上述msg1字符串内含2组手机号码，使用search( )只传回第一个发现的号码，下一节将改良此方法。

16-2-4　findall( )

从方法的名字就可以知道，这个方法可以传回所有找到的手机号码。这个方法会将搜寻到的手机号码用列表方式传回，这样就不会有只显示第一个搜寻到的手机号码的缺点，如果没有比对相符的号码就传回[ ]空列表。要使用这个方法的关键指令如下：

  phoneRule = re.compile(r'\d\d\d\d-\d\d\d-\d\d\d') # 建立phoneRule对象
  phoneNum = phoneRule.findall(string)                 # string是欲搜寻的字符串

findall( )函数由phoneRule对象启用，最后会将搜寻结果的列表传给phoneNum，只要打印phoneNum就可以得到执行结果。

程序实例ch16_4.py：使用findall( )搜寻字符串，第10行定义正则表达式，打印结果。

# ch16_4.py
import re

msg1 = 'Please call my secretary using 0930-919-919 or 0952-001-001'
msg2 = '请明天17:30和我一起参加明志科大教师节晚餐'
msg3 = '请明天17:30和我一起参加明志科大教师节晚餐, 可用0933-080-080联络我'

def parseString(string):
    """解析字符串是否含有电话号码"""
    phoneRule = re.compile(r'\d\d\d\d-\d\d\d-\d\d\d')
    phoneNum = phoneRule.findall(string)     # 用列表传回搜寻结果
    print("电话号码是: %s" % phoneNum)       # 列表方式显示电话号码

parseString(msg1)
parseString(msg2)
parseString(msg3)

执行结果

电话号码是: ['0930-919-919', '0952-001-001']
电话号码是: []
电话号码是: ['0933-080-080']

16-2-5　再看re模块

其实Python语言的re模块对于search( )和findall( )有提供更强的功能，可以省略使用re.compile( )直接将比对模式放在各自的参数内，此时语法格式如下：

   re.search(pattern, string, flags)
   re.findall(pattern, string, flags)

上述pattern是欲搜寻的正则表达方式，string是所搜寻的字符串，flags可以省略，未来会介绍几个flags常用相关参数的应用。

程序实例ch16_5.py：使用re.search( )重新设计ch16_3.py，由于省略了re.compile( )，所以读者需留意第11行内容写法。

# ch16_5.py
import re

msg1 = 'Please call my secretary using 0930-919-919 or 0952-001-001'
msg2 = '请明天17:30和我一起参加明志科大教师节晚餐'
msg3 = '请明天17:30和我一起参加明志科大教师节晚餐, 可用0933-080-080联络我'

def parseString(string):
    """解析字符串是否含有电话号码"""
    pattern = r'\d\d\d\d-\d\d\d-\d\d\d'
    phoneNum = re.search(pattern, string)
    if phoneNum != None:        # 如果phoneNum不是None表示取得号码
        print("电话号码是: %s" % phoneNum.group())
    else:
        print("%s 字符串不含电话号码" % string)

parseString(msg1)
parseString(msg2)
parseString(msg3)

执行结果　与ch16_3.py相同。

程序实例ch16_6.py：使用re.findall( )重新设计ch16_4.py，由于省略了re.compile( )，所以读者需留意第11行内容写法。

# ch16_6.py
import re

msg1 = 'Please call my secretary using 0930-919-919 or 0952-001-001'
msg2 = '请明天17:30和我一起参加明志科大教师节晚餐'
msg3 = '请明天17:30和我一起参加明志科大教师节晚餐, 可用0933-080-080联络我'

def parseString(string):
    """解析字符串是否含有电话号码"""
    pattern = r'\d\d\d\d-\d\d\d-\d\d\d'
    phoneNum = re.findall(pattern, string)   # 用列表传回搜寻结果
    print("电话号码是: %s" % phoneNum)       # 列表方式显示电话号码

parseString(msg1)
parseString(msg2)
parseString(msg3)

执行结果　与ch16_4.py相同。

16-2-6　再看正则表达式

下列是我们目前的正则表达式所搜寻的字符串模式：

 r'\d\d\d\d-\d\d\d-\d\d\d'

其中可以看到\d重复出现，对于重复出现的字符串可以用大括号内部加上重复次数方式表达，所以上述可以用下列方式表达。

 r'\d{4}-\d{3}-\d{3}'

程序实例ch16_7.py：使用本节观念重新设计ch16_6.py，下列只列出不一样的程序内容。
在这里插入图片描述

# ch16_7.py
import re

msg1 = 'Please call my secretary using 0930-919-919 or 0952-001-001'
msg2 = '请明天17:30和我一起参加明志科大教师节晚餐'
msg3 = '请明天17:30和我一起参加明志科大教师节晚餐, 可用0933-080-080联络我'

def parseString(string):
    """解析字符串是否含有电话号码"""
    pattern = r'\d{4}-\d{3}-\d{3}'
    phoneNum = re.findall(pattern, string)   # 用列表传回搜寻结果
    print("电话号码是: %s" % phoneNum)       # 列表方式显示电话号码

parseString(msg1)
parseString(msg2)
parseString(msg3)

执行结果　与ch16_4.py相同。

16-3　更多搜寻比对模式

先前我们所用的实例是手机号码，想想看如果我们改用市区电话号码的比对，台北市的电话号码如下：

 02-28350000  # 可用xx-xxxxxxxx表达

下列将以上述电话号码模式说明。

16-3-1　使用小括号分组

依照16-2节的观念，可以用下列正则表示法表达上述市区电话号码。

  r'\d\d-\d\d\d\d\d\d\d\d'

所谓括号分组是以连字符“-”区别，然后用小括号隔开群组，可以用下列方式重新规划上述表达式。也可简化为：

 r'(\d\d)-(\d\d\d\d\d\d\d\d')
 r'(\d{2})-(\d{8})'

当使用re.search( )执行比对时，未来可以使用group( )传回比对符合的不同分组，例如：group( )或group(0)传回第一个比对相符的文字与ch16_3.py观念相同。如果group(1)则传回括号的第一组文字，group(2)则传回括号的第二组文字。

程序实例ch16_8.py：使用小括号分组的观念，将分组内容输出。

# ch16_8.py
import re

msg = 'Please call my secretary using 02-26669999'
pattern = r'(\d{2})-(\d{8})'
phoneNum = re.search(pattern, msg)           # 传回搜寻结果

print("完整号码是: %s" % phoneNum.group())   # 显示完整号码
print("完整号码是: %s" % phoneNum.group(0))  # 显示完整号码
print("区域号码是: %s" % phoneNum.group(1))  # 显示区域号码
print("电话号码是: %s" % phoneNum.group(2))  # 显示电话号码

执行结果

完整号码是: 02-26669999
完整号码是: 02-26669999
区域号码是: 02
电话号码是: 26669999

如果所搜寻比对的正则表达式字符串有用小括号分组，若是使用findall( )方法处理，会传回元组(tuple)的列表(list)，元组内的每个元素就是搜寻的分组内容。

程序实例ch16_9.py：使用findall( )重新设计ch16_8.py，这个实例会多增加一组电话号码。

# ch16_9.py
import re

msg = 'Please call my secretary using 02-26669999 or 02-11112222'
pattern = r'(\d{2})-(\d{8})'
phoneNum = re.findall(pattern, msg)           # 传回搜寻结果
print(phoneNum)

执行结果

[('02', '26669999'), ('02', '11112222')]

16-3-2　groups( )

注意这是groups( )，有在group后面加上s，当我们使用re.search( )搜寻字符串时，可以使用这个方法取得分组的内容。这时还可以使用2-9节的多重指定的观念，若以ch16_8.py为例，在第7行我们可以使用下列多重指定获得区域号码和当地电话号码。

  areaNum, localNum = phoneNum.groups( )  # 多重指定

程序实例ch16_10.py：重新设计ch16_8.py，分别列出区域号码与电话号码。

# ch16_10.py
import re

msg = 'Please call my secretary using 02-26669999'
pattern = r'(\d{2})-(\d{8})'
phoneNum = re.search(pattern, msg)      # 传回搜寻结果
areaNum, localNum = phoneNum.groups()   # 留意是groups()
print("区域号码是: %s" % areaNum)       # 显示区域号码
print("电话号码是: %s" % localNum)      # 显示电话号码

执行结果

区域号码是: 02
电话号码是: 26669999

16-3-3　区域号码是在小括号内

在一般电话号码的使用中，常看到区域号码是用小括号包夹，如下所示：

 (02)-26669999

在处理小括号时，方式是(和)，可参考下列实例。

程序实例ch16_11.py：重新设计ch16_10.py，第4行的区域号码是(02)，读者需留意第4行和第5行的设计。

# ch16_11.py
import re

msg = 'Please call my secretary using (02)-26669999'
pattern = r'(\(\d{2}\))-(\d{8})'
phoneNum = re.search(pattern, msg)      # 传回搜寻结果
areaNum, localNum = phoneNum.groups()   # 留意是groups()
print("区域号码是: %s" % areaNum)       # 显示区域号码
print("电话号码是: %s" % localNum)      # 显示电话号码

执行结果

区域号码是: (02)
电话号码是: 26669999

16-3-4　使用管道|

|(pipe)在正规表示法称管道，使用管道我们可以同时搜寻比对多个字符串，例如，想要搜寻Mary和Tom字符串，可以使用下列表示。

pattern = 'Mary|Tom'  # 注意单引号'或|旁不可留空白

程序实例ch16_12.py：管道搜寻多个字符串的实例。

# ch16_12.py
import re

msg = 'John and Tom will attend my party tonight. John is my best friend.'
pattern = 'John|Tom'                # 搜寻John和Tom
txt = re.findall(pattern, msg)      # 传回搜寻结果
print(txt)
pattern = 'Mary|Tom'                # 搜寻Mary和Tom
txt = re.findall(pattern, msg)      # 传回搜寻结果
print(txt)

执行结果

['John', 'Tom', 'John']
['Tom']

16-3-5　多个分组的管道搜寻

假设有一个字符串内容如下：

 Johnson, Johnnason and Johnnathan will attend my party tonight.

由上述可知，如果想要搜寻字符串比对John后面可以是son、nason、nathan任一个字符串的组合，可以使用下列正则表达式格式：

 pattern = John(son|nason|nathan)

程序实例ch16_13.py：搜寻Johnson、Johnnason或Johnnathan任一字符串，然后列出结果，这个程序将列出第一个搜寻比对到的字符串。

# ch16_13.py
import re

msg = 'Johnson, Johnnason and Johnnathan will attend my party tonight.'
pattern = 'John(son|nason|nathan)'
txt = re.search(pattern,msg)    # 传回搜寻结果
print(txt.group())              # 打印第一个搜寻结果
print(txt.group(1))             # 打印第一个分组

执行结果

Johnson
son

同样的正则表达式若是使用findall( )方法处理，将只传回各分组搜寻到的字符串，如果要列出完整的内容，可以用循环同时为每个分组字符串加上前导字符串John。

程序实例ch16_14.py：使用findall( )重新设计ch16_13.py。

# ch16_14.py
import re

msg = 'Johnson, Johnnason and Johnnathan will attend my party tonight.'
pattern = 'John(son|nason|nathan)'
txts = re.findall(pattern,msg)      # 传回搜寻结果
print(txts)
for txt in txts:                    # 将搜寻到内容加上John
    print('John'+txt)

执行结果

['son', 'nason', 'nathan']
Johnson
Johnnason
Johnnathan

16-3-6　使用？号做搜寻

在正则表达式中若某些括号内的字符串或正则表达式可有可无，执行搜寻时皆算成功，例如，na字符串可有可无，表达方式是(na)?。

程序实例ch16_15.py：使用？搜寻的实例，这个程序会测试2次。

# ch16_15.py
import re
# 测试1
msg = 'Johnson will attend my party tonight.'
pattern = 'John((na)?son)'
txt = re.search(pattern,msg)      # 传回搜寻结果
print(txt.group())
# 测试2
msg = 'Johnnason will attend my party tonight.'
pattern = 'John((na)?son)'
txt = re.search(pattern,msg)      # 传回搜寻结果
print(txt.group())

执行结果

Johnson
Johnnason

有时候如果居住在同一个城市，在留电话号码时，可能不会留区域号码，这时就可以使用本功能了。请参考下列实例第11行。

程序实例ch16_16.py：这个程序在搜寻电话号码时，即使省略区域号码程序也可以搜寻到此号码，然后打印出来，正则表达式格式请留意第6行。

# ch16_16.py
import re

# 测试1
msg = 'Please call my secretary using 02-26669999'
pattern = r'(\d\d-)?(\d{8})'                 # 增加?号
phoneNum = re.search(pattern, msg)           # 传回搜寻结果
print("完整号码是: %s" % phoneNum.group())   # 显示完整号码

# 测试2
msg = 'Please call my secretary using 26669999'
pattern = r'(\d\d-)?(\d{8})'                 # 增加?号
phoneNum = re.search(pattern, msg)           # 传回搜寻结果
print("完整号码是: %s" % phoneNum.group())   # 显示完整号码

执行结果

完整号码是: 02-26669999
完整号码是: 26669999

16-3-7　使用*号做搜寻

在正则表达式中若某些字符串或正则表达式可从0到多次，执行搜寻时皆算成功，例如，na字符串可从0到多次，表达方式是(na)*。

程序实例ch16_17.py：这个程序的重点是第5行的正则表达式，其中字符串na的出现次数可以是从0到多次。

# ch16_17.py
import re
# 测试1
msg = 'Johnson will attend my party tonight.'
pattern = 'John((na)*son)'        # 字符串na可以0到多次
txt = re.search(pattern,msg)      # 传回搜寻结果
print(txt.group())
# 测试2
msg = 'Johnnason will attend my party tonight.'
pattern = 'John((na)*son)'        # 字符串na可以0到多次
txt = re.search(pattern,msg)      # 传回搜寻结果
print(txt.group())
# 测试3
msg = 'Johnnananason will attend my party tonight.'
pattern = 'John((na)*son)'        # 字符串na可以0到多次
txt = re.search(pattern,msg)      # 传回搜寻结果
print(txt.group())

执行结果

Johnson
Johnnason
Johnnananason

16-3-8　使用+号做搜寻

在正则表达式中若是某些字符串或正则表达式可从1到多次，执行搜寻时皆算成功，例如，na字符串可从1到多次，表达方式是(na)+。

程序实例ch16_18.py：这个程序的重点是第5行的正则表达式，其中字符串na的出现次数可以是从1到多次。

# ch16_18.py
import re
# 测试1
msg = 'Johnson will attend my party tonight.'
pattern = 'John((na)+son)'        # 字符串na可以1到多次
txt = re.search(pattern,msg)      # 传回搜寻结果
print(txt)                        # 请注意是直接打印对象
# 测试2
msg = 'Johnnason will attend my party tonight.'
pattern = 'John((na)+son)'        # 字符串na可以1到多次
txt = re.search(pattern,msg)      # 传回搜寻结果
print(txt.group())
# 测试3
msg = 'Johnnananason will attend my party tonight.'
pattern = 'John((na)+son)'        # 字符串na可以1到多次
txt = re.search(pattern,msg)      # 传回搜寻结果
print(txt.group())

执行结果

None
Johnnason
Johnnananason

16-3-9　搜寻时忽略大小写

搜寻时若是在search( )或findall( )内增加第三个参数re.I或re.IGNORECASE，搜寻时就会忽略大小写，至于打印输出时将以原字符串的格式显示。

程序实例ch16_19.py：以忽略大小写方式执行找寻相符字符串。

# ch16_19.py
import re

msg = 'john and TOM will attend my party tonight. JOHN is my best friend.'
pattern = 'John|Tom'                        # 搜寻John和Tom
txt = re.findall(pattern, msg, re.I)        # 传回搜寻忽略大小写的结果
print(txt)
pattern = 'Mary|tom'                        # 搜寻Mary和tom
txt = re.findall(pattern, msg, re.I)        # 传回搜寻忽略大小写的结果
print(txt)

执行结果

['john', 'TOM', 'JOHN']
['TOM']

16-4　贪婪与非贪婪搜寻

16-4-1　搜寻时使用大括号设定比对次数

在16-2-6节我们有使用过大括号，当时讲解\d{4}代表重复4次，也就是大括号的数字是设定重复次数。可以将这个观念应用在搜寻一般字符串，例如，(son){3}代表所搜寻的字符串是‘sonsonson’，如果有一字符串是‘sonson’，则搜寻结果是不符。大括号除了可以设定重复次数，也可以设定指定范围，例如，(son){3,5}代表所搜寻的字符串如果是‘sonsonson’‘sonsonsonson’或‘sonsonsonsonson’皆算是相符合的字符串。(son){3,5}正则表达式相当于下列表达式：

((son)(son)(son))|((son)(son)(son)(son))|((son)(son)(son)(son)(son))

程序实例ch16_20.py：设定搜寻son字符串重复3-5次皆算搜寻成功。

# ch16_20.py
import re

def searchStr(pattern, msg):
    txt = re.search(pattern, msg)
    if txt == None:         # 搜寻失败
        print("搜寻失败 ",txt)
    else:                   # 搜寻成功
        print("搜寻成功 ",txt.group())

msg1 = 'son'
msg2 = 'sonson'
msg3 = 'sonsonson'
msg4 = 'sonsonsonson'
msg5 = 'sonsonsonsonson'
pattern = '(son){3,5}'
searchStr(pattern,msg1)
searchStr(pattern,msg2)
searchStr(pattern,msg3)
searchStr(pattern,msg4)
searchStr(pattern,msg5)

执行结果

搜寻失败  None
搜寻失败  None
搜寻成功  sonsonson
搜寻成功  sonsonsonson
搜寻成功  sonsonsonsonson

使用大括号时，也可以省略第一或第二个数字，这相当于不设定最小或最大重复次数。例如：(son){3,}代表重复3次以上皆符合，(son){,10}代表重复10次以下皆符合。有关这方面的实作，将留给读者练习，可参考习题3。

16-4-2　贪婪与非贪婪搜寻

在讲解贪婪与非贪婪搜寻前，笔者先简化程序实例ch16_20.py，使用相同的搜寻模式‘(son){3,5}’，搜寻字符串是‘sonsonsonsonson’，看看结果。

程序实例ch16_21.py：使用搜寻模式‘(son){3,5}’，搜寻字符串‘sonsonsonsonson’。

# ch16_21.py
import re

def searchStr(pattern, msg):
    txt = re.search(pattern, msg)
    if txt == None:         # 搜尋失敗
        print("搜尋失敗 ",txt)
    else:                   # 搜尋成功
        print("搜尋成功 ",txt.group())

msg = 'sonsonsonsonson'
pattern = '(son){3,5}'
searchStr(pattern,msg)

执行结果

搜尋成功  sonsonsonsonson

其实由上述程序所设定的搜寻模式可知3、4或5个son重复就算找到了，可是Python执行结果是列出最多重复的字符串，5次重复，这是Python的默认模式，这种模式又称贪婪(greedy)模式。

另一种是列出最少重复的字符串，以这个实例而言是重复3次，这称非贪婪模式，方法是在正则表达式的搜寻模式右边增加？符号。

程序实例ch16_22.py：以非贪婪模式重新设计ch16_21.py，请读者留意第12行的正则表达式的搜寻模式最右边的？符号。
在这里插入图片描述

# ch16_22.py
import re

def searchStr(pattern, msg):
    txt = re.search(pattern, msg)
    if txt == None:         # 搜寻失败
        print("搜寻失败 ",txt)
    else:                   # 搜寻成功
        print("搜寻成功 ",txt.group())

msg = 'sonsonsonsonson'
pattern = '(son){3,5}?'     # 非贪婪模式
searchStr(pattern,msg)

执行结果

搜寻成功  sonsonson

16-5　正则表达式的特殊字符

为了不让一开始学习正则表达式太复杂，在前面4个小节笔者只介绍了\d，同时穿插介绍一些字符串的搜寻。我们知道\d代表的是数字字符，也就是从0-9的阿拉伯数字，如果使用管道|的观念，\d相当于是下列正则表达式：

(0|1|2|3|4|5|6|7|8|9)

这一节将针对正则表达式的特殊字符做一个完整的说明。

16-5-1　特殊字符表

在这里插入图片描述

下列是一些使用上述表格观念的正则表达式的实例说明。

程序实例ch16_23.py：将一段英文句子的单词分离，同时将英文单词前4个字母是“John”的单词筛选出来。笔者设定如下：

 pattern = ‘\w+'      # 意义是把不限长度的数字、字母和底线字符当作符合搜寻
 pattern = ‘John\w*'  # John开头后面接0～多个数字、字母和底线字符

# ch16_23.py
import re
# 测试1将字符串从句子分离
msg = 'John, Johnson, Johnnason and Johnnathan will attend my party tonight.'
pattern = '\w+'                    # 不限长度的单字
txt = re.findall(pattern,msg)      # 传回搜寻结果
print(txt)
# 测试2将John开始的字符串分离
msg = 'John, Johnson, Johnnason and Johnnathan will attend my party tonight.'
pattern = 'John\w*'                # John开头的单字
txt = re.findall(pattern,msg)      # 传回搜寻结果
print(txt)

执行结果

['John', 'Johnson', 'Johnnason', 'and', 'Johnnathan', 'will', 'attend', 'my', 'party', 'tonight']
['John', 'Johnson', 'Johnnason', 'Johnnathan']

程序实例ch16_24.py：正则表达式的应用，下列程序重点是第5行。

\d+：表示不限长度的数字。

\s：表示空格。

\w+：表示不限长度的数字、字母和底线字符连续字符。

# ch16_24.py
import re

msg = '1 cat, 2 dogs, 3 pigs, 4 swans'
pattern = '\d+\s\w+'
txt = re.findall(pattern,msg)      # 传回搜寻结果
print(txt)

执行结果

['1 cat', '2 dogs', '3 pigs', '4 swans']

16-5-2　字符分类

Python可以使用中括号来设定字符，可参考下列范例。

[a-z]：代表a-z的小写字符。

[A-Z]：代表A-Z的大写字符。

[aeiouAEIOU]：代表英文发音的元音字符。

[2-5]：代表2-5的数字。

在字符分类中，中括号内可以不用放上正则表示法的反斜杠\执行.、?、*、(、)等字符的转译。例如，[2-5.]会搜寻2-5的数字和句点，这个语法不用写成[2-5.]。

程序实例ch16_25.py：搜寻字符的应用，这个程序首先将搜寻[aeiouAEIOU]，然后将搜寻[2-5.]。

# ch16_25.py
import re
# 测试1搜寻[aeiouAEIOU]字符
msg = 'John, Johnson, Johnnason and Johnnathan will attend my party tonight.'
pattern = '[aeiouAEIOU]'           
txt = re.findall(pattern,msg)      # 传回搜寻结果
print(txt)
# 测试2搜寻[2-5.]字符
msg = '1. cat, 2. dogs, 3. pigs, 4. swans'
pattern = '[2-5.]'
txt = re.findall(pattern,msg)      # 传回搜寻结果
print(txt)

执行结果

['o', 'o', 'o', 'o', 'a', 'o', 'a', 'o', 'a', 'a', 'i', 'a', 'e', 'a', 'o', 'i']
['.', '2', '.', '3', '.', '4', '.']

16-5-3　字符分类的^字符

在16-5-2小节字符的处理中，如果在中括号内的左方加上^字符，意义是搜寻不在这些字符内的所有字符。

程序实例ch16_26.py：使用字符分类的^字符重新设计ch16_25.py。

# ch16_26.py
import re
# 测试1搜寻不在[aeiouAEIOU]的字符
msg = 'John, Johnson, Johnnason and Johnnathan will attend my party tonight.'
pattern = '[^aeiouAEIOU]'           
txt = re.findall(pattern,msg)      # 传回搜寻结果
print(txt)
# 测试2搜寻不在[2-5.]的字符
msg = '1. cat, 2. dogs, 3. pigs, 4. swans'
pattern = '[^2-5.]'
txt = re.findall(pattern,msg)      # 传回搜寻结果
print(txt)

执行结果

['J', 'h', 'n', ',', ' ', 'J', 'h', 'n', 's', 'n', ',', ' ', 'J', 'h', 'n', 'n', 's', 'n', ' ', 'n', 'd', ' ', 'J', 'h', 'n', 'n', 't', 'h', 'n', ' ', 'w', 'l', 'l', ' ', 't', 't', 'n', 'd', ' ', 'm', 'y', ' ', 'p', 'r', 't', 'y', ' ', 't', 'n', 'g', 'h', 't', '.']
['1', ' ', 'c', 'a', 't', ',', ' ', ' ', 'd', 'o', 'g', 's', ',', ' ', ' ', 'p', 'i', 'g', 's', ',', ' ', ' ', 's', 'w', 'a', 'n', 's']

上述第一个测试结果不会出现[aeiouAEIOU]字符，第二个测试结果不会出现[2-5.]字符。

16-5-4　正则表示法的^字符

这个^{字符与16-5-3小节的}字符完全相同，但是用在不一样的地方，意义不同。在正规表示法中起始位置加上^字符，表示正则表示法的字符串必须出现在被搜寻字符串的起始位置，这样搜寻成功才算成功。

程序实例ch16_27.py：正则表示法^字符的应用，测试1字符串John是在最前面所以可以得到搜寻结果，测试2字符串John不是在最前面，结果搜寻失败传回空字符串。

# ch16_27.py
import re
# 测试1搜寻John字符串在最前面
msg = 'John will attend my party tonight.'
pattern = '^John'           
txt = re.findall(pattern,msg)      # 传回搜寻结果
print(txt)
# 测试2搜寻John字符串不是在最前面
msg = 'My best friend is John'
pattern = '^John'
txt = re.findall(pattern,msg)      # 传回搜寻结果
print(txt)

执行结果

['John']
[]

16-5-5　正则表示法的$字符

正则表示法的末端放置$字符时，表示正则表示法的字符串必须出现在被搜寻字符串的最后位置，这样搜寻成功才算成功。

程序实例ch16_28.py：正则表示法$字符的应用，测试1是搜寻字符串结尾是非英文字符、数字和底线字符，由于结尾字符是“.”，所以传回所搜寻到的字符。测试2是搜寻字符串结尾是非英文字符、数字和底线字符，由于结尾字符是“8”，所以传回搜寻结果是空字符串。测试3是搜寻字符串结尾是数字字符，由于结尾字符是“8”，所以传回搜寻结果“8”。测试4是搜寻字符串结尾是数字字符，由于结尾字符是“.”，所以传回搜寻结果空字符串。

# ch16_28.py
import re
# 测试1搜寻最后字符是非英文字母数字和底线字符
msg = 'John will attend my party 28 tonight.'
pattern = '\W$'           
txt = re.findall(pattern,msg)      # 传回搜寻结果
print(txt)
# 测试2搜寻最后字符是非英文字母数字和底线字符
msg = 'I am 28'
pattern = '\W$'
txt = re.findall(pattern,msg)      # 传回搜寻结果
print(txt)
# 测试3搜寻最后字符是数字
msg = 'I am 28'
pattern = '\d$'
txt = re.findall(pattern,msg)      # 传回搜寻结果
print(txt)
# 测试4搜寻最后字符是数字
msg = 'I am 28 year old.'
pattern = '\d$'
txt = re.findall(pattern,msg)      # 传回搜寻结果
print(txt)

执行结果

['.']
[]
['8']
[]

我们也可以将16-5-4小节的^字符和$字符混合使用，这时如果既要符合开始字符串也要符合结束字符串，所以被搜寻的句子一定要只有一个字符串。

程序实例ch16_29.py：搜寻开始到结束皆是数字的字符串，字符串内容只要有非数字字符就算搜寻失败。测试2中由于中间有非数字字符，所以搜寻失败。读者应留意程序第5行的正则表达式的写法。

# ch16_29.py
import re
# 测试1搜寻开始或结尾皆是数字的字符串
msg = '09282028222'
pattern = '^\d+$'           
txt = re.findall(pattern,msg)      # 传回搜寻结果
print(txt)
# 测试2搜寻开始或结尾皆是数字的字符串
msg = '0928tuyr990'
pattern = '^\d+$'
txt = re.findall(pattern,msg)      # 传回搜寻结果
print(txt)

执行结果

['09282028222']
[]

16-5-6　单一字符使用通配符“.”

通配符(wildcard)“.”表示可以搜寻除了换行字符以外的所有字符，但是只限定一个字符。

程序实例ch16_30.py：通配符的应用，搜寻一个通配符加上at，在下列输出中，第4个由于at符合，Python自动加上空格符。第6个由于只能加上一个字符，所以搜寻结果是lat。

# ch16_30.py
import re
msg = 'cat hat sat at matter flat'
pattern = '.at'           
txt = re.findall(pattern,msg)      # 传回搜寻结果
print(txt)

执行结果

['cat', 'hat', 'sat', ' at', 'mat', 'lat']

如果搜寻的是真正的“.”字符，须使用反斜杠“.”。

16-5-7　所有字符使用通配符“.*”

若是将16-3-7小节所介绍的“.”字符与“*”组合，可以搜寻所有字符，意义是搜寻0到多个通配符（换行字符除外）。

程序实例ch16_31.py：搜寻所有字符“.*”的组合应用。

# ch16_31.py
import re

msg = 'Name: Jiin-Kwei Hung Address: 8F, Nan-Jing E. Rd, Taipei'
pattern = 'Name: (.*) Address: (.*)'
txt = re.search(pattern,msg)      # 传回搜寻结果
Name, Address = txt.groups()
print("Name:    ", Name)
print("Address: ", Address)

执行结果

Name:     Jiin-Kwei Hung
Address:  8F, Nan-Jing E. Rd, Taipei

16-5-8　换行字符的处理

使用16-5-7小节观念用“.*”搜寻时碰上换行字符，搜寻就停止。Python的re模块提供参数re.DOTALL，功能是包括搜寻换行字符，可以将此参数放在search( )、findall( )或compile( )。

程序实例ch16_32.py：测试1是搜寻除换行字符以外的字符，测试2是搜寻含换行字符的所有字符。由于测试2有包含换行字符，所以输出时，换行字符主导分2行输出。

# ch16_32.py
import re
#测试1搜寻除了换行字符以外字符
msg = 'Name: Jiin-Kwei Hung \nAddress: 8F, Nan-Jing E. Rd, Taipei'
pattern = '.*'
txt = re.search(pattern,msg)           # 传回搜寻不含换行字符结果
print("测试1输出: ", txt.group())
#测试2搜寻包括换行字符
msg = 'Name: Jiin-Kwei Hung \nAddress: 8F, Nan-Jing E. Rd, Taipei'
pattern = '.*'
txt = re.search(pattern,msg,re.DOTALL) # 传回搜寻含换行字符结果
print("测试2输出: ", txt.group())

执行结果

测试1输出:  Name: Jiin-Kwei Hung 
测试2输出:  Name: Jiin-Kwei Hung
Address: 8F, Nan-Jing E. Rd, Taipei

16-6　MatchObject对象

16-2节已经讲解使用re.search( )搜寻字符串，搜寻成功时可以产生MatchObject对象，这里将先介绍另一个搜寻对象的方法re.match( )，这个方法搜寻成功后也将产生MatchObject对象。接着本节会分成几个小节，再讲解MatchObject几个重要的方法(method)。

16-6-1　re.match( )

这本书已经讲解了搜寻字符串中最重要的2个方法re.search( )和re.findall( )，re模块另一个方法是re.match( )，这个方法其实和re.search( )相同，差异是re.match( )只搜寻比对字符串开始的字，如果失败就算失败。re.search( )则是搜寻整个字符串。至于re.match( )搜寻成功会传回MatchObject对象，若是搜寻失败会传回None，这部分与re.search( )相同。

程序实例ch16_33.py：re.match( )的应用。测试1是将John放在被搜寻字符串的最前面，测试2没有将John放在被搜寻字符串的最前面。

# ch16_33.py
import re
#测试1搜寻使用re.match()
msg = 'John will attend my party tonight.'  # John是第一个字符串
pattern = 'John'
txt = re.match(pattern,msg)                 # 传回搜寻结果
if txt != None:
    print("测试1输出: ", txt.group())
else:
    print("测试1搜寻失败")
#测试2搜寻使用re.match()
msg = 'My best friend is John.'             # John不是第一个字符串
txt = re.match(pattern,msg,re.DOTALL)       # 传回搜寻结果
if txt != None:
    print("测试2输出: ", txt.group())
else:
    print("测试2搜寻失败")

执行结果

测试1输出:  John
测试2搜寻失败

16-6-2　MatchObject几个重要的方法

当使用re.search( )或re.match( )搜寻成功时，会产生MatchOjbect对象。

程序实例ch16_34.py：看看MatchObject对象是什么。

# ch16_34.py
import re
#测试1搜寻使用re.match()
msg = 'John will attend my party tonight.'  
pattern = 'John'
txt = re.match(pattern,msg)                 # re.match()
if txt != None:
    print("使用re.match()输出MatchObject对象:  ", txt)
else:
    print("测试1搜寻失败")
#测试1搜寻使用re.search()
txt = re.search(pattern,msg)                # re.search()
if txt != None:
    print("使用re.search()输出MatchObject对象: ", txt)
else:
    print("测试1搜寻失败")

执行结果

使用re.match()输出MatchObject对象:   <re.Match object; span=(0, 4), match='John'>
使用re.search()输出MatchObject对象:  <re.Match object; span=(0, 4), match='John'>

从上述可知，当使用re.match( )和re.search( )皆搜寻成功时，两者的MatchObject对象内容是相同的。span是注明成功搜寻字符串的起始位置和结束位置，从此处可以知道起始索引位置是0，结束索引位置是4。match则是注明成功搜寻的字符串内容。

Python提供下列取得MatchObject对象内容的重要方法。

在这里插入图片描述

程序实例ch16_35.py：分别使用re.match( )和re.search( )搜寻字符串Joah，成功搜寻到字符串时，分别用start( )、end( )和span( )方法列出字符串出现的位置。

# ch16_35.py
import re
#测试1搜寻使用re.match()
msg = 'John will attend my party tonight.'  
pattern = 'John'
txt = re.match(pattern,msg)                 # re.match()
if txt != None:
    print("搜寻成功字符串的起始索引位置 :  ", txt.start())
    print("搜寻成功字符串的结束索引位置 :  ", txt.end())
    print("搜寻成功字符串的结束索引位置 :  ", txt.span())
#测试2搜寻使用re.search()
msg = 'My best friend is John.'  
txt = re.search(pattern,msg)                # re.search()
if txt != None:
    print("搜寻成功字符串的起始索引位置 :  ", txt.start())
    print("搜寻成功字符串的结束索引位置 :  ", txt.end())
    print("搜寻成功字符串的结束索引位置 :  ", txt.span())

执行结果

搜寻成功字符串的起始索引位置 :   0
搜寻成功字符串的结束索引位置 :   4
搜寻成功字符串的结束索引位置 :   (0, 4)
搜寻成功字符串的起始索引位置 :   18
搜寻成功字符串的结束索引位置 :   22
搜寻成功字符串的结束索引位置 :   (18, 22)

16-7　抢救CIA情报员-sub( )方法

Python re模块内的sub( )方法可以用新的字符串取代原本字符串的内容。

16-7-1　一般的应用

sub( )方法的基本使用语法如下：

 result = re.sub(pattern, newstr, msg)  # msg是整个欲处理的字符串或句子

pattern是欲搜寻的字符串，如果搜寻成功则用newstr取代，同时成功取代的结果回传给result变量，如果搜寻到多个相同字符串，这些字符串将全部被取代，需留意原先msg内容将不会改变。如果搜寻失败则将msg内容回传给result变量，当然msg内容也不会改变。

程序实例ch16_36.py：这是字符串取代的应用，测试1是发现2个字符串被成功取代(Eli Nan被Kevin Thomson取代)，同时列出取代结果。测试2是取代失败，所以txt与原msg内容相同。

# ch16_36.py
import re
#测试1取代使用re.sub()结果成功
msg = 'Eli Nan will attend my party tonight. My best friend is Eli Nan'  
pattern = 'Eli Nan'                 # 欲搜寻字符串        
newstr = 'Kevin Thomson'            # 新字符串
txt = re.sub(pattern,newstr,msg)    # 如果找到则取代
if txt != msg:                      # 如果txt与msg内容不同表示取代成功
    print("取代成功: ", txt)        # 列出成功取代结果
else:
    print("取代失败: ", txt)        # 列出失败取代结果
#测试2取代使用re.sub()结果失败  
pattern = 'Eli Thomson'             # 欲搜寻字符串        
txt = re.sub(pattern,newstr,msg)    # 如果找到则取代           
if txt != msg:                      # 如果txt与msg内容不同表示取代成功
    print("取代成功: ", txt)        # 列出成功取代结果
else:
    print("取代失败: ", txt)        # 列出失败取代结果

执行结果

取代成功:  Kevin Thomson will attend my party tonight. My best friend is Kevin Thomson
取代失败:  Eli Nan will attend my party tonight. My best friend is Eli Nan

16-7-2　抢救CIA情报员
社会上有太多需要保护当事人隐私权利的场合，例如，情报机构在内部文件不可直接将情报员的名字列出来，历史上太多这类实例造成情报员的牺牲，这时可以使用***代替原本的姓名。使用Python的正则表示法，可以轻松协助我们执行这方面的工作。这一节将先用程序代码，然后解析此程序。

程序实例ch16_37.py：将CIA情报员名字，用名字第一个字母和***取代。

# ch16_37.py
import re
# 使用隐藏文字执行取代
msg = 'CIA Mark told CIA Linda that secret USB had given to CIA Peter.'
pattern = r'CIA (\w)\w*'            # 欲搜寻FBI + 空一格后的名字        
newstr = r'\1***'                   # 新字符串使用隐藏文字
txt = re.sub(pattern,newstr,msg)    # 执行取代
print("取代成功: ", txt)            # 列出取代结果

执行结果

取代成功:  M*** told L*** that secret USB had given to P***.

上述程序第一个关键是第5行，这一行将搜寻CIA字符串外加空一格后出现不限长度的字符串（可以由英文大小写或数字或底线所组成）。观念是括号内的(\w)代表必须只有一个字符，同时小括号代表这是一个分组(group)，由于整行只有一个括号所以知道这是第一分组，同时只有一个分组，括号外的\w表示可以有0到多个字符。所以(\w)\w相当于是1-多个字符组成的单字，同时存在分组1。

上述程序第6行的\1代表用分组1找到的第一个字母当作字符串开头，后面则是接在第一个字母后的字符。对CIA Mark而言所找到的第一个字母是M，所以取代的结果是M。对CIA Linda而言所找到的第一个字母是L，所以取代的结果是L***。对CIA Peter而言所找到的第一个字母是P，所以取代的结果是P***。

16-8　处理比较复杂的正则表示法

有一个正则表示法内容如下：
在这里插入图片描述

其实相信大部分的读者看到上述正则表示法，就想弃械投降了，坦白说的确复杂，不过不用担心，笔者将一步步解析，让事情变简单。

16-8-1　将正则表达式拆成多行字符串

在3-4-2小节笔者有介绍可以使用3个单引号（或是双引号）将过长的字符串拆成多行表达，这个观念也可以应用在正则表达式，当我们适当地拆解后，可以为每一行加上批注，整个正则表达式就变得简单了。若是将上述pattern，拆解成下列表示法，整个就变得简单了。
在这里插入图片描述

接下来笔者分别解释相信读者就可以了解了，第一行区域号码是2位数，可以接受有括号的区域号码，也可以接受没有括号的区域号码，例如，02或(02)皆可以。第二行是设定区域号码与电话号码间的字符，可以接受空格符或-字符当作分隔符。第三行是设定8位数数字的电话号码。第四行是分机号码，分机号码可以用ext或ext.当作起始字符，空一定格数，然后接受2-4位数的分机号码。

16-8-2　re.VERBOSE

使用Python时，如果想在正则表达式中加上批注，可参考16-8-1小节，必须配合使用re.VERBOSE参数，然后将此参数放在search( )、findall( )或compile( )。

程序实例ch16_38.py：搜寻市区电话号码的应用，这个程序可以搜寻下列格式的电话号码。
在这里插入图片描述

# ch16_38.py
import re

msg = '''02-88223349, (02)-26669999, 02-29998888 ext 123,
        12345678, 02 33887766 ext. 12222'''
pattern = r'''(
    (\d{2}|\(\d{2}\))?              # 区域号码
    (\s|-)?                         # 区域号码与电话号码的分隔符
    \d{8}                           # 电话号码
    (\s*(ext|ext.)\s*\d{2,4})?      # 2-4位数的分机号码
    )'''
phoneNum = re.findall(pattern, msg, re.VERBOSE)     # 传回搜寻结果
print(phoneNum)

执行结果

[('02-88223349', '02', '-', '', ''), ('(02)-26669999', '(02)', '-', '', ''), ('02-29998888 ext 123', '02', '-', ' ext 123', 'ext'), (' 12345678', '', ' ', '', ''), ('02 33887766 ext. 1222', '02', ' ', ' ext. 1222', 'ext.')]

16-8-3　电子邮件地址的搜寻

在字处理过程中，必须在文件内将电子邮件地址解析出来很常见，下列是这方面的应用。下列是Pattern内容。

在这里插入图片描述

第1行用户账号常用的有a-z字符、A-Z字符、0-9数字、底线_、点.。第2行是@符号。第3行是主机域名，常用的有a-z字符、A-Z字符、0-9数字、分隔符-、点.。第4行是点 . 符号。第5行最常见的是com或edu，也可能是cc或其他，这通常由2至4个字符组成，常用的有a-z字符、A-Z字符。第6行是点 . 符号，在美国通常只要前5行就够了，但是在其他国家则常常需要此字段，所以此字段后面是？字符。第7行通常是国别，例如中国是cn、日本是ja，常用的有a-z字符、A-Z字符。

程序实例ch16_39.py：电子邮件地址的搜寻。

# ch16_39.py
import re

msg = '''txt@deepstone.com.tw kkk@gmail.com'''
pattern = r'''(
    [a-zA-Z0-9_.]+                  # 使用者账号
    @                               # @符号
    [a-zA-Z0-9-.]+                  # 主机域名domain
    [\.]                            # .符号
    [a-zA-Z]{2,4}                   # 可能是com或edu或其它
    ([\.])?                         # .符号, 也可能无特别是美国
    ([a-zA-Z]{2,4})?                # 国别
    )'''
eMail = re.findall(pattern, msg, re.VERBOSE)     # 传回搜寻结果
print(eMail)

执行结果

[('txt@deepstone.com.tw', '', ''), ('kkk@gmail.com', '', '')]

16-8-4　re.IGNORECASE/re.DOTALL/re.VERBOSE

在16-3-9小节笔者介绍了re.IGNORECASE参数，在16-5-8小节笔者介绍了re.DOTALL参数，在16-8-2小节笔者介绍了re.VERBOSE参数，我们可以分别在re.search( )、re.findall( )、re.match( )或是re.compile( )方法内使用它们，可是一次只能放置一个参数，如果我们想要一次放置多个参数特性，应如何处理？方法是使用16-3-4小节的管道|观念，例如，可以使用下列方式：

 datastr = re.search(pattern, msg, re.IGNORECASE|re.DOTALL|re.VERBOSE)

其实这一章已经讲解了相当多的正则表达式的知识了，未来各位在写论文、做研究或职场上相信会有相当帮助。如果仍觉不足，可以自行到Python官网获得更多正则表达式的知识。

在这里插入图片描述

收录于

我心中的王者：Python

标签

#python #正则表达式 #开发语言

从原理到接法全面了解三相电阅读详情

我心中的王者：Python-第16章 正则表达式(Regular Expression)

我心中的王者：Python-第16章 正则表达式(Regular Expression)

16-1 使用Python硬功夫搜寻文字

16-2 正则表达式的基础

16-2-1 建立搜寻字符串模式

16-2-2 使用re.compile( )建立Regex对象

16-2-3 搜寻对象

16-2-4 findall( )

16-2-5 再看re模块

16-2-6 再看正则表达式

16-3 更多搜寻比对模式

16-3-1 使用小括号分组

16-3-2 groups( )

16-3-3 区域号码是在小括号内

16-3-4 使用管道|

16-3-5 多个分组的管道搜寻

16-3-6 使用？号做搜寻

16-3-7 使用*号做搜寻

16-3-8 使用+号做搜寻

16-3-9 搜寻时忽略大小写

16-4 贪婪与非贪婪搜寻

16-4-1 搜寻时使用大括号设定比对次数

16-4-2 贪婪与非贪婪搜寻

16-5 正则表达式的特殊字符

16-5-1 特殊字符表

16-5-2 字符分类

16-5-3 字符分类的^字符

16-5-4 正则表示法的^字符

16-5-5 正则表示法的$字符

16-5-6 单一字符使用通配符“.”

16-5-7 所有字符使用通配符“.*”

16-5-8 换行字符的处理

16-6 MatchObject对象

16-6-1 re.match( )

16-6-2 MatchObject几个重要的方法

16-7 抢救CIA情报员-sub( )方法

16-7-1 一般的应用

16-8 处理比较复杂的正则表示法

16-8-1 将正则表达式拆成多行字符串

16-8-2 re.VERBOSE

16-8-3 电子邮件地址的搜寻

16-8-4 re.IGNORECASE/re.DOTALL/re.VERBOSE

相关推荐

我心中的王者：Python-第16章正则表达式(Regular Expression)

我心中的王者：Python-第16章　正则表达式(Regular Expression)

16-1　使用Python硬功夫搜寻文字

16-2　正则表达式的基础

16-2-1　建立搜寻字符串模式

16-2-2　使用re.compile( )建立Regex对象

16-2-3　搜寻对象

16-2-4　findall( )

16-2-5　再看re模块

16-2-6　再看正则表达式

16-3　更多搜寻比对模式

16-3-1　使用小括号分组

16-3-2　groups( )

16-3-3　区域号码是在小括号内

16-3-4　使用管道|

16-3-5　多个分组的管道搜寻

16-3-6　使用？号做搜寻

16-3-7　使用*号做搜寻

16-3-8　使用+号做搜寻

16-3-9　搜寻时忽略大小写

16-4　贪婪与非贪婪搜寻

16-4-1　搜寻时使用大括号设定比对次数

16-4-2　贪婪与非贪婪搜寻

16-5　正则表达式的特殊字符

16-5-1　特殊字符表

16-5-2　字符分类

16-5-3　字符分类的^字符

16-5-4　正则表示法的^字符

16-5-5　正则表示法的$字符

16-5-6　单一字符使用通配符“.”

16-5-7　所有字符使用通配符“.*”

16-5-8　换行字符的处理

16-6　MatchObject对象

16-6-1　re.match( )

16-6-2　MatchObject几个重要的方法

16-7　抢救CIA情报员-sub( )方法

16-7-1　一般的应用

16-8　处理比较复杂的正则表示法

16-8-1　将正则表达式拆成多行字符串

16-8-2　re.VERBOSE

16-8-3　电子邮件地址的搜寻

16-8-4　re.IGNORECASE/re.DOTALL/re.VERBOSE