一分钟了解正则表达式

来，一分钟搞定正则表达式！

首先，先了解正则表达式的整体知识框架，明确其作用和匹配的分类，以及如何重复使用正则表达的方法。

由上图可知，正则表达式的作用是用于字符串匹配、替换和分割。对于替换和分割相对来说，使用python中的re实现比较简单，将会在最后用例子进行简单展示。重点是理解匹配这块，下面将详细讲解匹配。

一、匹配

首先，对于匹配而言，可分为单匹配、全匹配，单匹配是指在字符串中找到一个符合条件的元素即可，全匹配是指匹配到所有符合条件的元素。然后，为了重复使用同一个正则表达式，还可以采用指定的格式来实现效果。

1.1 单匹配

单匹配中分为简单匹配、灵活匹配、按类型匹配、重复匹配、分组匹配这五个方面。

• 简单匹配：直接采用指定字符串进行搜索，即’ '。re.search(‘cat’,‘dog run to cat’);
• 灵活匹配：按照正式的正则表示方式进行匹配，即r’ '的形式。re.search(r’cat’,‘dog run to cat’);
• 按类型匹配：为了规定选择是数字、字母还是任意字符。
• 重复匹配：为规定一个元素是零个、一个还是多个匹配。
• 分组匹配：分组匹配便于后期的查询。

1.1.1 简单匹配

按照给定的字符串，在目标字符串找到符合条件的元素。
因为较为简单，直接上例子，来：

import re
#简单匹配
pattern1 = "cat"
pattern2 = "bird"
string = "dog runs to cat"
print(re.search(pattern1, string))  # <_sre.SRE_Match object; span=(12, 15), match='cat'>
print(re.search(pattern2, string))  # None

1.1.2 灵活匹配

中规中矩地用正则表达式的格式，设置匹配格式，即r’ '。
来看下面这个例子：

import re
ptn = r"r[au]n"   #按格式进行匹配，意为匹配ran或者run
print(re.search(ptn, "dog runs to cat"))    # 匹配结果为：<_sre.SRE_Match object; span=(4, 7), match='run'>
print(re.search(ptn, "dog rauns to cat"))    # None，不存在ran或者run
#还有下面的例子
print(re.search(r"r[A-Z]n", "dog runs to cat"))     # None
print(re.search(r"r[a-z]n", "dog runs to cat"))     # <_sre.SRE_Match object; span=(4, 7), match='run'>
print(re.search(r"r[0-9]n", "dog r2ns to cat"))     # <_sre.SRE_Match object; span=(4, 7), match='r2n'>
print(re.search(r"r[0-9a-z]n", "dog run r2an to cat"))  # <_sre.SRE_Match object; span=(4, 7), match='run'>

1.1.3 按类型匹配

首先，先了解每个规定类型的含义：

\d : 任何数字
\D : 不是数字
\s : 任何 white space, 如 [\t\n\r\f\v]
\S : 不是 white space
\w : 任何大小写字母, 数字和 “” [a-zA-Z0-9]
\W : 不是 \w
\b : 空白字符 (只在某个字的开头或结尾)
\B : 空白字符 (不在某个字的开头或结尾)
\\ : 匹配 \
. : 匹配任何字符 (除了 \n)
^ : 匹配开头
$ : 匹配结尾
? : 前面的字符可有可无

然后，再来看几个实例：

# \d : decimal digit
print(re.search(r"r\dn", "run r4n"))           # <_sre.SRE_Match object; span=(4, 7), match='r4n'>
# \D : any non-decimal digit
print(re.search(r"r\Dn", "run r4n"))           # <_sre.SRE_Match object; span=(0, 3), match='run'>
# \s : any white space [\t\n\r\f\v]
print(re.search(r"r\sn", "r\nn r4n"))          # <_sre.SRE_Match object; span=(0, 3), match='r\nn'>
# \S : opposite to \s, any non-white space
print(re.search(r"r\Sn", "r\nn r4n"))          # <_sre.SRE_Match object; span=(4, 7), match='r4n'>
# \w : [a-zA-Z0-9_]
print(re.search(r"r\wn", "r\nn r4n"))          # <_sre.SRE_Match object; span=(4, 7), match='r4n'>
# \W : opposite to \w
print(re.search(r"r\Wn", "r\nn r4n"))          # <_sre.SRE_Match object; span=(0, 3), match='r\nn'>
# \b : empty string (only at the start or end of the word)
print(re.search(r"\bruns\b", "dog runs to cat"))    # <_sre.SRE_Match object; span=(4, 8), match='runs'>
# \B : empty string (but not at the start or end of a word)
print(re.search(r"\B runs \B", "dog   runs  to cat"))  # <_sre.SRE_Match object; span=(8, 14), match=' runs '>
# \\ : match \
print(re.search(r"runs\\", "runs\ to me"))     # <_sre.SRE_Match object; span=(0, 5), match='runs\\'>
# . : match anything (except \n)
print(re.search(r"r.n", "r[ns to me"))         # <_sre.SRE_Match object; span=(0, 3), match='r[n'>
# ^ : match line beginning
print(re.search(r"^dog", "dog runs to cat"))   # <_sre.SRE_Match object; span=(0, 3), match='dog'>
# $ : match line ending
print(re.search(r"cat$", "dog runs to cat"))   # <_sre.SRE_Match object; span=(12, 15), match='cat'>
# ? : may or may not occur
print(re.search(r"Mon(day)?", "Monday"))       # <_sre.SRE_Match object; span=(0, 6), match='Monday'>
print(re.search(r"Mon(day)?", "Mon"))          # <_sre.SRE_Match object; span=(0, 3), match='Mon'>
#当存在多行时，匹配首字符，可以采用frags=re.M，M表示多行的意思
string = '''dog run to cat,
I run to dog.
'''
print(re.search(r'^I',string))#None
print(re.search(r'^I',string,flags=re.M))#<re.Match object; span=(16, 17), match='I'>

1.1.4 重复匹配

* : 重复零次或多次
+ : 重复一次或多次
{n, m} : 重复 n 至 m 次
{n} : 重复 n 次

来看个例子：

import re
print(re.search(r"ab*", "a"))             # <_sre.SRE_Match object; span=(0, 1), match='a'>
print(re.search(r"ab*", "abbbbb"))        # <_sre.SRE_Match object; span=(0, 6), match='abbbbb'>

# + : occur 1 or more times
print(re.search(r"ab+", "a"))             # None
print(re.search(r"ab+", "abbbbb"))        # <_sre.SRE_Match object; span=(0, 6), match='abbbbb'>

# {n, m} : occur n to m times
print(re.search(r"ab{2,10}", "a"))        # None
print(re.search(r"ab{2,10}", "abbbbb"))   # <_sre.SRE_Match object; span=(0, 6), match='abbbbb'> 

1.1.5 分组匹配

主要使用()可实现分组效果。直接看例子：

import re
match = re.search(r"(\d+), Date: (.+)", "ID: 021523, Date: Feb/12/2017")
print(match.group())                   # 021523, Date: Feb/12/2017
print(match.group(1))                  # 021523
print(match.group(2))                  # Date: Feb/12/2017
#  ?P<名字> 就给这个组定义了一个名字
match = re.search(r"(?P<id>\d+), Date: (?P<date>.+)", "ID: 021523, Date: Feb/12/2017")
print(match.group('id'))                # 021523
print(match.group('date'))              # Date: Feb/12/2017

1.2 全匹配

1.1节中采用的re.search()是单个匹配，找到符合条件的后就不再搜索。想要到达全部查找，可使用re.findall()。
来，上例子：

import re
# findall
print(re.findall(r"r[ua]n", "run ran ren"))    # ['run', 'ran']
# | : or
print(re.findall(r"(run|ran)", "run ran ren")) # ['run', 'ran']

1.3 重复使用正则匹配

如果重复使用同一个正则，可采用re.compile() 。
来，上例子：

import re
#重复使用正则
compiled_re = re.compile(r"r[ua]n")
print(compiled_re.search("dog ran to cat"))  # <_sre.SRE_Match object; span=(4, 7), match='ran'>

二、分割

分割也属于匹配的一种，先是找个符合条件的元素，去除已匹配到的元素，剩下的元素存储到数组中。
采用re.split()，来，上例子：

import re
print(re.split(r"[,;\.]", "a;b,c.d;e"))#由于.本身表示任意字符，需要用转移字符'\'区分           
# 结果：['a', 'b', 'c', 'd', 'e']
print(re.split(r"[,;\.]", "a;b,c.d.f,h;e"))
#结果：['a', 'b', 'c', 'd', 'f', 'h', 'e']

三、替换

先匹配到指定字符，再进行相应的替换。
采用re.sub()，只能匹配到第一个满足条件的元素，并给予替换。
来，上例子：

import re
print(re.sub(r"r[au]ns", "catches", "dog runs to cat"))     
#结果：dog catches to cat
print(re.sub(r"r[au]ns", "catches", "dog runs run ran to cat")) 
#结果：dog catches run ran to cat

---

好啦！一分钟的正则表达式解释完啦，嘿嘿，不知道看完后懂了没？