前面章节介绍了一些系统自带的工具函数，如 id()、max()。这些函数在 Python 启动时会自动加载进来，不需要我们做任何事情。但并不是所有的模块都是自动加载进来的，因为有些模块不常用，它们只是在完成某个特定任务时才被需要，此时才需要将其加载进来。

正则表达式又被称为规则表达式，英文名为 Regular expression。正则表达式是计算机科学的一个概念，通常被用来检索、替换那些符合某个模式的文本。现代编程语言基本都内嵌了正则表达式的库，如 Perl、Python 也不例外。虽然各种语言和库定义的正则表达式的语法规则会有所不同，但基本内容是相同的。

Python 虽然自带正则表达式库 re，但是该库不是自动加载进内存的，需要使用下面的语句来引入：

import re

正则表达式的基础是匹配。匹配操作有两个输入，一个是规则，另一个是输入字符串。在匹配的基础上可以进行替换、检索等操作。

一个简单的例子便是检查用户输入的邮箱地址是否合法，合法的邮箱地址应该符合下面的形式：

用户名 @ 主机地址

这里假定用户名可以包含 26 个字母和 10 个数字；主机地址是用小数点（ . ）分割的分段，每个分段可以出现的字符和用户名中可以出现的字符相同。这里只是一个假设，实际格式要复杂得多。下面的代码演示了如何判断某个输入是否是合法的邮箱地址。

>>> import re       # 引入正则表达式库
>>> def valid_email_address(addr):      # 定义函数
...     result = re.match(r"^[a-zA-Z0-9]+@[a-zA-Z0-9]+(\.[a-zA-Z0-9]+)*$",
        addr)
...     if result is not None:     # 匹配成功
...             print("[%s] is a valid email address" % addr)
...     else:                      # 匹配失败
...             print("[%s] is NOT a valid email address" % addr)
...                                  # 函数定义结束
>>> valid_email_address("name")      # 判断name是否为合法的邮箱地址
[name] is NOT a valid email address     # 不是合法的邮箱地址
>>> valid_email_address("name@")        # 判断name@是否为合法的邮箱地址
[name@] is NOT a valid email address    # 不是合法的邮箱地址
# 判断name@126.com是否为合法的邮箱地址
>>> valid_email_address("name@126.com")
[name@126.com] is a valid email address # 是合法的邮箱地址

元字符和语法

在正则表达式中，定义了一些元字符。这些字符一般用来匹配一组字符，如希望匹配 0～9 这 10 个数字字符，那么便可以使用元字符 \d。元字符一般是以 \ 开头，后面再跟着一个字符。

另外有些语法是描述某个或者某组字符出现的频率的，例如，如果认为某个字段是可选的，则可以指定其出现的频率是 0 或者 1。

下面介绍一下 Python 中正则表达式的常用元字符和语法。

1) 任意字符

任意字符可以表示除换行之外的任意字符。

>>> input_str = "abcdefgh"                 # 搜索的字符串
>>> result = re.match("a.c", input_str)    # 在input_str中查找符合a.c的字符串
>>> result is None                         # 如果没有找到会返回None
False                                      # 找到了
>>> input_str[result.start():result.end()]   # 显示匹配的字符串
'abc'

2) \（转义符）

假设要找到符合条件的字符串：以 a 开头，后面跟着 .. 再后面是任意字符，最后是 xxx。如果按照前面的方法来写如下：

a..xxx

. 表示任意字符，所以其表示的含义是以 a 开头，后面是任意两个字符，最后是 xxx。

这和我们期望的是不同的。为了解决该问题，需要使用转义符，转义符的作用就是使元字符无效，如 . 表示任意非换行字符，而 \. 就表示普通的小数点。下面的代码演示了所讨论的情况。

>>> input_str = "abcxxx"          # 这个应该是不符合要求的
>>> result = re.match(r"a..xxx", input_str)
>>> result is None
False
>>> input_str[result.start():result.end()]    # 显示匹配的字符串
'abcxxx'
        # 修改匹配规则，使用\.表示小数点
>>> result = re.match(r"a\..xxx", input_str)
>>> result is None                            # 是否能找到匹配的字符串
True                                          # 不能

\ 后面可以跟任何元字符，如表示任意字符的 .，表示转义的 \，即 \\ 表示普通的反斜杠 \。下面的例子演示了 \\ 的用法。

input_str = r"c:\python2"
>>> result = re.match(r"c:\\py", input_str)
>>> result is None
False
>>> input_str[result.start():result.end()]
'c:\\py'

3) [候选字符列表]

[候选字符列表] 表示任意候选字符中的字符。如 [abc] 表示 abc 中的任意字符，所以可以匹配 a，也可以匹配 b，还可以匹配 c。但不能匹配 y，也不能匹配 A。

下面的例子演示了其用法。

>>> input_str = "abcdefgh"     
>>> result = re.match(r"[abc]bc", input_str) # 匹配以abc中的一个字符开头，跟着bc的字符串
>>> input_str[result.start():result.end()]
'abc'                          # 结果匹配了字符串abc
>>> input_str = "bbcdefgh"     # 匹配以abc中的一个字符开头，跟着bc的字符串
>>> result = re.match(r"[abc]bc", input_str)          
>>> input_str[result.start():result.end()]
'bbc'                                # 结果匹配了字符串bbc

另外一个用法是 [开始字符-结束字符]，表示从开始字符到结束字符中的任意字符，包括开始字符和结束字符。如 [a-c] 可以匹配 a、b 或者 c。下面演示该用法。

>>> input_str = "abc"                 # 输入字符
>>> result = re.match(r"[a-x]bc", input_str)  # 匹配以a-x中的一个字符开头，跟着bc的字符串        
>>> result is None                    # 如果匹配不上，返回None
False                                 # 匹配上了
>>> input_str[result.start():result.end()]  # 显示匹配的字符串
'abc'
>>> input_str = "Abc"                       # 输入字符以大写的A开始
>>> result = re.match(r"[a-x]bc", input_str) # 匹配以a-x开头，跟着bc的字符串
>>> result is None                          # 如果匹配不上，返回None
True                                        # 没有匹配上

也可以使用 [^….] 来表示匹配不在 … 范围内定义的字符。如 [^a-b] 表示非 a~b 的任意字符。下面演示了这种用法。

>>> input_str = "Abc"
>>> result = re.match(r"[^a-x]bc", input_str)
>>> result is None         # 匹配失败则返回None
False
>>> input_str[result.start():result.end()]   # 显示匹配的字符串
'Abc'

4) \d（单个数字字符）

\d 等效于 [0-9]。

>>> input_str = "0123456789"                   # 输入字符串
>>> result = re.match(r"\d\d\d", input_str)    # 匹配3个数字字符
>>> result is None                             # 匹配失败则返回None
False
>>> input_str[result.start():result.end()]     # 显示匹配的字符串
'012'

5) \D（单个非数字字符）

\D 等效于除了 0~9 之外的任意字符，等效于 [^0-9]。

>>> input_str = "0123456789"
>>> result = re.match(r"\D", input_str)
>>> result is None
True

6) \s（空白字符）

空白字符包含空格、回车 \r、换行 \n、制表 \t、垂直制表 \v、换页 \f。

>>> input_str = "01234\n56789"          # 输入字符串
>>> re_obj = re.compile(r"4\s5")        # 匹配的目标字符串格式
>>> result = re.search(re_obj, input_str)    # 查找
>>> result.start()            # 开始位置
4
>>> result.end()              # 结束位置
7
>>> input_str[result.start():result.end()]   # 匹配的字符串
'4\n5'

7) \S（非空白字符）

这里是大写的 S。下面的例子是查找单词，使用 \S+ 表示不包含空格字符的字符串。

>>> input_str = "abc def ijk"          # 输入字符串
>>> re_obj = re.compile(r"\S+")        # 查找模式
>>> result = re.search(re_obj, input_str)    # 查找
>>> result.start()                           # 开始位置
0
>>> result.end()     # 结束位置，该位置的字符不被包含
3
>>> input_str[result.start():result.end()]   # 查看匹配的字符串
'abc'

8) \w（单词字符）

单词字符包括大小写字母、数字、下划线，不包括空格、$、# 等。

>>> input_str = "abc%def$ijk"    # 输入字符，其中的%是不能匹配\w的
>>> re_obj = re.compile(r"\w+")
>>> result = re.search(re_obj, input_str)
>>> result.start()
0
>>> result.end()
3
>>> input_str[result.start():result.end()]
'abc'

9) \W（非单词字符）

\W 即非 \w 所包含的字符。

>>> input_str = "!@#$%^&*()_+abc"
>>> re_obj = re.compile(r"\W+")
>>> result = re.search(re_obj, input_str)
>>> result.start()
0
>>> result.end()
10
>>> input_str[result.start():result.end()]
'!@#$%^&*()'

10) *（任意多个）

* 表示 0 或者多个前面的字符。

>>> input_str = "aaaaaaaaabc"        # 输入字符串
>>> re_obj = re.compile(r"a*bc")     # 任意多个a后面跟着bc
>>> result = re.search(re_obj, input_str)      # 查找
>>> result.start()                             # 开始位置
0
>>> result.end()
11
>>> input_str[result.start():result.end()]     # 查找的结果
'aaaaaaaaabc'  
>>> input_str = "bcdef"                        # 新的输入数据
>>> re_obj = re.compile(r"a*bc")               # 查找模式没有发生变化
>>> result = re.search(re_obj, input_str)      # 查找
>>> result.start()
0
>>> result.end()
2
>>> input_str[result.start():result.end()]     # 查找结果
'bc'

11) +（一个或者多个）

+ 表示 1 个或者多个前面的字符。

>>> input_str = "aaaaaaaaabc"
>>> re_obj = re.compile(r"a+bc")
>>> result = re.search(re_obj, input_str)
>>> result.start()
0
>>> result.end()
11
>>> input_str[result.start():result.end()]
'aaaaaaaaabc'
>>> input_str = "bcdef"      # 要求至少有一个a，但是输入字符串没有包括a
>>> re_obj = re.compile(r"a+bc")               # 匹配格式
>>> result = re.search(re_obj, input_str)      # 进行查找
>>> result is None     # 如果匹配失败，则返回None
True                   # 匹配失败

12) ?（1个或者0个）

? 表示 0 个或者 1 个前面的字符。

>>> input_str = "aaaaaaaaabc"
>>> re_obj = re.compile(r"a?bc")               # 表示1个或者0个a，后面跟着bc
>>> result = re.search(re_obj, input_str)      # 查找
>>> result is None           # 查找是否失败
False                                          # 没有失败
>>> result.start()           # 查找结果的开始位置
8
>>> result.end()             # 查找结果的结束位置
11
>>> input_str[result.start():result.end()]     # 查找的结果
'abc'
>>> input_str = "bcdef"                        # 新的输入字符串
>>> re_obj = re.compile(r"a?bc")               # 匹配模式没有变化
>>> result = re.search(re_obj, input_str)      # 查找操作
>>> result is None                             # 匹配是否失败
False                                          # 没有失败
>>> result.start()                             # 查找结果的开始位置
0
>>> result.end()                               # 查找结果的结束位置
2
>>> input_str[result.start():result.end()]     # 查找的结果
'bc'

13) {m}（出现指定次数）

{m} 表示 m 个前面的字符。m 可以为 0，表示不出现该字符。

>>> input_str = "aaaaaaaaabc"                  # 输入字符串
>>> re_obj = re.compile(r"a{3}bc")             # 表示3个a后面跟着bc
>>> result = re.search(re_obj, input_str)      # 查找
>>> result is None                             # 匹配是否失败
False                                          # 没有失败
>>> result.start()                             # 匹配开始的位置
6
>>> result.end()                               # 匹配结束的位置
11
>>> input_str[result.start():result.end()]     # 匹配的字符串
'aaabc'
>>> input_str = "aaaaaaaaabc"                  # 输入字符串没有改变
>>> re_obj = re.compile(r"a{4}bc")             # 表示4个a后面跟着bc
>>> result = re.search(re_obj, input_str)
>>> result is None
False
>>> result.start()
5
>>> result.end()
11
>>> input_str[result.start():result.end()]     # 匹配的字符串
'aaaabc'
>>> input_str = "aaaaaaaaabc"                  # 输入没有改变
>>> re_obj = re.compile(r"a{0}bc")             # m=0的情况
>>> result = re.search(re_obj, input_str)      # 查找
>>> result is None
False
>>> result.start()
9
>>> result.end()
11
>>> input_str[result.start():result.end()]     # 匹配的结果
'bc'

14) {m,n}（指定出现次数的范围）

{m,n} 表示 m 到 n 个前面的字符。如 1{1,2} 可以匹配 1 和 11 两个字符串。IPv4 中定义的 IP 地址格式比较统一，是由 4 段数字组成，段与段之间用 . 分割，段的长度在 1~3 之间。

下面的例子演示了如何定义 IPv4 的 IP 地址:

>>> input_str = "127.0.0.1"          # 合法的IPv4的IP地址
>>> result = re.match(r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}", input_str)
>>> result is None
False
>>> input_str[result.start():result.end()]      # 匹配的结果
'127.0.0.1'
>>> input_str = "127.0.0"            # 不合法的地址，少了一段
>>> result = re.match(r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}", input_str)
>>> result is None                   # 匹配是否失败
True                                                                                    # 匹配失败
>>> input_str = "127.0.0.1000"       # 新输入
>>> result = re.match(r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}", input_str)
>>> result is None
False
>>> input_str[result.start():result.end()]    # 显示匹配内容
'127.0.0.100'                   # 可以看到最后一个字符0没有被匹配上
>>> input_str = "1270.0.0.100"                # 新输入
>>> result = re.match(r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}", input_str)
>>> result is None                            # 没有匹配成功
True

15) ^（开头）

^ 字符表示的是输入的第一个字符，如 ^ab 可以匹配上 ab，但不能匹配上 mab。因为 mab 的第一字符是 m 而不是 a。

>>> re_obj = re.compile(r"^abc")    # 匹配以abc开头的字符串
>>> input_str = "aaaaaaaaabc"       # 输入字符串
>>> result = re.search(re_obj, input_str)       # 查找
>>> result is None                  # 匹配是否失败
True                                # 匹配失败
>>> input_str = "abcd"              # 新的输入字符串
>>> result = re.search(re_obj, input_str)        # 查找
>>> result is None                  # 匹配是否失败
False                               # 没有失败
>>> result.start()
0
>>> result.end()
3
>>> input_str[result.start():result.end()]    # 匹配的内容
'abc'

16) $（结尾）

$ 表示输入字符串的结尾字符，如 abc$ 可以匹配成功 abc，但不能匹配上 abcd，因为 abcd 的最后一个字符是 d，而不是 c。

>>> re_obj = re.compile(r"abc$")      # 匹配规则，以abc结尾的字符串
>>> input_str = "-----abcd"           # 输入字符串
>>> result = re.search(re_obj, input_str)      # 查找
>>> result is None                    # 匹配是否失败
True                                  # 匹配失败
>>> input_str = "-----abc"            # 新的输入字符串
>>> result = re.search(re_obj, input_str)      # 查找
>>> result is None                    # 匹配是否失败
False                                 # 没有失败
>>> result.start()
5
>>> result.end()
8
>>> input_str[result.start():result.end()]   # 匹配的字符串
'abc'

C风格接口函数

这类接口直接使用函数，而不用创建正则表达式对象，或者说正则表示式用字符串表示。其主要包括匹配、查找、替换等接口函数。

1) search()：查找

search() 接口函数在整个字符串内查找能够匹配上的子字符串。如果找到匹配的字符串，返回一个 re.Match 对象；如果未找到，返回 None。

如果给定一个输入 abc1234ef876，想得到第一个子数字串 1234，那么可以使用该函数来实现。

>>> input_str = "abc1234ef876"                         # 输入字符串
>>> result = re.search(r"\d+", input_str)      # 使用\d+进行配置
>>> result is None                                                     # 匹配是否失败
False
>>> input_str[result.start():result.end()]     # 显示匹配的字符串
'1234'

从上面的例子也可以看出，如果有多个符合条件可以成功匹配的子字符串，search() 仅返回第一个符合条件的子字符串。如上例中其实可以找到两个符合条件的子字符串，即 1234 和 876，但是 search() 仅返回第一个，即 1234。

2) match()：匹配

match() 从输入字符串头部开始匹配，如果匹配不成功，返回 None；如果匹配成功，返回 re.Match 对象。

3) sub()：替换

sub() 接口函数接受匹配模式，输入字符串和替换字符串，它在输入字符串中查找符合匹配模式的子字符串，并用替换字符串来替换匹配的字符串，得到一个新的字符串。其最常用的格式如下：

re.sub(匹配模式，替换字符串，输入字符串)

如输入字符串是 abc123kjl，匹配模式是 \d+，则可以匹配的子字符串是 123，替换字符串是 ===，那么得到的返回值是字符串 abv===kjl。

下面是该例子的演示效果：

>>> re.sub(r"\d+", "===", "abc123kjl")    # 替换
'abc===kjl'

如果匹配不成功，则返回值为输入字符串。如下面的例子，要求匹配 8 个连续数字字符，但输入字符串中没有 8 个连续的数字字符，即找不到可以进行替换的子字符串，那么返回值就是输入字符串。

>>> re.sub(r"\d{8}", "===", "abc123kjl")   # 没有匹配的情况
'abc123kjl'

默认情况下，该接口对所有符合条件的子字符串进行替换操作。如下面的例子，对所有的 a 用 A 进行替换，

>>> re.sub(r"a", "A", "abc123abcABC")
'Abc123AbcABC'

如果不希望替换所有符合条件的子字符串，则可以使用参数 count，该参数表示最多替换的次数。下面的例子演示了这种用法，其仅替换一个匹配的，即第一个匹配的字符串，其他的匹配不被替换。

>>> re.sub(r"a", "A", "abc123abcABC", count=1)
'Abc123abcABC'

面向风格接口函数

面向风格接口函数的用法是首先产生一个正则表达式对象，然后调用该对象的接口函数来完成匹配、查找及替换等功能。

可以用字符串来生成正则表达式对象，使用的是 re.compile() 函数。下面的例子演示了该函数的使用。

>>> re_obj = re.compile(r'\d\d\d')      # 得到正则表达式对象
>>> re_obj
re.compile('\\d\\d\\d')
>>> type(re_obj)
<class 're.Pattern'>

re.Match对象

re.Match 对象在前面已经使用过了，该对象表示匹配结果。前文也使用该对象的 start() 和 end() 接口函数来得到匹配的开始和结束位置，但该类型对象还有一些其他属性和方法需要进一步了解。

1) start()：匹配开始位置

start() 用于匹配开始位置。对于 match() 函数返回的 Match 对象，该值永远为 0，因为 match() 函数是从输入字符串的头部开始匹配的，如果第一个字符不能被匹配上，则匹配失败。

>>> match_obj = re.match(r"a+", "Aabc")        # 第一个字符不匹配，所以失败
>>> match_obj is not None                      # 匹配成功
False

如果匹配成功，start() 一定是 0，因为是从字符串的头部开始匹配的。

>>> match_obj = re.match(r"a+", "aaaabc")      # 可以匹配上开头的aaaa
>>> match_obj is not None                      # 匹配是否成功
True
>>> match_obj.start()       # 匹配子字符串在输入字符串中的开始位置
0

而对于 search() 则不同，其匹配上的子字符串可以在输入字符串的中间或者结尾。

>>> match_obj = re.search(r"a+", "Aabc")       # 查找
>>> match_obj is not None              # 查找是否成功
True
>>> match_obj.start()                  # 找到的字符串的开始位置
1

2) end()：匹配结束位置

end() 用于匹配结束位置。

>>> match_obj = re.search(r"a+", "Aaabc")
>>> match_obj is not None            # 是否找到符合要求的子字符串
True
>>> match_obj.end()                  # 结束位置是3
3

需要注意的是，input_string[end] 不是匹配的最后一个字符，而是最后一个匹配字符的后一个字符，最后一个字符是 input_string[end-1]。

>>> input_string = "AaabcKL"         # 输入字符串
# 查找，可以匹配上aabc
>>> match_obj = re.search(r"[a-z]+", input_string)
# end()表示结束位置，不是最后一个匹配的字符
>>> input_string[match_obj.end()]
'K'        # 该位置的字符是K，而不是c
>>> input_string[match_obj.end()-1]  # end()-1才是最后一个匹配字符的位置
'c'

3) span()：匹配的字符串的跨度

span() 接口函数返回一个包含两个元素的元组，第一个元素表示匹配开始的位置，第二个元素表示匹配结束的位置，即该接口同时返回了 start() 和 end() 的值。

>>> input_str = "abc123ABC"                    # 输入字符串
>>> match_obj = re.search(r"\d+", input_str)   # 查找连续数字字符
>>> match_obj is not None                      # 匹配成功？
True
>>> match_obj.start()             # start()，得到匹配开始的位置
3
>>> match_obj.end()               # end()，得到匹配结束的位置
6
>>> match_obj.span()              # span()，同时得到开始和结束的位置
(3, 6)

4) groups()

groups() 得到所有的分组信息，返回值是一个列表。前面匹配过邮箱地址，该地址由两部分组成，第一部分是用户名，第二部分是主机名。如果想同时得到用户名和主机名，那么就可以使用分组的方式。方法就是在模式中将某一部分用 () 包裹起来，便可以得到一个组。

格式化复制

>>> def pass_email_addr(addr):  # 返回邮箱地址中的用户名和主机名
...     match_obj = re.match(r"([a-zA-Z0-9]+)@([a-zA-Z0-9]+(\.[a-zA-
                Z0-9]+)*)",
...        addr)
...     if match_obj is not None:
...             return match_obj.groups()[0], match_obj.groups()[1]
...     else:                         # 非法邮箱地址
...             return None           # 返回None
...                                   # 函数定义结束
>>> pass_email_addr("hello@python.cn") # 分析邮箱地址
('hello', 'python.cn')                # 得到用户名和主机名