Python中的正则表达式

摘要：正则表达式匹配的字符串限定范围和否定除了单字符外，字符集还支持匹配指定的字符范围。问号要求正则表达式引擎在当前正则表达式中尽可能少地匹配字符。正则表达式匹配的字符串表示简单浮点数的字符串扩展表示法正则表达式的扩展表示法，以问号开始。

正则表达式 是包含文本和特殊字符的字符串, 为高级的文本模式匹配, 抽取, 与文本形式的搜索和替换功能提供了基础

Python通过标准库re模块来支持正则表达式

模式匹配的两种方法完成匹配(模式匹配)

搜索(search())

匹配(match())

元字符指正则表达式中的特殊符号和字符。

管道符号在正则表达式中又称为择一匹配符，表示 从多个模式中选择其一 的操作。

句点(.)符号匹配除了换行符 以外的任何字符。无论字母、数字、空格(不包括 换行符)、可打印字符、不可打印字符，使用.都可以匹配。

注意

要显式匹配一个句点符号本身，必须使用反斜线转义句点符号的功能，例如.。

有些符号和相关的特殊字符用于在字符串的起始或结尾部分指定用于搜索的模式。

简单示例如下。

简单示例如下。

使用[]创建字符集，可以匹配某些特定字符。

除了单字符外，字符集还支持匹配指定的字符范围。两个字符中间用连字符-连接，用于指定一个字符的范围。如果^紧跟在左括号后面，这个符号就表示不匹配给定字符集中任何一个字符。

如果问号紧跟在任何使用闭包操作符的匹配后面，它将直接要求正则表达式引擎匹配尽可能少的次数。当模式匹配使用分组操作符时，正则表达式引擎将试图吸收匹配该模式的尽可能多的字符，这通常叫做贪婪匹配。问号要求正则表达式引擎在当前正则表达式中尽可能少地匹配字符。

简单示例。

有一些特殊字符能够表示字符集。

简单示例。

有时候不仅想要知道整个字符串是否匹配我们的标准，而且想要知道能否提取任何已经成功匹配的特定字符串或者子字符串，可以使用分组来实现。

一对圆括号可以实现一下任意一个功能：

对正则表达式进行分组

匹配子组

对正则表达式分组，可以在整个正则表达式中使用重复的操作符。

使用圆括号进行分组的一个副作用就是，匹配模式的子字符串可以保存起来供后续使用。这些子组能够被同一次的匹配或者搜索重复调用，或者提取出来用于后续处理。

匹配子组的重要性在于，很多时候除了进行匹配操作以外，我们还想要提取所匹配的模式。

简单示例如下。

正则表达式的扩展表示法，以问号开始(?...)。他们通常用于在判断匹配之前提供标记，实现一个前视或者后视匹配，或者条件检查。

尽管这些符号使用圆括号，但是只有(?P) 表示一个分组匹配，其他的都没有创建一个分组。

在Python中，re模块支持更强大而且更通用的Perl风格的正则表达式，该模块允许多个线程共享同一个已编译的正则表达式对象，也支持命名子组。

在Python中可以通过两种途径使用正则表达式：

re模块函数

调用编译后的正则表达式对象方法

在Python中由两类对象和正则表达式有关：

re.compile生成的表达式对象

匹配对象（成功调用 match() 或 search() 之后返回的对象）

几乎所有的re模块函数都可以作为regex对象的方法。

可以通过按位或操作符(|)合并使用多个标记

可以使用(?FLAG)将标记嵌入到正则表达式

</>复制代码 
>>> re.match(r"(?i)the", "the")
<_sre.SRE_Match object; span=(0, 3), match="the">
>>> re.match(r"(?i)the", "The")
<_sre.SRE_Match object; span=(0, 3), match="The">
>>> re.match(r"the", "The")
>>>

匹配对象是成功调用match()或者search()返回的对象。匹配对象有两个主要的方法: group()和groups()。

group()要么返回整个匹配对象，要么根据要求返回特定子组。groups()则仅返回一个包含唯一或者全部子组的元组。如果没有子组的要求，那么当group()仍返回整个匹配时，groups()返回一个空元组。

Python正则表达式允许命名匹配。

match方法试图从字符串的起始部分对模式进行匹配。

如果匹配成功，就返回一个匹配对象；如果匹配对象失败，就返回None。

匹配对象的group()方法能够用于显示那个成功的匹配。

</>复制代码 
Python 3.5.4rc1 (default, Jul 25 2017, 08:53:34) 
[GCC 6.4.0 20170704] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import re
>>> m = re.match("foo", "foo")
>>> if m is not None:
...     m.group()
... 
"foo"
>>> m
<_sre.SRE_Match object; span=(0, 3), match="foo">

只要模式从字符串的起始部分匹配，即使字符串比模式长，匹配也仍然能够成功。匹配结果是从较长字符串中抽取的匹配部分。

</>复制代码 
>>> re.match("foo", "food on the table").group()
"foo"

search函数在任意位置对给定正则表达式模式搜索第一次出现的匹配情况。如果搜索到成功的匹配，就会返回一个匹配对象；否则，返回None。

与match相比，match只能从起始开始匹配，search可以匹配任意位置。

</>复制代码 
>>> m = re.match("foo", "seafood")
>>> m.group() if m is not None else print(m)
None
>>> m = re.search("foo", "seafood")
>>> m.group() if m is not None else print(m)
"foo"

上面代码，使用match匹配失败，使用search则匹配成功。

管道符号或择一匹配符号(|)的使用。

</>复制代码 
>>> bt = "bat|bet|bit"
>>> m = re.match(bt, "bat")
>>> m.group() if m is not None else print(m)
"bat"
>>> m = re.match(bt, "blt")                   # 不能匹配
>>> m.group() if m is not None else print(m)
None
>>> m = re.match(bt, "He bit me")          # 不能匹配
>>> m.group() if m is not None else print(m)
None
>>> m = re.search(bt, "He bit me")      # 可以搜索到
>>> m.group() if m is not None else print(m)
"bit"

点号.不能匹配换行符和空字符串。

</>复制代码 
>>> dote = ".end"
>>> m = re.match(dote, "bend")  # OK
>>> m.group() if m is not None else print(m)
"bend"
>>> m = re.match(dote, "end")   # 不能匹配空内容
>>> m.group() if m is not None else print(m)
None
>>> m = re.match(dote, "
end") # 不能匹配换行符
>>> m.group() if m is not None else print(m)
None
>>> m = re.search(dote, "The end.")  # 搜索匹配
>>> m.group() if m is not None else print(m)
" end"

使用转义符，匹配点号。

</>复制代码 
>>> pi = "3.14"
>>> pit = "3.14"
>>> m = re.match(pit, "3.14")   # 精确匹配
>>> m.group() if m is not None else print(m)
"3.14"
>>> m = re.match(pi, "3014")    # 点号匹配0
>>> m.group() if m is not None else print(m)
"3014"
>>> m = re.match(pi, "3.14")    # 点号匹配.
>>> m.group() if m is not None else print(m)
"3.14"

</>复制代码 
>>> selc = "[cr][23][dp][o2]"
>>> m = re.match(selc, "c3po")
>>> m.group() if m is not None else print(m)
"c3po"
>>> m = re.match(selc, "c3p1")
>>> m.group() if m is not None else print(m)
None

正则表达式中最常见的情况包括：

特殊字符的使用

正则表达式模式的重复出现

使用圆括号对匹配模式的各部分进行分组和提取操作

特殊字符与重复出现

匹配0~1个中间子域名

</>复制代码 
>>> import re
>>> patt = "w+@(w+.)?w+.com"
>>> m = re.match(patt, "nobody@xxx.com")            # 匹配0个中间子域名
>>> m.group() if m is not None else print(m)
"nobody@xxx.com"
>>> m = re.match(patt, "nobody@xxx.yyy.com")        # 匹配1个中间子域名
>>> m.group() if m is not None else print(m)
"nobody@xxx.yyy.com"
>>> m = re.match(patt, "nobody@xxx.yyy.zzz.com")    # 不能匹配2个中间子域名
>>> m.group() if m is not None else print(m)
None

匹配任意多个子域名

</>复制代码 
>>> patt = "w+@(w+.)*w+.com"                    # 将 ? 替换为 *
>>> m = re.match(patt, "nobody@xxx.yyy.zzz.com")    # 匹配2个中间子域名
>>> m.group() if m is not None else print(m)
"nobody@xxx.yyy.zzz.com"

分组

使用圆括号来匹配和保存子组，以便于后续处理。

使用group()和groups()方法获取分组，其两者区别：

group()

访问每个独立的子组

获取完整匹配(不传递参数)

groups()

获取一个包含所有匹配子组的元组

</>复制代码 
>>> m = re.match("(www)-(ffffd)", "abc-123")
>>> m.group()                   # 完整匹配
"abc-123"
>>> m.group(1)                  # 子组1
"abc"
>>> m.group(2)                  # 子组2
"123"
>>> m.groups()                  # 全部子组
("abc", "123")

一个完整示例

</>复制代码 
>>> m = re.match("ab", "ab")            # 没有分组
>>> m.group()                           # 完整匹配
"ab"
>>> m = re.match("ab", "ab")            # 没有分组
>>> m.group()                           # 完整匹配
"ab"
>>> m.groups()                          # 所有子组
()
>>>
>>> m = re.match("(ab)", "ab")          # 一个子组
>>> m.group()                           # 完整匹配
"ab"
>>> m.group(1)                          # 子组1
"ab"
>>> m.groups()                          # 全部子组
("ab",)
>>>
>>> m = re.match("(a)(b)", "ab")        # 两个子组
>>> m.group()
"ab"
>>> m.group(1)                          # 子组1
"a"
>>> m.group(2)                          # 子组2
"b"
>>> m.groups()                          # 全部子组
("a", "b")
>>>
>>> m = re.match("(a(b))", "ab")        # 两个嵌套子组
>>> m.group()                           # 完整匹配
"ab"
>>> m.group(1)                          # 子组1
"ab"
>>> m.group(2)                          # 子组2
"b"
>>> m.groups()                          # 全部子组
("ab", "b")

</>复制代码 
>>> m = re.search("^The", "The end.")   # 匹配
>>> m.group() if m is not None else print(m)
"The"
>>> m = re.search("^The", "end. The")   # 不做为开始
>>> m.group() if m is not None else print(m)
None
>>> m = re.search(r"the", "bite the dog")     # 匹配左侧边界
>>> m.group() if m is not None else print(m)
"the"
>>> m = re.search(r"the", "bitethe dog")      # 匹配左侧边界
>>> m.group() if m is not None else print(m)
None
>>> m = re.search(r"Bthe", "bitethe dog")      # 匹配左侧没有边界
>>> m.group() if m is not None else print(m)
"the"
>>> m = re.search(r"BtheB", "bitethe dog")    # 匹配两侧没有边界
>>> m.group() if m is not None else print(m)
None
>>> m = re.search(r"Bthe", "bitethe dog")    # 匹配左侧没有边界，右侧有边界
>>> m.group() if m is not None else print(m)
"the"

findall()

查询字符串中某个正则表达式模式全部的非重复出现情况

与match()和search()的区别是，findall()总是返回一个列表

finditer()与findall()类似，不过返回结果是一个迭代器。

</>复制代码 
>>> re.findall("car", "car")
["car"]
>>> re.findall("car", "carry")
["car"]
>>> re.findall("car", "carry the barcardi to the car")
["car", "car", "car"]

结合分组使用

</>复制代码 
>>> s = "This and that."
>>> re.findall(r"(thw+) and (thw+)", s, re.I)
[("This", "that")]
>>> list(re.finditer(r"(thw+) and (thw+)", s, re.I))[0].groups()
("This", "that")
>>> list(re.finditer(r"(thw+) and (thw+)", s, re.I))[0].group(1)
"This"
>>> list(re.finditer(r"(thw+) and (thw+)", s, re.I))[0].group(2)
"that"

单个分组的多重匹配

如果模式中只有一个分组，则匹配结果作为结果集合的单个元素

如果模式中由多个分组，则匹配结果为元组，作为结果集的单个元素

</>复制代码 
>>> s = "this and that"
>>> re.findall(r"(thw+) and (thw+)", s, re.I)
[("this", "that")]
>>> re.findall(r"(thw+)", s, re.I)
["this", "that"]
>>>
>>>
>>> s = "This and that. What, where, when, and who"
>>> re.findall(r"thw+|whw+", s, re.I)
["This", "that", "What", "where", "when", "who"]
>>> re.findall(r"(thw+)|(whw+)", s, re.I)
[("This", ""), ("that", ""), ("", "What"), ("", "where"), ("", "when"), ("", "who")]
>>> re.findall(r"(whw+)", s, re.I)
["What", "where", "when", "who"]
>>>
>>>
>>> s = "This where. That when. There who."
>>> re.findall(r"(thw+)s(whw+)", s, re.I)
[("This", "where"), ("That", "when"), ("There", "who")]

有两个函数用于实现搜索和替换功能: sub() 和 subn()。sub()返回一个替换后的字符串；subn()还返回一个表示替换的总数，替换后的字符串和替换总数作为元组返回。

</>复制代码 
>>> re.sub("X", "Mr. Smith", "attn: X
Dear X,
")
"attn: Mr. Smith
Dear Mr. Smith,
"
>>> re.subn("X", "Mr. Smith", "attn: X
Dear X,
")
("attn: Mr. Smith
Dear Mr. Smith,
", 2)
>>> re.sub("[ae]", "X", "abcdef")
"XbcdXf"
>>> re.subn("[ae]", "X", "abcdef")
("XbcdXf", 2)

使用匹配对象的group()方法除了能够取出匹配分组编号外，还可以使用N，其中N是在替换字符串中使用的分组编号。

</>复制代码 
>>> re.sub(r"(d{1,2})/(d{1,2})/(d{2}|d{4})", r"2/1/3", "2/20/1992")
"20/2/1992"
>>> re.sub(r"(d{1,2})/(d{1,2})/(d{2}|d{4})", r"2/1/3", "2/20/92")
"20/2/92"

split 基于正则表达式的模式分隔字符串。可以通过为max参数设定一个值（非零）来指定最大分割数。

</>复制代码 
>>> import re
>>> DATA = ()
>>> DATA = (
...     "Mountain View, CA 94040",
...     "Sunnyvale, CA",
...     "Los Altos, 94023",
...     "Cupertino 95014",
...     "Palo Alto CA"
... )
>>> for datum in DATA:
...     print(re.split(", |(?= (?:d{5}|[A-Z]{2})) ", datum))
...
["Mountain View", "CA", "94040"]
["Sunnyvale", "CA"]
["Los Altos", "94023"]
["Cupertino", "95014"]
["Palo Alto", "CA"]

通过使用(?iLmsux)系列选项，用户可以直接在正则表达式里面指定一个或者多个标记。

re.I/re.IGNORECASE, re.M/MULTILINE

</>复制代码 
>>> re.findall(r"(?i)yes", "yes? Yes. YES!~")        # 忽略大小写
["yes", "Yes", "YES"]
>>> re.findall(r"(?i)thw+", "The quickest way is through this tunnel.")    # 忽略大小写
["The", "through", "this"]
>>> re.findall(r"(?im)(^th[w ]+)", """                # 忽略大小写；多行
... This line is the first,
... another line,
... that line, it"s the best.
... """)
["This line is the first", "that line"]

re.S/re.DOTALL

使用re.S,re.DOTALL标记，使得点号.能够用来表示换行符。

</>复制代码 
>>> re.findall(r"th.+", """
... The first line
... the second line
... the third line
... """)
["the second line", "the third line"]
>>> re.findall(r"(?s)th.+", """
... The first line
... the second line
... the third line
... """)
["the second line
the third line
"]

re.X/re.VERBOSE

re.X/re.VERBOSE标记允许用户通过抑制在正则表达式中使用空白符（除了在字符类中或者在反斜线转义中）来创建更易读的正则表达式。

</>复制代码 
>>> re.search(r"""(?x)
...     ((d{3}))     # 匹配区号
...     [ ]             # 匹配空格
...     (d{3})         # 匹配前缀
...     -               # 横线
...     (d{4})         # 终点数字
... """, "(800) 555-1212").groups()
("800", "555", "1212")

(?:...)

通过使用(?:...)符号，可以对部分正则表达式进行分组，但是并不会保存该分组用于后续的检索或应用。

</>复制代码 
>>> re.findall(r"http://(?:w+.)*(w+.com)",
...             "http://goole.com http://www.google.com http://code.google.com")
["goole.com", "google.com", "google.com"]
>>> re.search(r"((?Pd{3})) (?Pd{3})-(?:d{4})",
...             "(800) 555-1212").groupdict()
{"areacode": "800", "prefix": "555"}

结合g，使用(?P) 和 (?P=name)符号。

</>复制代码 
>>> re.sub(r"((?Pd{3})) (?Pd{3})-(?:d{4})",
...     "(g) g-xxxx", "(800) 555-1212")
"(800) 555-xxxx"

检索元组

对于没有命名的元组，使用N，其中N为数字

对于命名的元组，可以使用g，也可以使用N

</>复制代码 
>>> m = re.search(r"(d{4}) (?Pd{4}) (d{3})", "0530 8023 123")
>>> m.group()
"0530 8023 123"
>>> m.group(1)
"0530"
>>> m.group(2)
"8023"
>>> m.group(3)
"123"
>>> m.groupdict()
{"prefix": "8023"}
>>>
>>> re.sub(r"(d{4}) (d{4}) (d{3})", r"3 2 1", "0530 8023 123")
"123 8023 0530"
>>> re.sub(r"(d{4}) (?Pd{4}) (d{3})", r"3 2 1 - g", "0530 8023 123")
"123 8023 0530 - 8023"

在一个相同的正则表达式中重用模式。

</>复制代码 
>>> re.match(r"(?Pd{2})(?P=num)", "1212")            # 只能匹配相同的内容
>>> print(m) if m is None else m.group()
"1212"
>>> m = re.match(r"(?Pd{2})(?P=num)", "1234")        # 不能匹配不同的内容
>>> print(m) if m is None else m.group()
None

</>复制代码 
>>> bool(re.match(r"((?Pd{3})) (?Pd{3})-(?Pd{4}) (?P=areacode)-(?P=prefix)-(?P=number)",
...     "(800) 555-1212 800-555-1212"))
True
>>> bool(re.match(r"""(?x)
...     # match (800) 555-1212, save areacode, prefix, no.
...     ((?Pd{3}))[ ](?Pd{3})-(?Pd{4})
... 
...     # space
...     [ ]
... 
...     # match 800-555-1212
...     (?P=areacode)-(?P=prefix)-(?P=number)
... 
...     # space
...     [ ]
... 
...     # match 18005551212
...     1(?P=areacode)(?P=prefix)(?P=number)
... """, "(800) 555-1212 800-555-1212 18005551212"))
True

前视匹配

可以使用(?=...) 和 (?!...) 符号在目标字符串中实现一个前视匹配，而不必实际使用这些字符串。

(?=...) : 正向前视断言

(?!...) : 负向前视断言

</>复制代码 
>>> re.findall(r"w+(?= van Rossum)",    # 正向前视断言
... """
...     Guido van Rossum
...     Tim Peters
...     Alex Martelli
...     Just van Rossum
...     Raymond Hettinger
... """)
["Guido", "Just"]
>>> re.findall(r"(?m)^s+(?!noreply|postmaster)(w+)",    # 负向前视断言
... """
...     sales@phptr.com
...     postmaster@phptr.com
...     eng@phptr.com
...     noreply@phptr.com
...     admin@phptr.com
... """)
["sales", "eng", "admin"]
>>> ["%s@aw.com" % e.group(1) for e in 
... re.finditer(r"(?m)^s+(?!noreply|postmaster)(w+)",
... """
...     sales@phptr.com
...     postmaster@phptr.com
...     eng@phptr.com
...     noreply@phptr.com
...     admin@phptr.com
... """)]
["sales@aw.com", "eng@aw.com", "admin@aw.com"]

条件正则表达式匹配

(?(id/name)yes-pattern|no-pattern)

</>复制代码 
Will try to match with yes-pattern if the group with given id or name exists, and with no-pattern if it doesn’t. no-pattern is optional and can be omitted. For example, (<)?(w+@w+(?:.w+)+)(?(1)>|$) is a poor email matching pattern, which will match with "" as well as "user@host.com", but not with " nor "user@host.com>".

</>复制代码 
>>> r = r"(<)?(w+@w+(?:.w+)+)(?(1)>|$)"
>>> m = re.match(r, "")
>>> print(m) if m is None else m.group()
""
>>> m = re.match(r, "user@host.com")
>>> print(m) if m is None else m.group()
"user@host.com"
>>> m = re.match(r, ">> print(m) if m is None else m.group()
None
>>> m = re.match(r, "user@host.com>")
>>> print(m) if m is None else m.group()

</>复制代码 
Thu Feb 15 17:32:12 2007::szhkai@qq.com::1123242-3-5

</>复制代码 
>>> s = """
Thu Feb 15 17:41:42 2007::szhkai@qq.com::1123242-3
Sun Jul 22 13:32:25 2007::szhkai@qq.com::1123242-5
The May 12 17:02:52 2007::szhkai@qq.com::1123242-3-5
Thu Apr 18 12:22:42 2007::szhkai@qq.com::12323-3-5
"""
>>> re.findall(r"(?m).+d+-d+-d+", s)
["
The May 12 17:02:52 2007::szhkai@qq.com::1123242-3-5", "
Thu Apr 18 12:22:42 2007::szhkai@qq.com::12323-3-5"]

</>复制代码 
>>> re.findall(r"(?m).+(d+-d+-d+)", s)
["2-3-5", "3-3-5"]

</>复制代码 
>>> re.findall(r"(?m).+?(d+-d+-d+)", s)
["1123242-3-5", "12323-3-5"]

</>复制代码 
>>> m = re.match("blow", "blow")      # 退格键; 没有匹配
>>> print(m) if m is None else m.group()
None
>>> m = re.match("blow", "blow")     # 匹配单词边界
>>> print(m) if m is None else m.group()
"blow"
>>> m = re.match(r"blow", "blow")     # 使用 raw string
>>> print(m) if m is None else m.group()
"blow"

</>复制代码 
# 对于Python2
bovenson@ThinkCentre:~$ python2
Python 2.7.13+ (default, Jul 19 2017, 18:15:03) 
[GCC 6.4.0 20170704] on linux2
Type "help", "copyright", "credits" or "license" for more information.
# 对于Python3
bovenson@ThinkCentre:~$ python3
Python 3.5.4rc1 (default, Jul 25 2017, 08:53:34) 
[GCC 6.4.0 20170704] on linux
Type "help", "copyright", "credits" or "license" for more information.