百度百科上关于正则表达式的解释：

• 正则表达式，又称规则表达式。（英语：Regular Expression，在代码中常简写为 regex、regexp 或 RE ），计算机科学的一个概念。 正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本。
• 正则表达式是对字符串 （包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为“元字符”）） 操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。正则表达式是一种 文本模式 ，模式描述在搜索文本时要匹配的一个或多个字符串。
• Python 从 1.5 版本开始增加了 re 模块，它提供 Perl 风格的正则表达式模式。re 模块使 Python 语言拥有全部的正则表达式功能。

为了证明正则表达式功能的强大之处，我们先用个小例子体现一下：

例：判断是否是手机号码

未采用正则表达式

# 用之前学过的知识判断输入的是否是手机号码
def isPhoneNumber(str):
    if len(str) != 11:
        return False
    elif str[0] != "1":
        return False
    # 这里只列出了常见的几种手机号码的开头
    elif str[1:3] != "31" and str[1:3] != "32" and str[1:3] != "38" and str[1:3] != "39" and str[1:3] != "47" and str[1:3] != "51" and str[1:3] != "57" and str[1:3] != "78" and str[1:3] != "86" and str[1:3] != "88":
        return False
    for i in range(3, 11):
        if str[i] < "0" or str[i] > "9":
            return False
    return True
phoneNumber = input("请输入您的手机号：")
print(isPhoneNumber(phoneNumber))

采用正则表达式

def isPhoneNumber(phoneNumber):
    pat = r"^1(([3578]\d)|(47))\d{8}$"
    print(re.match(pat, phoneNumber))
phoneNumber = input("请输入您的手机号：")
isPhoneNumber(phoneNumber)

相信你此刻已经感受到了它的强大之处，接下来就让我们开始正则表达式的学习。先来介绍一下 re 模块。

re模块介绍

常用函数

1. re.match()函数：扫描整个字符串，返回从起始位置成功的匹配 语法：re.match(pattern, string, flags=0) pattern 匹配的正则表达式；string 要匹配的字符串；flags 标志位，用于控制正则表达式的匹配方式，常见值如下：（re.I 忽略大小写；re.M 多行匹配）
2. re.search()函数：扫描整个字符串，并返回第一个成功的匹配（ 语法同上 ）
3. findall()函数：扫描整个字符串，并返回结果列表（ 语法同上 ）

代码块

import re
# 扫描整个字符串，注意返回从起始位置成功的匹配
print(re.match("To", "To be a better man !"))  # <_sre.SRE_Match object; span=(0, 2), match='To'>
print(re.match("To", "be To a better man !"))  # None
print(re.match("to", "To be a better man !", flags=re.I))
# 扫描整个字符串，并返回第一个成功的匹配
print(re.search("To", "be To a better man !"))  # <_sre.SRE_Match object; span=(3, 5), match='To'>
# 扫描整个字符串，并返回结果列表
print(re.findall("To", "To be a better man and to make right decision !", flags=re.I))  # ['To', 'to'] 

匹配字符

匹配单个字符

• . 匹配除换行符以外的任意字符
• [123abc] []是字符集和，表示匹配方括号中所包含的任意一个字符
• [^ Mark] 匹配除了 Mark 这几个字母以外的所有字符，中括号里的 ^ 称为脱字符，表示不匹配集合中的字符
• \d 匹配数字，效果同 [0-9]
• \D 匹配非数字字符，效果同 [^0-9]
• \w 匹配数字、字母和下划线，效果同 [0-9a-zA-Z_]
• \W 匹配非数字、字母和下划线，效果同 [^0-9a-zA-Z_]
• \s 匹配任意的空白符（空格、换行、回车、换页、制表），效果同 [ \n\r\f\t]
• \S 匹配任意的非空白符，效果同 [^ \n\r\f\t]

代码块

import re
print(re.findall(".", "To be a \n better man !"))
print(re.findall("[better]", "To be a \n better man !"))
print(re.findall("[^To be a]", "To be a \n better man !"))
print(re.findall("\d", "95 To be a better man ! 0831"))
print(re.findall("\w", "95 To be a better man ! 0831"))
print(re.findall("\s", "95 To be a better man ! 0831"))

锚字符（边界字符）

• ^ 行首匹配，和在 [] 里的 ^ 不是一个意思
• $ 行尾匹配
• \A 匹配字符串的开始，它和 ^ 的区别是，\A 只匹配整个字符串的开头，即使在 re.M 模式下也不会匹配其它行的行首
• \Z 匹配字符串的结尾，它和 $ 的区别是，\Z 只匹配整个字符串的结尾，即使在 re.M 模式下也不会匹配其它行的行尾
• \b 匹配一个单词的边界，也就是指单词和空格间的位置
• \B 匹配非单词边界

代码块

import re
print(re.search("^To", "To be a better man !"))
print(re.search("!$", "To be a better man !"))
print(re.findall("\ATo", "To be a  better man !\nTo be a  better man !", re.M))
print(re.findall("^To", "To be a  better man !\nTo be a  better man !", re.M))
print(re.search(r"er\b", "better"))

匹配多个字符

说明：下方的 x、y、z 均为假设的普通字符，不是正则表达式的元字符，m n 表示非负整数

• (xyz) 匹配小括号内的 xyz (作为一个整体去匹配)
• x? 匹配 0 个或者 1 个 x
• x* 匹配 0 个或者任意多个 x
• x+ 匹配至少一个 x
• x{n} 匹配确定的 n 个 x（ n 是一个非负整数）
• x{n,} 匹配至少 n 个 x
• x{n,m} 匹配至少 n 个最多 m 个 x，注意：n <= m

代码块

import re
# 贪婪匹配，尽可能多的匹配；非贪婪匹配，尽可能少的匹配
print(re.findall(r"(better)", "To be a better man !"))  # ['better']
print(re.findall(r"a?", "aaaaaa"))  # ['a', 'a', 'a', 'a', 'a', 'a', '']
print(re.findall(r"a*", "aaaaaa"))  # ['aaaaaa', '']
print(re.findall(r"a+", "aaaaaaba"))  # ['aaaaaa', 'a']
print(re.findall(r"a{3}", "aaaaaa"))  # ['aaa', 'aaa']
print(re.findall(r"a{4,}", "aaaaaabaaaacaaa"))  # ['aaaaaa', 'aaaa']
print(re.findall(r"a{4,5}", "aaaaaabaaaacaaa"))  # ['aaaaa', 'aaaa']
print(re.findall(r"((M|m)ark)", "Mark mark"))  # [('Mark', 'M'), ('mark', 'm')]

特殊

• *? +? x? 最小匹配，通常都是尽可能多的匹配，可以使用这种方式进行最小匹配

代码块

# 对 * 进行转义，进行非贪婪匹配
print(re.findall(r"//*.*?/*/", r"/* one */ /* two */ "))  # ['/* one */', '/* two */']

大家可以去写一下关于 QQ 、邮箱、电话、用户名、密码、IP地址、URL的正则表达式来练下手。

END

re模块深入了解

字符串切割

# 切割字符串
s = "To   be a better man !"
print(s.split(" "))
print(re.split(r" +", s))  # 以一个或多个空格切割

finditer() 函数

# re.finditer() 函数，与 findall() 类似，扫描整个字符串，返回的是一个迭代器，节省内存
s = "To be a better man! To be a better man! To be a better man!"
x = re.findall(r"(better)", s)
print(x)
i = re.finditer(r"(better)", s)  # 迭代器
while 1:
        j = next(i)
        print(j)
    except StopIteration as e:
        break

字符串的替换和修改

re.sub(pattern, repl, string, count, flags=0) 与 re.subn(…) repl 用来替换的字符串，string 目标字符串，count 最多替换次数

作用：在目标字符串中以正则表达式的规则匹配字符串，再把他们替换成指定的字符串，可以指定替换的次数，如果不指定，替换所有的匹配字符串

区别：前者返回一个被替换的字符串，后者返回一个元组，元组的第一个元素为被替换的字符串，第二个元素为被替换的次数

s = "To be a better better better man!"
print(re.sub(r"(better)", "great", s))
print(type(re.sub(r"(better)", "great", s)))
print(re.subn(r"(better)", "great", s, 2))
print(type(re.subn(r"(better)", "great", s)))

分组 group

# 分组
phone = "010-8888888"
d = re.match(r"((\d{3})-(\d{7}))", phone)
# 使用序号获取对应组的信息，group(0) 代表原始字符串
print(d.group(0))
# 第一组
print(d.group(1))  # 010-8888888
print(d.group(2))  # 010
print(d.group(3))
# 查看匹配的各组的情况
print(d.groups())  # ('010-8888888', '010', '8888888')

编译 compile(pattern, flags=0)

编译：当我们使用正则表达式时，re 模块会做两件事：

1.编译正则表达式，如果正则表达式本身不合法，会报错 2.用编译后的正则表达式去匹配对象，如果编译成正则对象，简化了匹配过程

pat= r"^1(([3578]\d)|(47))\d{8}$"