正则表达式入门学习(1)

        网上好的帖子很多，但是自己查起来比较费时间，想写一个偏应用的，需要的时候拿出来查下，下面就是我自己学习到的内容：

一、正则表达式常见功能：

        1、校验数据的有效性：效验手机号、身份证号

        2、查找符合要求的文本：查找有规律某段数据/代码

        3、对文本进行切割和替换等操作：文本切割、替换等

二、正则表达式基础功能：

        2.1 元字符

        就是指那些在正则表达式中具有特殊意义的专用字符，元字符是构成正则表达式的基本元件。正则就是由一系列的元字符组成的，看到这里相信你也能明白元字符的重要性了吧。

举例1：

要求：
1、第 1 位固定为数字 1；
2、第 2 位可能是 3，4，5，6，7，8，9；
3、第 3 位到第 11 位我们认为可能是 0-9 任意数字。

可以用表达式：
1、1[3456789][0-9]{9}
2、1[3-9][0-9]{9}
3、1[3-9]\d{9}

如果强制一行内容只有这3个条件的话，可以加前后判断：

^表示一行的开头，$表示一行的结尾：
如：
1、^1[3456789][0-9]{9}$
2、^1[3-9][0-9]{9}$
3、^1[3-9]\d{9}$

网友给大家总结的正则网站or软件吧，大家各取所好。

1. https://regex101.com/

2. https://tool.oschina.net/regex/

3. http://tool.chinaz.com/regex/

4. https://www.w3cschool.cn/tools/index?name=re

5. https://c.runoob.com/front-end/854

6. http://tools.haokh.net/Regex

7. Windows 上推荐：RegexBuddy

8. Mac上推荐：Expressions

备注：1中支持账号功能，可以保存后进行分享。2~6都包含大量常用的正则示例。7&8 都需要付费。

2.2 量词与贪婪

        2.2.1贪婪匹配（Greedy）

        首先，我们来看一下贪婪匹配。在正则中，表示次数的量词默认是贪婪的，在贪婪模式下，会尝试尽可能最大长度去匹配。

         首先，我们来看一下在字符串 aaabb 中使用正则 a* 的匹配过程。

        a* 在匹配开头的 a 时，会尝试尽量匹配更多的 a，直到第一个字母 b 不满足要求为止，匹配上三个 a，后面每次匹配时都得到了空字符串。

         相信看到这里你也发现了，贪婪模式的特点就是尽可能进行最大长度匹配。所以要不要使用贪婪模式是根据需求场景来定的。如果我们想尽可能最短匹配呢？那就要用到非贪婪匹配模式了。

        2.2.2 非贪婪匹配（Lazy）

         那么如何将贪婪模式变成非贪婪模式呢？我们可以在量词后面加上英文的问号 (?)，正则就变成了 a*?。此时的匹配结果如下：

        

>>> import re 
>>> re.findall(r'a*', 'aaabb') # 贪婪模式 
['aaa', '', '', ''] 
>>> re.findall(r'a*?', 'aaabb') # 非贪婪模式 
['', 'a', '', 'a', '', 'a', '', '', '']

        这一次我们可以看到，这次匹配到的结果都是单个的 a，就连每个 a 左边的空字符串也匹配上了。 到这里你可能就明白了，非贪婪模式会尽可能短地去匹配，我把这两者之间的区别写到了下面这张图中。

        从下面这个示例中，我们可以很容易看出两者对比上的差异。左右的文本是一样的，其中有两对双引号。不同之处在于，左边的示例中，不加问号时正则是贪婪匹配，匹配上了从第一个引号到最后一个引号之间的所有内容；而右边的图是非贪婪匹配，找到了符合要求的结果。

        2.2.3 独占模式（Possessive）

        不管是贪婪模式，还是非贪婪模式，都需要发生回溯才能完成相应的功能。但是在一些场景下，我们不需要回溯，匹配不上返回失败就好了，因此正则中还有另外一种模式，独占模式，它类似贪婪匹配，但匹配过程不会发生回溯，因此在一些场合下性能会更好。 你可能会问，那什么是回溯呢？我们来看一些例子，例如下面的正则： regex = “xy{1,3}z” text = “xyyz” 在匹配时，y{1,3}会尽可能长地去匹配，当匹配完 xyy 后，由于 y 要尽可能匹配最长，即三个，但字符串中后面是个 z 就会导致匹配不上，这时候正则就会向前回溯，吐出当前字符 z，接着用正则中的 z 去匹配。

        需要注意的是 Python 和 Go 的标准库目前都不支持独占模式，会报错，可以引用regex 模块

        如果你用 a{1,3}+ab 去匹配 aaab 字符串，a{1,3}+ 会把前面三个 a 都用掉，并且不会回溯，这样字符串中内容只剩下 b 了，导致正则中加号后面的 a 匹配不到符合要求的内容，匹配失败。如果是贪婪模式 a{1,3} 或非贪婪模式 a{1,3}? 都可以匹配上。

        这里我简单总结一下，独占模式性能比较好，可以节约匹配的时间和 CPU 资源，但有些情况下并不能满足需求，要想使用这个模式还要看具体需求（比如我们接下来要讲的案例），另外还得看你当前使用的语言或库的支持程度。

        总结：

        正则中量词默认是贪婪匹配，如果想要进行非贪婪匹配需要在量词后面加上问号。贪婪和非贪婪匹配都可能会进行回溯，独占模式也是进行贪婪匹配，但不进行回溯，因此在一些场景下，可以提高匹配的效率，具体能不能用独占模式需要看使用的编程语言的类库的支持情况，以及独占模式能不能满足需求。

举例2：

有一篇英文文章，里面有很多单词，单词和单词之间是用空格隔开的，在引号里面的一到多个单词表示特殊含义，即引号里面的多个单词要看成一个单词。现在你需要提取出文章中所有的单词。我们可以假设文章中除了引号没有其它的标点符号，有什么方法可以解决这个问题呢？如果用正则来解决，你能不能写出一个正则，提取出文章中所有的单词呢（不要求结果去重）？

we found “the little cat” is in the hat, we like “the little cat”

答案有很多种如下：
[a-zA-Z]+|“.+?”            # .+?查找花费74步，不推荐
\w+|“[^”]*”                # 引号里面是非引号出现一到多次，查找花费48步
\w+|“[^”]+”
\w+|“[\w\s]+?”
\w+|“.+?”                # 非贪婪模式，取符合条件的最小情况，查找花费74步，不推荐
^([a-zA-Z]+|"[^"]+")$    # 查找所有单词，不需要^和$
    

2.3 分组与引用

         在大多数正则实现中，多分支选择都是左边的优先。

        

        针对 15 或 18 位数字这个问题，可以看成是 15 位数字，后面 3 位数据有或者没有，你应该很快写出了 \d{15}\d{3}? 。

        示例一： \d{15}\d{3}? 由于 \d{3} 表示三次，加问号非贪婪还是 3 次

        示例二： \d{15}(\d{3})? 在 \d{3} 整体后加问号，表示后面三位有或无

        这时候，必须使用括号将来把表示“三个数字”的\d{3}这一部分括起来，也就是表示成\d{15}(\d{3})?这样。现在就比较清楚了：括号在正则中的功能就是用于分组。简单来理解就是，由多个元字符组成某个部分，应该被看成一个整体的时候，可以用括号括起来表示一个整体，这是括号的一个重要功能。其实用括号括起来还有另外一个作用，那就是“复用”，我接下来会给你讲讲这个作用。

2.3.0分组与编号

        可以使用括号进行分组，被括号括起来的部分“子表达式”会被保存成一个子组。那分组和编号的规则是怎样的呢？其实很简单，用一句话来说就是，第几个括号就是第几个分组。这么说可能不好理解，我们来举一个例子看一下。

         这里有个时间格式 2020-05-10 20:23:05。假设我们想要使用正则提取出里面的日期和时间。

        我们可以写出如图所示的正则，将日期和时间都括号括起来。这个正则中一共有两个分组，日期是第 1 个，时间是第 2 个。

        不保存子组

        在括号里面的会保存成子组，但有些情况下，你可能只想用括号将某些部分看成一个整体，后续不用再用它，类似这种情况，在实际使用时，是没必要保存子组的。这时我们可以在括号里面使用 ?: 不保存子组。

         如果正则中出现了括号，那么我们就认为，这个子表达式在后续可能会再次被引用，所以不保存子组可以提高正则的性能。除此之外呢，这么做还有一些好处，由于子组变少了，正则性能会更好，在子组计数时也更不容易出错。

         那到底啥是不保存子组呢？我们可以理解成，括号只用于归组，把某个部分当成“单个元素”，不分配编号，后面不会再进行这部分的引用。

括号嵌套

        前面讲完了子组和编号，但有些情况会比较复杂，比如在括号嵌套的情况里，我们要看某个括号里面的内容是第几个分组怎么办？不要担心，其实方法很简单，我们只需要数左括号（开括号）是第几个，就可以确定是第几个子组。

        在阿里云简单日志系统中，我们可以使用正则来匹配一行日志的行首。假设时间格式是 2020-05-10 20:23:05 。

        日期分组编号是 1，时间分组编号是 5，年月日对应的分组编号分别是 2，3，4，时分秒的分组编号分别是 6，7，8。

        命名分组

        前面我们讲了分组编号，但由于编号得数在第几个位置，后续如果发现正则有问题，改动了括号的个数，还可能导致编号发生变化，因此一些编程语言提供了命名分组（named grouping），这样和数字相比更容易辨识，不容易出错。命名分组的格式为(?P<分组名>正则)。 比如在 Django 的路由中，命名分组示例如下： 

url(r'^profile/(?P<username>\w+)/$', view_func)

        需要注意的是，刚刚提到的方式命名分组和前面一样，给这个分组分配一个编号，不过你可以使用名称，不用编号，实际上命名分组的编号已经分配好了。不过命名分组并不是所有语言都支持的，在使用时，你需要查阅所用语言正则说明文档，如果支持，那你才可以使用。

分组引用

        在知道了分组引用的编号 （number）后，大部分情况下，我们就可以使用 “反斜扛 + 编号”，即 \number 的方式来进行引用，而 JavaScript 中是通过$编号来引用，如$1。

        JavaScript中，查找时必须用 \ 引用，替换时用 $

         我给到了你一些在常见的编程语言中，分组查找和替换的引用方式：

2.3.1 分组引用在查找中使用

        前面介绍了子组和引用的基本知识，现在我们来看下在正则查找时如何使用分组引用。比如我们要找重复出现的单词，我们使用正则可以很方便地使“前面出现的单词再次出现”，具体要怎么操作呢？我们可以使用 \w+ 来表示一个单词，针对刚刚的问题，我们就可以很容易写出 (\w+) \1 这个正则表达式了。

2.3.2 分组引用在替换中使用

        和查找类似，我们可以使用反向引用，在得到的结果中，去拼出来我们想要的结果。还是使用刚刚日期时间的例子，我们可以很方便地将它替换成， 2020 年 05 月 10 日这样的格式。

        由于这个例子稍微复杂一些，这里我给出一个示例链接方便你学习，不知道学到这里，你有没有觉得子组和引用非常强大呢？

        你可能很好奇，那在编程语言中如何实现这个功能呢？我下面以 Python3 为例，给出一个示例。

>>> import re
>>> test_str = "2020-05-10 20:23:05"
>>> regex = r"((\d{4})-(\d{2})-(\d{2})) ((\d{2}):(\d{2}):(\d{2}))"
>>> subst = r"日期\1 时间\5   \2年\3月\4日 \6时\7分\8秒"
>>> re.sub(regex, subst, test_str)
'日期2020-05-10 时间20:23:05   2020年05月10日 20时23分05秒'

        总结：

        以上是正则中的分组和子组编号相关内容。括号可以将某部分括起来，看成一个整体，也可以保存成一个子组，在后续查找替换的时候使用。分组编号是指，在正则中第几个括号内就是第几个分组，而嵌套括号我们只要看左括号是第几个就可以了。如果不想将括号里面的内容保存成子组，可以在括号里面加上?: 来解决。 搞懂了分组的内容，我们就可以利用分组引用，来实现将“原文本部分内容”，在查找或替换时进行再次利用，达到实现复杂文本的查找和替换工作。甚至在使用一些文本编辑器的时候，不写代码，我们就可以完成文本的查找替换处理工作，这往往可以节约很多开发时间。

举例3：

最后，我们来做一个小练习吧。有一篇英文文章，里面有一些单词连续出现了多次，
我们认为连续出现多次的单词应该是一次，比如： 
the little cat cat is in the hat hat hat, we like it. 
其中 cat 和 hat 连接出现多次，
要求处理后结果是 the little cat is in the hat, we like it.

答案：
查找(\w+) \1
替换\1

查找(\w+)( \1)+
替换\1

最推荐答案：考虑比较全面
查找(\w+) (\s+\1)+       #连续出现多次单词，可能有多个空格，所以用了\s+
替换\1

2.4 匹配模式

        所谓匹配模式，指的是正则中一些改变元字符匹配行为的方式，比如匹配时不区分英文字母大小写。常见的匹配模式有 4 种，分别是不区分大小写模式、点号通配模式、多行模式和注释模式。需要注意的是，这里的“模式”对应的是英文中的 mode，而不是 pattern。有些地方会把正则表达式 pattern 也翻译成模式，你在网上看到的技术文章中讲的正则模式，有可能指的是正则表达式本身，这一点你需要注意区别。

        2.4.1 不区分大小写模式（Case-Insensitive）

        首先，我们来看一下不区分大小写模式。它有什么用呢？学一个知识的时候，我一般喜欢先从它的应用出发，这样有时候更能激发我学习的兴趣，也更容易看到学习成果。 下面我来举个例子说明一下。在进行文本匹配时，我们要关心单词本身的意义。比如要查找单词 cat，我们并不需要关心单词是 CAT、Cat，还是 cat。根据之前我们学到的知识，你可能会把正则写成这样：[Cc][Aa][Tt]，这样写虽然可以达到目的，但不够直观，如果单词比较长，写起来容易出错，阅读起来也比较困难。

那么有没有更好的办法来实现这个需求呢？这时候不区分大小写模式就派上用场了。

        我们前面说了，不区分大小写是匹配模式的一种。当我们把模式修饰符放在整个正则前面时，就表示整个正则表达式都是不区分大小写的。模式修饰符是通过 (? 模式标识) 的方式来表示的。 我们只需要把模式修饰符放在对应的正则前，就可以使用指定的模式了。在不区分大小写模式中，由于不分大小写的英文是 Case-Insensitive，那么对应的模式标识就是 I 的小写字母 i，所以不区分大小写的 cat 就可以写成 (?i)cat。

        

和[Cc][Aa][Tt] 相比，这样是不是清晰简洁了很多呢？

        如果我们想要前面匹配上的结果，和第二次重复时的大小写一致，那该怎么做呢？我们只需要用括号把修饰符和正则 cat 部分括起来，加括号相当于作用范围的限定，让不区分大小写只作用于这个括号里的内容。同样的，我在这里给你放了一个测试链接，你可以自己看一下。

        

        需要注意的是，这里正则写成了 ((?i)cat) \1，而不是 ((?i)(cat)) \1。也就是说，我们给修饰符和 cat 整体加了个括号，而原来 cat 部分的括号去掉了。如果 cat 保留原来的括号，即 ((?i)(cat)) \1，这样正则中就会有两个子组，虽然结果也是对的，但这其实没必要。在上一讲里我们已经讲解了相关的内容，如果忘记了你可以回去复习一下。 到这里，我们再进阶一下。如果用正则匹配，实现部分区分大小写，另一部分不区分大小写，这该如何操作呢？就比如说我现在想要，the cat 中的 the 不区分大小写，cat 区分大小写。 通过上面的学习，你应该能很快写出相应的正则，也就是 ((?i)the) cat。实现的效果如下：

        有一点需要你注意一下，上面讲到的通过修饰符指定匹配模式的方式，在大部分编程语言中都是可以直接使用的，但在 JS 中我们需要使用 /regex/i 来指定匹配模式。在编程语言中通常会提供一些预定义的常量，来进行匹配模式的指定。比如 Python 中可以使用 re.IGNORECASE 或 re.I ，来传入正则函数中来表示不区分大小写。我下面给出了你一个示例，你可以看一下。

>>> import re
>>> re.findall(r"cat", "CAT Cat cat", re.IGNORECASE)
['CAT', 'Cat', 'cat']

到这里简单总结一下不区分大小写模式的要点：

1、不区分大小写模式的指定方式，使用模式修饰符 (?i)；

2、修饰符如果在括号内，作用范围是这个括号内的正则，而不是整个正则；

3、使用编程语言时可以使用预定义好的常量来指定匹配模式。

2.4.2 点号通配模式（Dot All）

        在基础篇的第一讲里，我为你讲解了元字符相关的知识，你还记得英文的点（.）有什么用吗？它可以匹配上任何符号，但不能匹配换行。当我们需要匹配真正的“任意”符号的时候，可以使用 [\s\S] 或 [\d\D] 或 [\w\W] 等。

        但是这么写不够简洁自然，所以正则中提供了一种模式，让英文的点（.）可以匹配上包括换行的任何字符。 这个模式就是点号通配模式，有很多地方把它称作单行匹配模式，但这么说容易造成误解，毕竟它与多行匹配模式没有联系，因此在课程中我们统一用更容易理解的“点号通配模式”。 单行的英文表示是 Single Line，单行模式对应的修饰符是 (?s)，我还是选择用 the cat 来给你举一个点号通配模式的例子。如下图所示：  

      

        需要注意的是，JavaScript 不支持此模式，那么我们就可以使用前面说的[\s\S]等方式替代。在 Ruby 中则是用 Multiline，来表示点号通配模式（单行匹配模式），我猜测设计者的意图是把点（.）号理解成“能匹配多行”。

2.4.3 多行匹配模式（Multiline）

        讲完了点号通配模式，我们再来看看多行匹配模式。通常情况下，^匹配整个字符串的开头，$ 匹配整个字符串的结尾。多行匹配模式改变的就是 ^ 和 $ 的匹配行为。

多行模式的作用在于，使 ^ 和 $ 能匹配上每行的开头或结尾，我们可以使用模式修饰符号 (?m) 来指定这个模式。

        这个模式有什么用呢？在处理日志时，如果日志以时间开头，有一些日志打印了堆栈信息，占用了多行，我们就可以使用多行匹配模式，在日志中匹配到以时间开头的每一行日志。

        值得一提的是，正则中还有 \A 和 \z（Python 中是 \Z） 这两个元字符容易混淆，\A 仅匹配整个字符串的开始，\z 仅匹配整个字符串的结束，在多行匹配模式下，它们的匹配行为不会改变，如果只想匹配整个字符串，而不是匹配每一行，用这个更严谨一些。

        2.4.4 注释模式（Comment）

        在实际工作中，正则可能会很复杂，这就导致编写、阅读和维护正则都会很困难。我们在写代码的时候，通常会在一些关键的地方加上注释，让代码更易于理解。很多语言也支持在正则中添加注释，让正则更容易阅读和维护，这就是正则的注释模式。正则中注释模式是使用 (?#comment) 来表示。

        比如我们可以把单词重复出现一次的正则 (\w+) \1 写成下面这样，这样的话，就算不是很懂正则的人也可以通过注释看懂正则的意思。

(\w+)(?#word) \1(?#word repeat again)

 

在很多编程语言中也提供了 x 模式来书写正则，也可以起到注释的作用。我用 Python3 给你举了一个例子，你可以参考一下。

import re

regex = r'''(?mx)  # 使用多行模式和x模式
^          # 开头
(\d{4})    # 年
(\d{2})    # 月
$          # 结尾
'''

re.findall(regex, '202006\n202007')
# 输出结果 [('2020', '06'), ('2020', '07')]

         需要注意的是在 x 模式下，所有的换行和空格都会被忽略。为了换行和空格的正确使用，我们可以通过把空格放入字符组中，或将空格转义来解决换行和空格的忽略问题。我下面给了你一个示例，你可以看看。

regex = r'''(?mx)
^          # 开头
(\d{4})    # 年
[ ]        # 空格
(\d{2})    # 月
$          # 结尾
'''

re.findall(regex, '2020 06\n2020 07')
# 输出结果 [('2020', '06'), ('2020', '07')]

 总结

        最后，正则中常见的四种匹配模式，分别是：不区分大小写、点号通配模式、多行模式和注释模式。

1、不区分大小写模式，它可以让整个正则或正则中某一部分进行不区分大小写的匹配。

2、点号通配模式也叫单行匹配，改变的是点号的匹配行为，让其可以匹配任何字符，包括换行。

3、多行匹配说的是 ^ 和 $ 的匹配行为，让其可以匹配上每行的开头或结尾。

4、注释模式则可以在正则中添加注释，让正则变得更容易阅读和维护。

举例4：

HTML 标签是不区分大小写的，比如我们要提取网页中的 head 标签中的内容，用正则如何实现呢？

1、(?si)<head>(.*)<\/head>
2、(?si)<head>(.+?)<\/head>
3、(?i)<head>([\s\S]*)<\/head>
4、(?m)^<head(?:(?s).+)head>$

三、正则表达应用

3.1 断言

        什么是断言呢？简单来说，断言是指对匹配到的文本位置有要求。这么说你可能还是没理解，我通过一些例子来给你讲解。你应该知道 \d{11} 能匹配上 11 位数字，但这 11 位数字可能是 18 位身份证号中的一部分。再比如，去查找一个单词，我们要查找 tom，但其它的单词，比如 tomorrow 中也包含了 tom。

        也就是说，在有些情况下，我们对要匹配的文本的位置也有一定的要求。为了解决这个问题，正则中提供了一些结构，只用于匹配位置，而不是文本内容本身，这种结构就是断言。常见的断言有三种：单词边界、行的开始或结束以及环视。

        在讲单词边界具体怎么使用前，我们先来看一下例子。我们想要把下面文本中的 tom 替换成 jerry。注意一下，在文本中出现了 tomorrow 这个单词，tomorrow 也是以 tom 开头的。

替换前：tom asked me if I would go fishing with him tomorrow.
替换后：jerry asked me if I would go fishing with him jerryorrow.

         这显然是错误的，因为明天这个英语单词里面的 tom 也被替换了。

        那正则是如何解决这个问题的呢？单词的组成一般可以用元字符 \w+ 来表示，\w 包括了大小写字母、下划线和数字（即 [A-Za-z0-9_]）。那如果我们能找出单词的边界，也就是当出现了\w 表示的范围以外的字符，比如引号、空格、标点、换行等这些符号，我们就可以在正则中使用\b 来表示单词的边界。 \b 中的 b 可以理解为是边界（Boundary）这个单词的首字母。

根据刚刚学到的内容，在准确匹配单词时，我们使用 \b\w+\b 就可以实现了。 下面我们以 Python3 语言为例子，为你实现上面提到的 “tom 替换成 jerry”：

>>> import re
>>> test_str = "tom asked me if I would go fishing with him tomorrow."
>>> re.sub(r'\btom\b', 'jerry', test_str)
'jerry asked me if I would go fishing with him tomorrow.'

 3.1.2 行的开始或结束

        和单词的边界类似，在正则中还有文本每行的开始和结束，如果我们要求匹配的内容要出现在一行文本开头或结尾，就可以使用 ^ 和 $ 来进行位置界定。 我们先说一下行的结尾是如何判断的。你应该知道换行符号。在计算机中，回车（\r）和换行（\n）其实是两个概念，并且在不同的平台上，换行的表示也是不一样的。我在这里列出了 Windows、Linux、macOS 平台上换行的表示方式。

日志起始行判断

        最常见的例子就是日志收集，我们在收集日志的时候，通常可以指定日志行的开始规则，比如以时间开头，那些不是以时间开头的可能就是打印的堆栈信息。我来给你一个以日期开头，下面每一行都属于同一篇日志的例子。

[2020-05-24 12:13:10] "/home/tu/demo.py"
Traceback (most recent call last):
  File "demo.py", line 1, in <module>
    1/0
ZeroDivisionError: integer division or modulo by zero

 在这种情况下，我们就通过日期时间开头来判断哪一行是日志的第一行，在日期时间后面的日志都属于同一条日志。除非我们看见下一个日期时间的出现，才是下一条日志的开始。

输入数据校验

        在 Web 服务中，我们常常需要对输入的内容进行校验，比如要求输入 6 位数字，我们可以使用 \d{6} 来校验。但你需要注意到，如果用户输入的是 6 位以上的数字呢？在这种情况下，如果不去要求用户录入的 6 位数字必须是行的开头或结尾，就算验证通过了，结果也可能不对。比如下面的示例，在不加行开始和结束符号时，用户输入了 7 位数字，也是能校验通过的：

>>> import re
>>> re.search('\d{6}', "1234567") is not None
True    <-- 能匹配上 (包含6位数字)
>>> re.search('^\d{6}', "1234567") is not None
True    <-- 能匹配上 (以6位数字开头)
>>> re.search('\d{6}$', "1234567") is not None
True    <-- 能匹配上 (以6位数字结尾)
>>> re.search('^\d{6}$', "1234567") is not None
False   <-- 不能匹配上 (只能是6位数字)
>>> re.search('^\d{6}$', "123456") is not None
True    <-- 能匹配上 (只能是6位数字)

        在前面的匹配模式章节中，我们学习过，在多行模式下，^ 和 $ 符号可以匹配每一行的开头或结尾。大部分实现默认不是多行匹配模式，但也有例外，比如 Ruby 中默认是多行模式。所以对于校验输入数据来说，一种更严谨的做法是，使用 \A 和 \z （Python 中使用 \Z） 来匹配整个文本的开头或结尾。

        解决这个问题还有一种做法，我们可以在使用正则校验前，先判断一下字符串的长度，如果不满足长度要求，那就不需要再用正则去判断了。相当于你用正则解决主要的问题，而不是所有问题，这也是前面说的使用正则要克制。

        3.1.环视

        《孟子·梁惠王下》中有一个成语“王顾左右而言他”。其中“王顾左右”可以理解成“环视”，看看左边，再看看右边。在正则中我们有时候也需要瞻前顾后，找准定位。环视就是要求匹配部分的前面或后面要满足（或不满足）某种规则，有些地方也称环视为零宽断言。

        那具体什么时候我们会用到环视呢？我来举个例子。邮政编码的规则是由 6 位数字组成。现在要求你写出一个正则，提取文本中的邮政编码。根据规则，我们很容易就可以写出邮编的组成\d{6}。我们可以使用下面的文本进行测试：

130400  满足要求
465441  满足要求
4654000 长度过长
138001380002 长度过长

 我们发现，7 位数的前 6 位也能匹配上，12 位数匹配上了两次，这显然是不符合要求的。

 也就是说，除了文本本身组成符合这 6 位数的规则外，这 6 位数左边或右边都不能是数字。 正则是通过环视来解决这个问题的。解决这个问题的正则有四种。

你可能觉得名称比较难记住，没关系，我给你一个小口诀，你只要记住了它的功能和写法就行。这个小口诀你可以在心里默念几遍：左尖括号代表看左边，没有尖括号是看右边，感叹号是非的意思。 因此，针对刚刚邮编的问题，就可以写成左边不是数字，右边也不是数字的 6 位数的正则。即 如下：

单词边界用环视表示

        可以思考一下，表示单词边界的 \b 如果用环视的方式来写，应该是怎么写呢？

         这个问题其实比较简单，单词可以用 \w+ 来表示，单词的边界其实就是那些不能组成单词的字符，即左边和右边都不能是组成单词的字符。比如下面这句话：

        the little cat is in the hat the

        左侧是行首，右侧是空格，hat 右侧是行尾，左侧是空格，其它单词左右都是空格。所有单词左右都不是 \w。

        (?<!\w) 表示左边不能是单词组成字符，(?!\w) 右边不能是单词组成字符，即 \b\w+\b 也可以写成 (?<!\w)\w+(?!\w)。

        另外，根据前面学到的知识，非\w 也可以用\W 来表示。那单词的正则可以写成 (?<=\W)\w+(?=\W)。并不推荐在日常工作中这么来表示单词的边界，因为 \b 明显更简洁，也更容易阅读和书写。

总结：

        今天我们学习了正则中断言相关的内容，最常见的断言有三种：单词的边界、行的开始或结束、环视。

        单词的边界是使用 \b 来表示，这个比较简单。而多行模式下，每一行的开始和结束是使用 ^ 和 $ 符号。如果想匹配整个字符串的开始或结束，可以使用 \A 和 \z，它们不受匹配模式的影响。

         最后就是环视，它又分为四种情况：肯定逆向环视、否定逆向环视、肯定顺序环视、否定顺序环视。在使用的时候记住一个方法：有左尖括号代表看左边，没有尖括号是看右边，而感叹号是非的意思。

举例：

前面我们用正则分组引用来实现替换重复出现的单词，其实之前写的正则是不严谨的，在一些场景下，其实是不能正常工作的，你能使用今天学到的知识来完善一下它么？

the little cat cat2 is in the hat hat2, we like it.

需要注意一下，文本中 cat 和 cat2，还有 hat 和 hat2 其实是不同的单词。你应该能想到在 \w+ 左右加上单词边界 \b 来解决这个问题。你可以试一下，真的能像期望的那样工作么？也就是说，在分组引用时，前面的断言还有效么？

1、\b(\w+)\s\1\b
2、(\w+)\s+\1\d\b


思考过程：
v1: 错误版本 (\b\w+\b) \1  ，实际测试还是能匹配到 cat cat2 情况，错在应该对分组后的引用\1加边界限制。
v2: (\w+) \b\1\b   还有优化空间，2个重复单词间的空字符不一定是空格，还可能是 换行符，制表符等。测试链接：https://regex101.com/r/lVOdaq/4
v3: (\w+)\s\b\1\b  在v2基础上优化了空字符匹配。测试链接：https://regex101.com/r/lVOdaq/2

3.2 转义

        在计算机科学与远程通信中，当转义字符放在字符序列中，它将对它后续的几个字符进行替代并解释。通常，判定某字符是否为转义字符由上下文确定。转义字符即标志着转义序列开始的那个字符。

        转义序列通常有两种功能。第一种功能是编码无法用字母表直接表示的特殊数据。第二种功能是用于表示无法直接键盘录入的字符（如回车符）。 我们这节课说的就是第二种情况，转义字符自身和后面的字符看成一个整体，用来表示某种含义。最常见的例子是，C 语言中用反斜线字符“\”作为转义字符，来表示那些不可打印的 ASCII 控制符。另外，在 URI 协议中，请求串中的一些符号有特殊含义，也需要转义，转义字符用的是百分号“%”。之所以把这个字符称为转义字符，是因为它后面的字符，不是原来的意思了。

字符串转义和正则转义

        说完了转义字符，我们再来看一下正则中的转义。正则中也是使用反斜杠进行转义的。 一般来说，正则中 \d 代表的是单个数字，但如果我们想表示成 反斜杠和字母 d，这时候就需要进行转义，写成 \\d，这个就表示反斜杠后面紧跟着一个字母 d。 

需要注意的是，如果你想用代码来测试这个，在程序中表示普通字符串的时候，我们如果要表示反斜杠，通常需要写成两个反斜杠，因为只写一个会被理解成“转义符号”，而不是反斜杠本身。

        下面我给出使用 Python3 来测试的情况，你可以看一下。

>>> import re
>>> re.findall('\\|d', 'a*b+c?\d123d\')  # 字符串没转义"反斜杠"
  File "<input>", line 1
      re.findall('\\|d', 'a*b+c?\d123d\')
                                       ^
SyntaxError: EOL while scanning string literal

>>> re.findall('\\|d', 'a*b+c?\\d123d\\')
[]

看到这里，你内心是不是有很多问号？为什么转义了还不行呢？我们来把正则表达式部分精简一下，看看两个反斜杠在正则中是什么意思。

>>> import re
>>> re.findall('\\', 'a*b+c?\\d123d\\')
Traceback (most recent call last):
 省去部分信息
re.error: bad escape (end of pattern) at position 0

我们发现，正则部分写的两个反斜杠，Python3 处理的时候会报错，认为是转义字符，即认为是单个反斜杠，如果你再进一步测试在正则中写单个反斜杠，你会发现直接报语法错误，你可以自行尝试。 那如何在正则中正确表示“反斜杠”呢？答案是写四个反斜杠。

>>> import re
>>> re.findall('\\\\', 'a*b+c?\\d123d\\')
['\\', '\\']

        你可以想一下，为什么不是三个呢？后面的文本部分，也得要用四个反斜杠表示才是正确的么？到这里，你是不是发现，转义其实没那么简单。

        我来给你详细解释一下这里面的过程，在程序使用过程中，从输入的字符串到正则表达式，其实有两步转换过程，分别是字符串转义和正则转义。

        在正则中正确表示“反斜杠”具体的过程是这样子：我们输入的字符串，四个反斜杠 \\，经过第一步字符串转义，它代表的含义是两个反斜杠 \；这两个反斜杠再经过第二步正则转义，它就可以代表单个反斜杠 \了。

        

        你可以用这个过程，推导一下两个和三个反斜杠的转换过程，这样你就会明白上面报错的原因了。

        那在真正使用的时候，有没有更简单的方法呢？答案是有的，我们尽量使用原生字符串，在 Python 中，可以在正则前面加上小写字母 r 来表示。

>>> import re
>>> re.findall(r'\\', 'a*b+c?\\d123d\\')
['\\', '\\']


如果现在我们要查找比如星号（*）、加号（+）、问号（?）本身，而不是元字符的功能，这时候就需要对其进行转义，直接在前面加上反斜杠就可以了。

>>> import re
>>> re.findall('\+', '+')
['+']


在正则中方括号 [] 和 花括号 {} 只需转义开括号，但圆括号 () 两个都要转义。
>>> import re
>>> re.findall('\(\)\[]\{}', '()[]{}')
['()[]{}']
>>> re.findall('\(\)\[\]\{\}', '()[]{}')  # 方括号和花括号都转义也可以
['()[]{}']

在正则中，圆括号通常用于分组，或者将某个部分看成一个整体，如果只转义开括号或闭括号，正则会认为少了另外一半，所以会报错。

在正则中，圆括号通常用于分组，或者将某个部分看成一个整体，如果只转义开括号或闭括号，正则会认为少了另外一半，所以会报错。
>>> import re
>>> re.escape('\d')  # 反斜杠和字母d转义
'\\\\d'
>>> re.findall(re.escape('\d'), '\d')
['\\d']

>>> re.escape('[+]')  # 中括号和加号
'\\[\\+\\]'
>>> re.findall(re.escape('[+]'), '[+]')
['[+]']

        这个转义函数可以将整个文本转义，一般用于转义用户输入的内容，即把这些内容看成普通字符串去匹配，但你还是得好好注意一下，如果使用普通字符串查找能满足要求，就不要使用正则，因为它简单不容易出问题。下面是一些其他编程语言对应的转义函数，供你参考。

字符组中需要转义的有三种情况

1、脱字符在中括号中，且在第一个位置需要转义：
>>> import re
>>> re.findall(r'[^ab]', '^ab')  # 转义前代表"非"
['^']
>>> re.findall(r'[\^ab]', '^ab')  # 转义后代表普通字符
['^', 'a', 'b']

2、中划线在中括号中，且不在首尾位置：
>>> import re
>>> re.findall(r'[a-c]', 'abc-')  # 中划线在中间，代表"范围"
['a', 'b', 'c']
>>> re.findall(r'[a\-c]', 'abc-')  # 中划线在中间，转义后的
['a', 'c', '-']
>>> re.findall(r'[-ac]', 'abc-')  # 在开头，不需要转义
['a', 'c', '-']
>>> re.findall(r'[ac-]', 'abc-')  # 在结尾，不需要转义
['a', 'c', '-']

3、右括号在中括号中，且不在首位：

>>> import re
>>> re.findall(r'[]ab]', ']ab')  # 右括号不转义，在首位
[']', 'a', 'b']
>>> re.findall(r'[a]b]', ']ab')  # 右括号不转义，不在首位
[]  # 匹配不上，因为含义是 a后面跟上b]
>>> re.findall(r'[a\]b]', ']ab')  # 转义后代表普通字符
[']', 'a', 'b']

字符组中其它的元字符

        一般来说如果我们要想将元字符（.*+?() 之类）表示成它字面上本来的意思，是需要对其进行转义的，但如果它们出现在字符组中括号里，可以不转义。这种情况，一般都是单个长度的元字符，比如点号（.）、星号（*）、加号（+）、问号（?）、左右圆括号等。它们都不再具有特殊含义，而是代表字符本身。但如果在中括号中出现 \d 或 \w 等符号时，他们还是元字符本身的含义。

>>> import re
>>> re.findall(r'[.*+?()]', '[.*+?()]')  # 单个长度的元字符 
['.', '*', '+', '?', '(', ')']
>>> re.findall(r'[\d]', 'd12\\')  # \w，\d等在中括号中还是元字符的功能
['1', '2']  # 匹配上了数字，而不是反斜杠\和字母d

总结：

        正则中转义有些情况下会比较复杂，从录入的字符串文本，到最终的正则表达式，经过了字符串转义和正则转义两个步骤。元字符的转义一般在前面加反斜杠就行，方括号和花括号的转义一般转义开括号就可以，但圆括号两个都需要转义，我们可以借助编程语言中的转义函数来实现转义。另外我们也讲了字符组中三种需要转义的情况，详细的可以参考下面的脑图。

举例：

文本部分是反斜杠，n，换行，反斜杠四个部分组成。正则部分分别是 1 到 4 个反斜杠和字母 n，我用 Python3 写了对应的示例，相应的查找过程是这样子的。解释出这四个示例中的转义过程。

>>> import re
>>> re.findall('\n', '\\n\n\\')
['\n']  # 找到了换行符
>>> re.findall('\\n', '\\n\n\\')
['\n']  # 找到了换行符
>>> re.findall('\\\n', '\\n\n\\')
['\n']  # 找到了换行符
>>> re.findall('\\\\n', '\\n\n\\')
['\\n'] # 找到了反斜杠和字母n



原字符串中，共包含四个字符，第一个字符是 \，第二个是字母n，第三个是换行符，第四个是 \。
四个正则表达式的构造字符串中，
第一个是换行符（正则转义后保持不变，仍然是换行符），
第二个是\和n字母（正则转义后是换行符），
第三个是\和换行符（正则转义后，单个换行符无意义，只剩下换行符），
第四个是\\和换行符（正则转义后为一个斜杠和一个换行符）。
前三个都是找到了换行处，第四个找到了换行符。